@stenajs-webui/redux 17.4.1 → 17.7.0

package/dist/index.es.js

@@ -1,675 +1,653 @@
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-var __assign = function() {
-    __assign = Object.assign || function __assign(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-
-function __spreadArray(to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-}
-
-var createRecordObjectReducer = function (reducer) {
-    return function (state, action) {
-        var _a;
-        if (state === void 0) { state = {}; }
-        switch (action.type) {
-            case "RECORD_OBJECT:CLEAR_RECORD": {
-                var recordId = action.recordId;
-                var newState = __assign({}, state);
-                delete newState[recordId];
-                return newState;
-            }
-            case "RECORD_OBJECT:CLEAR_ALL_RECORDS": {
-                return {};
-            }
-            case "RECORD_OBJECT:ACTION": {
-                var recordId = action.recordId, innerAction = action.action;
-                return __assign(__assign({}, state), (_a = {}, _a[recordId] = reducer(state[recordId], innerAction), _a));
-            }
-            default:
-                return state;
-        }
-    };
+(function(){ try {var elementStyle = document.createElement('style'); elementStyle.appendChild(document.createTextNode("")); document.head.appendChild(elementStyle);} catch(e) {console.error('vite-plugin-css-injected-by-js', e);} })();const createRecordObjectReducer = (reducer) => (state = {}, action) => {
+  switch (action.type) {
+    case "RECORD_OBJECT:CLEAR_RECORD": {
+      const { recordId } = action;
+      const newState = { ...state };
+      delete newState[recordId];
+      return newState;
+    }
+    case "RECORD_OBJECT:CLEAR_ALL_RECORDS": {
+      return {};
+    }
+    case "RECORD_OBJECT:ACTION": {
+      const { recordId, action: innerAction } = action;
+      return {
+        ...state,
+        [recordId]: reducer(state[recordId], innerAction)
+      };
+    }
+    default:
+      return state;
+  }
 };
-
-var createRecordObjectActions = function () { return ({
-    recordAction: function (recordId, action) { return ({
-        type: "RECORD_OBJECT:ACTION",
-        action: action,
-        recordId: recordId,
-    }); },
-    clearRecord: function (recordId) { return ({
-        type: "RECORD_OBJECT:CLEAR_RECORD",
-        recordId: recordId,
-    }); },
-    clearAllRecords: function () { return ({
-        type: "RECORD_OBJECT:CLEAR_ALL_RECORDS",
-    }); },
-}); };
-
-var reducerIdGate = function (reducerId, reducer) {
-    return function (state, action) {
-        var newState = state == null ? reducer(undefined, {}) : state;
-        if (!isValidReducerIdGateAction(action)) {
-            return newState;
-        }
-        if (reducerId !== action.reducerId ||
-            action.type !== "REDUCER_ID_GATE:ACTION") {
-            return newState;
-        }
-        return reducer(newState, action.action);
-    };
-};
-var reducerIdGateAction = function (reducerId, action) { return ({
-    type: "REDUCER_ID_GATE:ACTION",
-    action: action,
-    reducerId: reducerId,
-}); };
-var isValidReducerIdGateAction = function (action) {
-    return !!action.action &&
-        action.type === "REDUCER_ID_GATE:ACTION" &&
-        typeof action.reducerId === "string";
+const createRecordObjectActions = () => ({
+  recordAction: (recordId, action) => ({
+    type: "RECORD_OBJECT:ACTION",
+    action,
+    recordId
+  }),
+  clearRecord: (recordId) => ({
+    type: "RECORD_OBJECT:CLEAR_RECORD",
+    recordId
+  }),
+  clearAllRecords: () => ({
+    type: "RECORD_OBJECT:CLEAR_ALL_RECORDS"
+  })
+});
+const reducerIdGate = (reducerId, reducer) => (state, action) => {
+  let newState = state == null ? reducer(void 0, {}) : state;
+  if (!isValidReducerIdGateAction(action)) {
+    return newState;
+  }
+  if (reducerId !== action.reducerId || action.type !== "REDUCER_ID_GATE:ACTION") {
+    return newState;
+  }
+  return reducer(newState, action.action);
 };
-
-var wrapActionWithReducerIdGate = function (reducerId, actionCreator) {
-    return function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        return {
-            type: "REDUCER_ID_GATE:ACTION",
-            reducerId: reducerId,
-            action: actionCreator.apply(void 0, args),
-        };
-    };
-};
-var wrapActionsWithReducerIdGate = function (reducerId, actionCreators) {
-    var boundActionCreators = {};
-    for (var key in actionCreators) {
-        var actionCreator = actionCreators[key];
-        boundActionCreators[key] = wrapActionWithReducerIdGate(reducerId, actionCreator);
-    }
-    return boundActionCreators;
+const reducerIdGateAction = (reducerId, action) => ({
+  type: "REDUCER_ID_GATE:ACTION",
+  action,
+  reducerId
+});
+const isValidReducerIdGateAction = (action) => !!action.action && action.type === "REDUCER_ID_GATE:ACTION" && typeof action.reducerId === "string";
+const wrapActionWithReducerIdGate = (reducerId, actionCreator) => (...args) => {
+  return {
+    type: "REDUCER_ID_GATE:ACTION",
+    reducerId,
+    action: actionCreator(...args)
+  };
 };
-
-var createCommitReducerActions = function (id) {
-    return {
-        setValues: function (values) { return ({
-            type: "COMMIT_REDUCER.SET_VALUES",
-            id: id,
-            values: values,
-        }); },
-        commitValues: function () { return ({
-            type: "COMMIT_REDUCER.COMMIT_VALUES",
-            id: id,
-        }); },
-        clearValues: function () { return ({
-            type: "COMMIT_REDUCER.CLEAR",
-            id: id,
-        }); },
-    };
+const wrapActionsWithReducerIdGate = (reducerId, actionCreators) => {
+  const boundActionCreators = {};
+  for (const key in actionCreators) {
+    const actionCreator = actionCreators[key];
+    boundActionCreators[key] = wrapActionWithReducerIdGate(reducerId, actionCreator);
+  }
+  return boundActionCreators;
 };
-
-var createCommitReducer = function (id, initialState) {
-    return function (state, action) {
-        if (state === void 0) { state = initialState; }
-        if (action.id !== id) {
-            return state;
-        }
-        switch (action.type) {
-            case "COMMIT_REDUCER.SET_VALUES": {
-                var values = action.values;
-                return __assign(__assign({}, state), { workspace: __assign(__assign({}, state.workspace), values) });
-            }
-            case "COMMIT_REDUCER.CLEAR": {
-                return __assign(__assign({}, state), { workspace: __assign({}, initialState.workspace) });
-            }
-            case "COMMIT_REDUCER.COMMIT_VALUES": {
-                return __assign(__assign({}, state), { committed: __assign({}, state.workspace) });
-            }
-            default:
-                return state;
-        }
-    };
+const createCommitReducerActions = (id) => {
+  return {
+    setValues: (values) => ({
+      type: "COMMIT_REDUCER.SET_VALUES",
+      id,
+      values
+    }),
+    commitValues: () => ({
+      type: "COMMIT_REDUCER.COMMIT_VALUES",
+      id
+    }),
+    clearValues: () => ({
+      type: "COMMIT_REDUCER.CLEAR",
+      id
+    })
+  };
 };
-
-var createCommitReducerSelectors = function (id, stateSelector) {
-    return {
-        getWorkspaceValues: function (state) { return stateSelector(state, id).workspace; },
-        getCommittedValues: function (state) { return stateSelector(state, id).committed; },
-    };
+const createCommitReducer = (id, initialState) => (state = initialState, action) => {
+  if (action.id !== id) {
+    return state;
+  }
+  switch (action.type) {
+    case `COMMIT_REDUCER.SET_VALUES`: {
+      const { values } = action;
+      return {
+        ...state,
+        workspace: {
+          ...state.workspace,
+          ...values
+        }
+      };
+    }
+    case `COMMIT_REDUCER.CLEAR`: {
+      return {
+        ...state,
+        workspace: {
+          ...initialState.workspace
+        }
+      };
+    }
+    case `COMMIT_REDUCER.COMMIT_VALUES`: {
+      return {
+        ...state,
+        committed: {
+          ...state.workspace
+        }
+      };
+    }
+    default:
+      return state;
+  }
 };
-
-var createEntityListActions = function () {
-    return {
-        addAtEnd: function (entity) { return ({ type: "ENTITY_LIST:ADD_AT_END", entity: entity }); },
-        addAtStart: function (entity) { return ({
-            entity: entity,
-            type: "ENTITY_LIST:ADD_AT_START",
-        }); },
-        clearList: function () { return ({ type: "ENTITY_LIST:CLEAR_LIST" }); },
-        removeFirst: function () { return ({ type: "ENTITY_LIST:REMOVE_FIRST" }); },
-        removeLast: function () { return ({ type: "ENTITY_LIST:REMOVE_LAST" }); },
-        removeAtIndex: function (index) { return ({
-            type: "ENTITY_LIST:REMOVE_AT_INDEX",
-            index: index,
-        }); },
-        removeByFieldMatch: function (fields) { return ({
-            type: "ENTITY_LIST:REMOVE_BY_FIELD_MATCH",
-            fields: fields,
-        }); },
-        remove: function (entity) { return ({ type: "ENTITY_LIST:REMOVE", entity: entity }); },
-        setList: function (list) { return ({ type: "ENTITY_LIST:SET_LIST", list: list }); },
-        toggle: function (entity) { return ({ type: "ENTITY_LIST:TOGGLE", entity: entity }); },
-        actionByFieldsMatch: function (fields, action) { return ({
-            type: "ENTITY_LIST:ACTION_BY_FIELDS_MATCH",
-            fields: fields,
-            action: action,
-        }); },
-        actionByIndex: function (index, action) { return ({
-            type: "ENTITY_LIST:ACTION_BY_INDEX",
-            index: index,
-            action: action,
-        }); },
-        actionOnAll: function (action) { return ({
-            type: "ENTITY_LIST:ACTION_ON_ALL",
-            action: action,
-        }); },
-    };
+const createCommitReducerSelectors = (id, stateSelector) => {
+  return {
+    getWorkspaceValues: (state) => stateSelector(state, id).workspace,
+    getCommittedValues: (state) => stateSelector(state, id).committed
+  };
 };
-
-var fieldsMatch = function (entity, fields) {
-    var keys = Object.keys(fields);
-    if (keys.length === 0) {
-        return false;
-    }
-    for (var i = 0; i < keys.length; i++) {
-        var key = keys[i];
-        if (entity[key] !== fields[key]) {
-            return false;
-        }
-    }
-    return true;
+const createEntityListActions = () => {
+  return {
+    addAtEnd: (entity) => ({ type: "ENTITY_LIST:ADD_AT_END", entity }),
+    addAtStart: (entity) => ({
+      entity,
+      type: "ENTITY_LIST:ADD_AT_START"
+    }),
+    clearList: () => ({ type: "ENTITY_LIST:CLEAR_LIST" }),
+    removeFirst: () => ({ type: "ENTITY_LIST:REMOVE_FIRST" }),
+    removeLast: () => ({ type: "ENTITY_LIST:REMOVE_LAST" }),
+    removeAtIndex: (index) => ({
+      type: "ENTITY_LIST:REMOVE_AT_INDEX",
+      index
+    }),
+    removeByFieldMatch: (fields) => ({
+      type: "ENTITY_LIST:REMOVE_BY_FIELD_MATCH",
+      fields
+    }),
+    remove: (entity) => ({ type: "ENTITY_LIST:REMOVE", entity }),
+    setList: (list) => ({ type: "ENTITY_LIST:SET_LIST", list }),
+    toggle: (entity) => ({ type: "ENTITY_LIST:TOGGLE", entity }),
+    actionByFieldsMatch: (fields, action) => ({
+      type: "ENTITY_LIST:ACTION_BY_FIELDS_MATCH",
+      fields,
+      action
+    }),
+    actionByIndex: (index, action) => ({
+      type: "ENTITY_LIST:ACTION_BY_INDEX",
+      index,
+      action
+    }),
+    actionOnAll: (action) => ({
+      type: "ENTITY_LIST:ACTION_ON_ALL",
+      action
+    })
+  };
 };
-
-var createEntityListReducer = function (reducer) {
-    return function (state, action) {
-        if (state === void 0) { state = []; }
-        switch (action.type) {
-            case "ENTITY_LIST:SET_LIST": {
-                var list = action.list;
-                return list;
-            }
-            case "ENTITY_LIST:CLEAR_LIST": {
-                return [];
-            }
-            case "ENTITY_LIST:ADD_AT_END": {
-                var entity = action.entity;
-                return __spreadArray(__spreadArray([], state, true), [entity], false);
-            }
-            case "ENTITY_LIST:ADD_AT_START": {
-                var entity = action.entity;
-                return __spreadArray([entity], state, true);
-            }
-            case "ENTITY_LIST:REMOVE_FIRST": {
-                if (state.length === 0) {
-                    throw new Error("Cannot remove, list is empty.");
-                }
-                var list = state.slice(1);
-                return list;
-            }
-            case "ENTITY_LIST:REMOVE_LAST": {
-                if (state.length === 0) {
-                    throw new Error("Cannot remove, list is empty.");
-                }
-                var list = __spreadArray([], state, true);
-                list.pop();
-                return list;
-            }
-            case "ENTITY_LIST:REMOVE_AT_INDEX": {
-                var index = action.index;
-                if (index < 0) {
-                    throw new Error("Index is lower than 0.");
-                }
-                if (index >= state.length) {
-                    throw new Error("Index is outside of list bounds.");
-                }
-                var list = __spreadArray([], state, true);
-                list.splice(index, 1);
-                return list;
-            }
-            case "ENTITY_LIST:REMOVE_BY_FIELD_MATCH": {
-                var fields_1 = action.fields;
-                return state.filter(function (item) { return !fieldsMatch(item, fields_1); });
-            }
-            case "ENTITY_LIST:REMOVE": {
-                var entity_1 = action.entity;
-                return state.filter(function (item) { return item !== entity_1; });
-            }
-            case "ENTITY_LIST:TOGGLE": {
-                var entity_2 = action.entity;
-                var index = state.findIndex(function (item) { return item === entity_2 || fieldsMatch(item, entity_2); });
-                if (index >= 0) {
-                    var list = __spreadArray([], state, true);
-                    list.splice(index, index);
-                    return list;
-                }
-                else {
-                    return __spreadArray(__spreadArray([], state, true), [entity_2], false);
-                }
-            }
-            case "ENTITY_LIST:ACTION_BY_FIELDS_MATCH": {
-                var fields_2 = action.fields, innerAction_1 = action.action;
-                if (!reducer) {
-                    throw new Error("No reducer specified, unable to handle 'actionByFieldsMatch'.");
-                }
-                return state.map(function (item) {
-                    return fieldsMatch(item, fields_2) ? reducer(item, innerAction_1) : item;
-                });
-            }
-            case "ENTITY_LIST:ACTION_BY_INDEX": {
-                var index_1 = action.index, innerAction_2 = action.action;
-                if (!reducer) {
-                    throw new Error("No reducer specified, unable to handle 'actionByIndex'.");
-                }
-                return state.map(function (item, i) {
-                    return index_1 === i ? reducer(item, innerAction_2) : item;
-                });
-            }
-            case "ENTITY_LIST:ACTION_ON_ALL": {
-                var innerAction_3 = action.action;
-                if (!reducer) {
-                    throw new Error("No reducer specified, unable to handle 'actionByIndex'.");
-                }
-                return state.map(function (item) { return reducer(item, innerAction_3); });
-            }
-            default:
-                return state;
-        }
-    };
+const fieldsMatch = (entity, fields) => {
+  const keys = Object.keys(fields);
+  if (keys.length === 0) {
+    return false;
+  }
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (entity[key] !== fields[key]) {
+      return false;
+    }
+  }
+  return true;
 };
-
-var createEntityListSelectors = function (stateSelector) { return ({
-    getList: function (store) { return stateSelector(store); },
-}); };
-
-var entityByIdInitialState = { entities: {} };
-var createEntityByIdReducer = function () {
-    return function (state, action) {
-        var _a, _b;
-        if (state === void 0) { state = entityByIdInitialState; }
-        switch (action.type) {
-            case "ENTITY_BY_ID:SET_ENTITY": {
-                var entity = action.entity;
-                return __assign(__assign({}, state), { entities: __assign(__assign({}, state.entities), (_a = {}, _a[entity.id] = entity, _a)) });
-            }
-            case "ENTITY_BY_ID:SET_ENTITY_FIELDS": {
-                var id = action.id, fields = action.fields;
-                return __assign(__assign({}, state), { entities: __assign(__assign({}, state.entities), (_b = {}, _b[id] = __assign(__assign({}, state.entities[id]), fields), _b)) });
-            }
-            case "ENTITY_BY_ID:CLEAR_ALL_ENTITIES": {
-                return __assign(__assign({}, state), { entities: {} });
-            }
-            case "ENTITY_BY_ID:CLEAR_ENTITY": {
-                var id = action.id;
-                var entities = __assign({}, state.entities);
-                delete entities[id];
-                return __assign(__assign({}, state), { entities: entities });
-            }
-            default:
-                return state;
-        }
-    };
+const createEntityListReducer = (reducer) => (state = [], action) => {
+  switch (action.type) {
+    case "ENTITY_LIST:SET_LIST": {
+      const { list } = action;
+      return list;
+    }
+    case "ENTITY_LIST:CLEAR_LIST": {
+      return [];
+    }
+    case "ENTITY_LIST:ADD_AT_END": {
+      const { entity } = action;
+      return [...state, entity];
+    }
+    case "ENTITY_LIST:ADD_AT_START": {
+      const { entity } = action;
+      return [entity, ...state];
+    }
+    case "ENTITY_LIST:REMOVE_FIRST": {
+      if (state.length === 0) {
+        throw new Error("Cannot remove, list is empty.");
+      }
+      const [, ...list] = state;
+      return list;
+    }
+    case "ENTITY_LIST:REMOVE_LAST": {
+      if (state.length === 0) {
+        throw new Error("Cannot remove, list is empty.");
+      }
+      const list = [...state];
+      list.pop();
+      return list;
+    }
+    case "ENTITY_LIST:REMOVE_AT_INDEX": {
+      const { index } = action;
+      if (index < 0) {
+        throw new Error("Index is lower than 0.");
+      }
+      if (index >= state.length) {
+        throw new Error("Index is outside of list bounds.");
+      }
+      const list = [...state];
+      list.splice(index, 1);
+      return list;
+    }
+    case "ENTITY_LIST:REMOVE_BY_FIELD_MATCH": {
+      const { fields } = action;
+      return state.filter((item) => !fieldsMatch(item, fields));
+    }
+    case "ENTITY_LIST:REMOVE": {
+      const { entity } = action;
+      return state.filter((item) => item !== entity);
+    }
+    case "ENTITY_LIST:TOGGLE": {
+      const { entity } = action;
+      const index = state.findIndex((item) => item === entity || fieldsMatch(item, entity));
+      if (index >= 0) {
+        const list = [...state];
+        list.splice(index, index);
+        return list;
+      } else {
+        return [...state, entity];
+      }
+    }
+    case "ENTITY_LIST:ACTION_BY_FIELDS_MATCH": {
+      const { fields, action: innerAction } = action;
+      if (!reducer) {
+        throw new Error("No reducer specified, unable to handle 'actionByFieldsMatch'.");
+      }
+      return state.map((item) => fieldsMatch(item, fields) ? reducer(item, innerAction) : item);
+    }
+    case "ENTITY_LIST:ACTION_BY_INDEX": {
+      const { index, action: innerAction } = action;
+      if (!reducer) {
+        throw new Error("No reducer specified, unable to handle 'actionByIndex'.");
+      }
+      return state.map((item, i) => index === i ? reducer(item, innerAction) : item);
+    }
+    case "ENTITY_LIST:ACTION_ON_ALL": {
+      const { action: innerAction } = action;
+      if (!reducer) {
+        throw new Error("No reducer specified, unable to handle 'actionByIndex'.");
+      }
+      return state.map((item) => reducer(item, innerAction));
+    }
+    default:
+      return state;
+  }
 };
-
-var createEntityByIdActions = function () { return ({
-    setEntity: function (entity) { return ({
-        type: "ENTITY_BY_ID:SET_ENTITY",
-        entity: entity,
-    }); },
-    setEntityFields: function (id, fields) { return ({
-        type: "ENTITY_BY_ID:SET_ENTITY_FIELDS",
-        id: id,
-        fields: fields,
-    }); },
-    clearEntity: function (id) { return ({
-        type: "ENTITY_BY_ID:CLEAR_ENTITY",
-        id: id,
-    }); },
-    clearAllEntities: function () { return ({
-        type: "ENTITY_BY_ID:CLEAR_ALL_ENTITIES",
-    }); },
-}); };
-
-var createEntityByIdSelectors = function (stateSelector) { return ({
-    getState: stateSelector,
-}); };
-
-var createEntityReducer = function (initialEntity) {
-    var INITIAL_STATE = initialEntity;
-    return function (state, action) {
-        if (state === void 0) { state = INITIAL_STATE; }
-        switch (action.type) {
-            case "ENTITY:SET_ENTITY": {
-                var entity = action.entity;
-                return entity;
-            }
-            case "ENTITY:SET_ENTITY_FIELDS": {
-                var fields = action.fields;
-                return __assign(__assign({}, state), fields);
-            }
-            default:
-                return state;
-        }
-    };
+const createEntityListSelectors = (stateSelector) => ({
+  getList: (store) => stateSelector(store)
+});
+const entityByIdInitialState = { entities: {} };
+const createEntityByIdReducer = () => {
+  return (state = entityByIdInitialState, action) => {
+    switch (action.type) {
+      case "ENTITY_BY_ID:SET_ENTITY": {
+        const { entity } = action;
+        return {
+          ...state,
+          entities: {
+            ...state.entities,
+            [entity.id]: entity
+          }
+        };
+      }
+      case "ENTITY_BY_ID:SET_ENTITY_FIELDS": {
+        const { id, fields } = action;
+        return {
+          ...state,
+          entities: {
+            ...state.entities,
+            [id]: {
+              ...state.entities[id],
+              ...fields
+            }
+          }
+        };
+      }
+      case "ENTITY_BY_ID:CLEAR_ALL_ENTITIES": {
+        return {
+          ...state,
+          entities: {}
+        };
+      }
+      case "ENTITY_BY_ID:CLEAR_ENTITY": {
+        const { id } = action;
+        const entities = {
+          ...state.entities
+        };
+        delete entities[id];
+        return {
+          ...state,
+          entities
+        };
+      }
+      default:
+        return state;
+    }
+  };
 };
-
-var createEntityActions = function () { return ({
-    setEntity: function (entity) { return ({
-        type: "ENTITY:SET_ENTITY",
-        entity: entity,
-    }); },
-    setEntityFields: function (fields) { return ({
-        type: "ENTITY:SET_ENTITY_FIELDS",
-        fields: fields,
-    }); },
-}); };
-
-var createEntitySelectors = function (stateSelector) { return ({
-    getEntity: function (state) { return stateSelector(state); },
-}); };
-
-var createEntityCrudStatusReducer = function () {
-    return createEntityByIdReducer();
-};
-var createEntityCrudStatusActions = function () {
-    return createEntityByIdActions();
-};
-var createEntityCrudStatusSelectors = function (stateSelector) { return createEntityByIdSelectors(stateSelector); };
-var createEntityCrudStatusRedux = function (stateSelector) {
-    var reducer = createEntityCrudStatusReducer();
-    var actions = createEntityCrudStatusActions();
-    var selectors = createEntityCrudStatusSelectors(stateSelector);
-    return {
-        reducer: reducer,
-        actions: actions,
-        selectors: selectors,
-    };
+const createEntityByIdActions = () => ({
+  setEntity: (entity) => ({
+    type: "ENTITY_BY_ID:SET_ENTITY",
+    entity
+  }),
+  setEntityFields: (id, fields) => ({
+    type: "ENTITY_BY_ID:SET_ENTITY_FIELDS",
+    id,
+    fields
+  }),
+  clearEntity: (id) => ({
+    type: "ENTITY_BY_ID:CLEAR_ENTITY",
+    id
+  }),
+  clearAllEntities: () => ({
+    type: "ENTITY_BY_ID:CLEAR_ALL_ENTITIES"
+  })
+});
+const createEntityByIdSelectors = (stateSelector) => ({
+  getState: stateSelector
+});
+const createEntityReducer = (initialEntity) => {
+  const INITIAL_STATE2 = initialEntity;
+  return (state = INITIAL_STATE2, action) => {
+    switch (action.type) {
+      case "ENTITY:SET_ENTITY": {
+        const { entity } = action;
+        return entity;
+      }
+      case "ENTITY:SET_ENTITY_FIELDS": {
+        const { fields } = action;
+        return {
+          ...state,
+          ...fields
+        };
+      }
+      default:
+        return state;
+    }
+  };
 };
-
-var createModifiedFieldRedux = function (stateSelector) {
-    var reducer = createEntityByIdReducer();
-    var selectors = createEntityByIdSelectors(stateSelector);
-    var actions = createEntityByIdActions();
-    return {
-        reducer: reducer,
-        selectors: selectors,
-        actions: actions,
-    };
+const createEntityActions = () => ({
+  setEntity: (entity) => ({
+    type: "ENTITY:SET_ENTITY",
+    entity
+  }),
+  setEntityFields: (fields) => ({
+    type: "ENTITY:SET_ENTITY_FIELDS",
+    fields
+  })
+});
+const createEntitySelectors = (stateSelector) => ({
+  getEntity: (state) => stateSelector(state)
+});
+const createEntityCrudStatusReducer = () => createEntityByIdReducer();
+const createEntityCrudStatusActions = () => createEntityByIdActions();
+const createEntityCrudStatusSelectors = (stateSelector) => createEntityByIdSelectors(stateSelector);
+const createEntityCrudStatusRedux = (stateSelector) => {
+  const reducer = createEntityCrudStatusReducer();
+  const actions = createEntityCrudStatusActions();
+  const selectors = createEntityCrudStatusSelectors(stateSelector);
+  return {
+    reducer,
+    actions,
+    selectors
+  };
 };
-
-var createEditableEntityReducer = function (initialEntity, initialId) {
-    var initialState = {
-        id: initialId,
-        editable: initialEntity,
-        persisted: initialEntity,
-    };
-    return function (state, action) {
-        if (state === void 0) { state = initialState; }
-        switch (action.type) {
-            case "EDITABLE_ENTITY:SET_ENTITY_ID": {
-                var id = action.id;
-                return __assign(__assign({}, state), { id: id });
-            }
-            case "EDITABLE_ENTITY:SET_ENTITY": {
-                var entity = action.entity;
-                return __assign(__assign({}, state), { persisted: entity, editable: entity });
-            }
-            case "EDITABLE_ENTITY:SET_PERSISTED_ENTITY": {
-                var entity = action.entity;
-                return __assign(__assign({}, state), { persisted: entity });
-            }
-            case "EDITABLE_ENTITY:SET_EDITABLE_ENTITY": {
-                var entity = action.entity;
-                return __assign(__assign({}, state), { editable: entity });
-            }
-            case "EDITABLE_ENTITY:SET_EDITABLE_ENTITY_FIELDS": {
-                var fields = action.fields;
-                return __assign(__assign({}, state), { editable: __assign(__assign({}, state.editable), fields) });
-            }
-            case "EDITABLE_ENTITY:REVERT_EDITABLE_ENTITY": {
-                return __assign(__assign({}, state), { editable: state.persisted });
-            }
-            case "EDITABLE_ENTITY:COMMIT_EDITABLE_ENTITY_TO_PERSISTED": {
-                return __assign(__assign({}, state), { persisted: state.editable });
-            }
-            default:
-                return state;
-        }
-    };
+const createModifiedFieldRedux = (stateSelector) => {
+  const reducer = createEntityByIdReducer();
+  const selectors = createEntityByIdSelectors(stateSelector);
+  const actions = createEntityByIdActions();
+  return {
+    reducer,
+    selectors,
+    actions
+  };
 };
-
-var createEditableEntityActions = function () { return ({
-    setEntityId: function (id) { return ({
-        type: "EDITABLE_ENTITY:SET_ENTITY_ID",
-        id: id,
-    }); },
-    setEntity: function (entity) { return ({ type: "EDITABLE_ENTITY:SET_ENTITY", entity: entity }); },
-    setPersistedEntity: function (entity) { return ({
-        type: "EDITABLE_ENTITY:SET_PERSISTED_ENTITY",
-        entity: entity,
-    }); },
-    setEditableEntity: function (entity) { return ({
-        type: "EDITABLE_ENTITY:SET_EDITABLE_ENTITY",
-        entity: entity,
-    }); },
-    setEditableEntityFields: function (fields) { return ({
-        type: "EDITABLE_ENTITY:SET_EDITABLE_ENTITY_FIELDS",
-        fields: fields,
-    }); },
-    revertEditableEntity: function () { return ({
-        type: "EDITABLE_ENTITY:REVERT_EDITABLE_ENTITY",
-    }); },
-    commitEditableEntityToPersisted: function () { return ({
-        type: "EDITABLE_ENTITY:COMMIT_EDITABLE_ENTITY_TO_PERSISTED",
-    }); },
-}); };
-
-var createSelectedIdsReducerInitialState = function (initialSelection) {
-    if (initialSelection === void 0) { initialSelection = []; }
-    return ({
-        selectedIds: initialSelection,
-    });
-};
-var INITIAL_STATE$1 = createSelectedIdsReducerInitialState();
-var createSelectedIdsReducer = function (initialState) {
-    if (initialState === void 0) { initialState = INITIAL_STATE$1; }
-    return function (state, action) {
-        if (state === void 0) { state = initialState; }
-        switch (action.type) {
-            case "SELECTED_IDS:SET_SELECTED_IDS": {
-                var selectedIds = action.selectedIds;
-                return __assign(__assign({}, state), { selectedIds: selectedIds });
-            }
-            case "SELECTED_IDS:CLEAR_SELECTED_IDS": {
-                return __assign(__assign({}, state), { selectedIds: [] });
-            }
-            default:
-                return state;
-        }
-    };
-};
-var selectedIdsReducer = createSelectedIdsReducer();
-
-var createSelectedIdsActions = function () { return ({
-    setSelectedIds: function (selectedIds) { return ({
-        selectedIds: selectedIds,
-        type: "SELECTED_IDS:SET_SELECTED_IDS",
-    }); },
-    clearSelectedIds: function () { return ({
-        type: "SELECTED_IDS:CLEAR_SELECTED_IDS",
-    }); },
-}); };
-var selectedIdsActions = createSelectedIdsActions();
-
-var createSelectedIdsSelectors = function (stateSelector) { return ({
-    getState: stateSelector,
-}); };
-
-var INITIAL_STATE = {
-    ids: undefined,
-};
-var createSortOrderByIdReducer = function () {
-    return function (state, action) {
-        if (state === void 0) { state = INITIAL_STATE; }
-        switch (action.type) {
-            case "SORT_ORDER_BY_ID:SET_SORT_ORDER":
-                return __assign(__assign({}, state), { ids: action.ids });
-            case "SORT_ORDER_BY_ID:CLEAR_SORT_ORDER":
-                return __assign(__assign({}, state), { ids: undefined });
-            default:
-                return state;
-        }
-    };
-};
-var sortOrderByIdReducer = createSortOrderByIdReducer();
-
-var createSortOrderByIdActions = function () {
-    return {
-        setSortOrder: function (ids) { return ({
-            ids: ids,
-            type: "SORT_ORDER_BY_ID:SET_SORT_ORDER",
-        }); },
-        clearSortOrder: function () { return ({
-            type: "SORT_ORDER_BY_ID:CLEAR_SORT_ORDER",
-        }); },
-    };
-};
-var sortOrderByIdActions = createSortOrderByIdActions();
-
-var createSortOrderByIdSelectors = function (rootStateProvider) {
-    return {
-        getSortOrderByIdState: function (state) {
-            return rootStateProvider(state);
-        },
-        getSortOrder: function (state) {
-            return rootStateProvider(state).ids;
-        },
-    };
+const createEditableEntityReducer = (initialEntity, initialId) => {
+  const initialState = {
+    id: initialId,
+    editable: initialEntity,
+    persisted: initialEntity
+  };
+  return (state = initialState, action) => {
+    switch (action.type) {
+      case "EDITABLE_ENTITY:SET_ENTITY_ID": {
+        const { id } = action;
+        return {
+          ...state,
+          id
+        };
+      }
+      case "EDITABLE_ENTITY:SET_ENTITY": {
+        const { entity } = action;
+        return {
+          ...state,
+          persisted: entity,
+          editable: entity
+        };
+      }
+      case "EDITABLE_ENTITY:SET_PERSISTED_ENTITY": {
+        const { entity } = action;
+        return {
+          ...state,
+          persisted: entity
+        };
+      }
+      case "EDITABLE_ENTITY:SET_EDITABLE_ENTITY": {
+        const { entity } = action;
+        return {
+          ...state,
+          editable: entity
+        };
+      }
+      case "EDITABLE_ENTITY:SET_EDITABLE_ENTITY_FIELDS": {
+        const { fields } = action;
+        return {
+          ...state,
+          editable: {
+            ...state.editable,
+            ...fields
+          }
+        };
+      }
+      case "EDITABLE_ENTITY:REVERT_EDITABLE_ENTITY": {
+        return {
+          ...state,
+          editable: state.persisted
+        };
+      }
+      case "EDITABLE_ENTITY:COMMIT_EDITABLE_ENTITY_TO_PERSISTED": {
+        return {
+          ...state,
+          persisted: state.editable
+        };
+      }
+      default:
+        return state;
+    }
+  };
 };
-
-var createSortOrderReducerInitialState = function (sortBy, desc) {
-    if (sortBy === void 0) { sortBy = undefined; }
-    if (desc === void 0) { desc = false; }
-    return ({
-        sortBy: sortBy,
-        desc: desc,
-    });
-};
-var createSortOrderReducer = function (initialState) {
-    if (initialState === void 0) { initialState = { sortBy: undefined, desc: false }; }
-    return function (state, action) {
-        if (state === void 0) { state = initialState; }
-        switch (action.type) {
-            case "SORT_ORDER:SET_SORT_BY": {
-                var sortBy = action.sortBy, desc = action.desc;
-                return __assign(__assign({}, state), { sortBy: sortBy, desc: desc });
-            }
-            case "SORT_ORDER:CLEAR_SORT_ORDER": {
-                return __assign(__assign({}, state), { sortBy: undefined, desc: false });
-            }
-            default:
-                return state;
-        }
-    };
+const createEditableEntityActions = () => ({
+  setEntityId: (id) => ({
+    type: "EDITABLE_ENTITY:SET_ENTITY_ID",
+    id
+  }),
+  setEntity: (entity) => ({ type: "EDITABLE_ENTITY:SET_ENTITY", entity }),
+  setPersistedEntity: (entity) => ({
+    type: "EDITABLE_ENTITY:SET_PERSISTED_ENTITY",
+    entity
+  }),
+  setEditableEntity: (entity) => ({
+    type: "EDITABLE_ENTITY:SET_EDITABLE_ENTITY",
+    entity
+  }),
+  setEditableEntityFields: (fields) => ({
+    type: "EDITABLE_ENTITY:SET_EDITABLE_ENTITY_FIELDS",
+    fields
+  }),
+  revertEditableEntity: () => ({
+    type: "EDITABLE_ENTITY:REVERT_EDITABLE_ENTITY"
+  }),
+  commitEditableEntityToPersisted: () => ({
+    type: "EDITABLE_ENTITY:COMMIT_EDITABLE_ENTITY_TO_PERSISTED"
+  })
+});
+const createSelectedIdsReducerInitialState = (initialSelection = []) => ({
+  selectedIds: initialSelection
+});
+const INITIAL_STATE$1 = createSelectedIdsReducerInitialState();
+const createSelectedIdsReducer = (initialState = INITIAL_STATE$1) => (state = initialState, action) => {
+  switch (action.type) {
+    case "SELECTED_IDS:SET_SELECTED_IDS": {
+      const { selectedIds } = action;
+      return {
+        ...state,
+        selectedIds
+      };
+    }
+    case "SELECTED_IDS:CLEAR_SELECTED_IDS": {
+      return {
+        ...state,
+        selectedIds: []
+      };
+    }
+    default:
+      return state;
+  }
 };
-
-var createSortOrderActions = function () { return ({
-    sortBy: function (sortBy, desc) { return ({
-        desc: desc,
-        sortBy: sortBy,
-        type: "SORT_ORDER:SET_SORT_BY",
-    }); },
-    clearSortOrder: function () { return ({
-        type: "SORT_ORDER:CLEAR_SORT_ORDER",
-    }); },
-}); };
-
-var createSortOrderSelectors = function (stateProvider) { return ({
-    getState: stateProvider,
-}); };
-
-var valueByIdInitialState = { values: {} };
-var createValueByIdReducer = function (initialValue) {
-    if (initialValue === void 0) { initialValue = valueByIdInitialState; }
-    return function (state, action) {
-        var _a;
-        if (state === void 0) { state = initialValue; }
-        switch (action.type) {
-            case "VALUE_BY_ID:SET_VALUE": {
-                var id = action.id, value = action.value;
-                return __assign(__assign({}, state), { values: __assign(__assign({}, state.values), (_a = {}, _a[id] = value, _a)) });
-            }
-            case "VALUE_BY_ID:CLEAR_ALL_VALUES": {
-                return __assign(__assign({}, state), { values: {} });
-            }
-            case "VALUE_BY_ID:CLEAR_VALUE": {
-                var id = action.id;
-                var values = __assign({}, state.values);
-                delete values[id];
-                return __assign(__assign({}, state), { values: values });
-            }
-            default:
-                return state;
-        }
-    };
+const selectedIdsReducer = createSelectedIdsReducer();
+const createSelectedIdsActions = () => ({
+  setSelectedIds: (selectedIds) => ({
+    selectedIds,
+    type: "SELECTED_IDS:SET_SELECTED_IDS"
+  }),
+  clearSelectedIds: () => ({
+    type: "SELECTED_IDS:CLEAR_SELECTED_IDS"
+  })
+});
+const selectedIdsActions = createSelectedIdsActions();
+const createSelectedIdsSelectors = (stateSelector) => ({
+  getState: stateSelector
+});
+const INITIAL_STATE = {
+  ids: void 0
 };
-
-var createValueByIdActions = function () { return ({
-    setValue: function (id, value) { return ({
-        type: "VALUE_BY_ID:SET_VALUE",
-        id: id,
-        value: value,
-    }); },
-    clearValue: function (id) { return ({
-        type: "VALUE_BY_ID:CLEAR_VALUE",
-        id: id,
-    }); },
-    clearAllValues: function () { return ({
-        type: "VALUE_BY_ID:CLEAR_ALL_VALUES",
-    }); },
-}); };
-
-var createValueByIdSelectors = function (stateSelector) { return ({
-    getState: stateSelector,
-}); };
-
+const createSortOrderByIdReducer = () => (state = INITIAL_STATE, action) => {
+  switch (action.type) {
+    case "SORT_ORDER_BY_ID:SET_SORT_ORDER":
+      return {
+        ...state,
+        ids: action.ids
+      };
+    case "SORT_ORDER_BY_ID:CLEAR_SORT_ORDER":
+      return {
+        ...state,
+        ids: void 0
+      };
+    default:
+      return state;
+  }
+};
+const sortOrderByIdReducer = createSortOrderByIdReducer();
+const createSortOrderByIdActions = () => {
+  return {
+    setSortOrder: (ids) => ({
+      ids,
+      type: "SORT_ORDER_BY_ID:SET_SORT_ORDER"
+    }),
+    clearSortOrder: () => ({
+      type: "SORT_ORDER_BY_ID:CLEAR_SORT_ORDER"
+    })
+  };
+};
+const sortOrderByIdActions = createSortOrderByIdActions();
+const createSortOrderByIdSelectors = (rootStateProvider) => {
+  return {
+    getSortOrderByIdState: (state) => {
+      return rootStateProvider(state);
+    },
+    getSortOrder: (state) => {
+      return rootStateProvider(state).ids;
+    }
+  };
+};
+const createSortOrderReducerInitialState = (sortBy = void 0, desc = false) => ({
+  sortBy,
+  desc
+});
+const createSortOrderReducer = (initialState = { sortBy: void 0, desc: false }) => (state = initialState, action) => {
+  switch (action.type) {
+    case "SORT_ORDER:SET_SORT_BY": {
+      const { sortBy, desc } = action;
+      return {
+        ...state,
+        sortBy,
+        desc
+      };
+    }
+    case "SORT_ORDER:CLEAR_SORT_ORDER": {
+      return {
+        ...state,
+        sortBy: void 0,
+        desc: false
+      };
+    }
+    default:
+      return state;
+  }
+};
+const createSortOrderActions = () => ({
+  sortBy: (sortBy, desc) => ({
+    desc,
+    sortBy,
+    type: "SORT_ORDER:SET_SORT_BY"
+  }),
+  clearSortOrder: () => ({
+    type: "SORT_ORDER:CLEAR_SORT_ORDER"
+  })
+});
+const createSortOrderSelectors = (stateProvider) => ({
+  getState: stateProvider
+});
+const valueByIdInitialState = { values: {} };
+const createValueByIdReducer = (initialValue = valueByIdInitialState) => {
+  return (state = initialValue, action) => {
+    switch (action.type) {
+      case "VALUE_BY_ID:SET_VALUE": {
+        const { id, value } = action;
+        return {
+          ...state,
+          values: {
+            ...state.values,
+            [id]: value
+          }
+        };
+      }
+      case "VALUE_BY_ID:CLEAR_ALL_VALUES": {
+        return {
+          ...state,
+          values: {}
+        };
+      }
+      case "VALUE_BY_ID:CLEAR_VALUE": {
+        const { id } = action;
+        const values = {
+          ...state.values
+        };
+        delete values[id];
+        return {
+          ...state,
+          values
+        };
+      }
+      default:
+        return state;
+    }
+  };
+};
+const createValueByIdActions = () => ({
+  setValue: (id, value) => ({
+    type: "VALUE_BY_ID:SET_VALUE",
+    id,
+    value
+  }),
+  clearValue: (id) => ({
+    type: "VALUE_BY_ID:CLEAR_VALUE",
+    id
+  }),
+  clearAllValues: () => ({
+    type: "VALUE_BY_ID:CLEAR_ALL_VALUES"
+  })
+});
+const createValueByIdSelectors = (stateSelector) => ({
+  getState: stateSelector
+});
 export { createCommitReducer, createCommitReducerActions, createCommitReducerSelectors, createEditableEntityActions, createEditableEntityReducer, createEntityActions, createEntityByIdActions, createEntityByIdReducer, createEntityByIdSelectors, createEntityCrudStatusActions, createEntityCrudStatusReducer, createEntityCrudStatusRedux, createEntityCrudStatusSelectors, createEntityListActions, createEntityListReducer, createEntityListSelectors, createEntityReducer, createEntitySelectors, createModifiedFieldRedux, createRecordObjectActions, createRecordObjectReducer, createSelectedIdsActions, createSelectedIdsReducer, createSelectedIdsReducerInitialState, createSelectedIdsSelectors, createSortOrderActions, createSortOrderByIdActions, createSortOrderByIdReducer, createSortOrderByIdSelectors, createSortOrderReducer, createSortOrderReducerInitialState, createSortOrderSelectors, createValueByIdActions, createValueByIdReducer, createValueByIdSelectors, entityByIdInitialState, reducerIdGate, reducerIdGateAction, selectedIdsActions, selectedIdsReducer, sortOrderByIdActions, sortOrderByIdReducer, valueByIdInitialState, wrapActionWithReducerIdGate, wrapActionsWithReducerIdGate };
 //# sourceMappingURL=index.es.js.map