Function

Takes an object that maps attribute names to values, and returns it as html formatted attributes.

The result will start with an empty space if the provided object is not empty.

Element.remove() polyfill for IE11 compatibility

Used to ensure that a map built by makeTypeMappedReduxMapFromApiData or makeImmutableOrderedMapFromValueArray is loaded in redux-store

Note that this should only be used in cases where the data is static (e.g. load once, use always), as it does not pass any params to the api or check if any specific data is present. This simply triggers the given action if the map is empty and not already loading.

Escape HTML attribute value.

Get file extension.

Simple util to fetch data from a redux-api-map (which should always be built by makeApiDataMapIsLoading, makeApiDataMapNewData or makeApiDataMapError).

This util will lookup the given id in the given map and return it if it exists. If the entry is missing or loading, null is returned. If the entry is missing (and not already loading), the given dispatchAction is dispatched and null is returned.

Note that this util will still return the object even if it is an error-object (apiError !== null), so you need to handle errors in your component.

Used to fetch the ImmutableOrderedMap of values for a <typeKey> in a structure built by makeTypeMappedReduxMapFromApiData. See its documentation for structure.

If the given <typeKey> is not present in the map, then the entry referenced by TYPE_MAPPED_REDUX_MAP_DEFAULT_KEY will be returned instead.

Returns True if the provided tagName is an inline tag.

Returns True if the provided tagName is a self closing tag.

Used to mark an object in redux-state as deleted.

Util used by all action.js-files in redux/api/*.

This is used to build a common error-format for all redux-map-entries. sets isLoading to false, data to null, timestamp to now.

stores the error in the field apiError formatted like this:

apiError: ImmutableMap({ status: error.response.status, bodydata: ImmutableMap(error.response.bodydata) })

Util used by all action.js-files in redux/api/*. This is used to mark an entry in a redux-map as loading.

sets isLoading to true and apiError to null.

Util used by all action.js-files in redux/api/*. This is used to format data to store in redux-state-map when an api-call is successful.

The given newData is inserted as an ImmutableMap data.

sets isLoading to false, apiError to null and timestamp to now.

Make a custom error "class".

Makes an old style prototype based error class.

Example:

// In myerrors.js
export let MyCustomError = makeCustomError('MyCustomError');

// Using the error
import {MyCustomError} from './myerrors';
throw new MyCustomError('The message');

try {
    throw new MyCustomError('The message', {
         code: 'stuff_happened',
         details: {
             size: 10
         }
    });
} catch(e) {
    if(e instanceof MyCustomError) {
        console.error(`${e.toString()} -- Code: ${e.code}. Size: ${e.details.size}`);
    }
}

let NotFoundError = makeCustomError('NotFoundError');
// error instanceof NotFoundError === true
// error instanceof Error === true

let MyValueError = makeCustomError('MyValueError', TypeError);
let error = new MyValueError();
// error instanceof MyValueError === true
// error instanceof TypeError === true
// error instanceof Error === true

let MySuperError = makeCustomError('MySuperError', TypeError);
let MySubError = makeCustomError('MySubError', MySuperError);
let error = new MySubError();
// error instanceof MySubError === true
// error instanceof MySuperError === true
// error instanceof TypeError === true
// error instanceof Error === true

Make a HTML end tag.

Handles self-closing tags automatically.

Make a HTML start tag.

Handles self-closing tags automatically.

Used for the internal OrderedMap from makeTypeMappedReduxMapFromApiData, and should be used for other type-lists from api.

The only required fieldname on the api-data is value, which will be used as key in the ImmutableOrderedMap

Builds a structure like this: ImmutableOrderedMap({ <valueKey>: ImmutableMap({ label: <some label>, description: <some description>, <otherfield>: <otherfieldkey>, ... }) })

from input-data formatted like this: [ { "value": "<valueKey>", "label": "<some label>", "description": "<some description>", <otherfield>: <otherfieldkey>, ... } ]

Used for apis like nodePaymentSubscriptionTypes and nodeMembershipTypes.

Builds a structure like this: ImmutableMap({ <nodeType>: ImmutableOrderedMap({ <valueKey>: ImmutableMap({ label: <some label>, description: <some description>, <otherfield>: <otherfieldkey>, ... }) }) })

Expects apiResponseBodydata to be formatted like this: { "<nodeType>": [ { "value": "<valueKey>", "label": "<some label>", "description": "<some description>", <otherfield>: <otherfieldkey>, ... } ] }

Wrap a callback that is called when the document is done loading.

Detect the type of an object and return the result as a string.

Handles the following types:

• null (returned as "null").
• undefined (returned as "undefined").
• Number (returned as "number").
• Boolean (returned as "boolean").
• String (returned as "string").
• Array (returned as "array").
• Map (returned as "map").
• Set (returned as "set").
• Function (returned as "function").
• Object (returned as "object").

We do not handle classes - they are returned as "function". We could handle classes, but for Babel classes that will require a fairly expensive and error prone regex.