@stenajs-webui/redux 17.13.2 → 17.13.3

package/dist/index.es.js

@@ -1,476 +1,421 @@
-(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) {
+(function(){"use strict";try{var e=document.createElement("style");e.appendChild(document.createTextNode("")),document.head.appendChild(e)}catch(t){console.error("vite-plugin-css-injected-by-js",t)}})();
+const C = (e) => (t = {}, r) => {
+  switch (r.type) {
     case "RECORD_OBJECT:CLEAR_RECORD": {
-      const { recordId } = action;
-      const newState = { ...state };
-      delete newState[recordId];
-      return newState;
+      const { recordId: E } = r, T = { ...t };
+      return delete T[E], T;
     }
-    case "RECORD_OBJECT:CLEAR_ALL_RECORDS": {
+    case "RECORD_OBJECT:CLEAR_ALL_RECORDS":
       return {};
-    }
     case "RECORD_OBJECT:ACTION": {
-      const { recordId, action: innerAction } = action;
+      const { recordId: E, action: T } = r;
       return {
-        ...state,
-        [recordId]: reducer(state[recordId], innerAction)
+        ...t,
+        [E]: e(t[E], T)
       };
     }
     default:
-      return state;
+      return t;
   }
-};
-const createRecordObjectActions = () => ({
-  recordAction: (recordId, action) => ({
+}, p = () => ({
+  recordAction: (e, t) => ({
     type: "RECORD_OBJECT:ACTION",
-    action,
-    recordId
+    action: t,
+    recordId: e
   }),
-  clearRecord: (recordId) => ({
+  clearRecord: (e) => ({
     type: "RECORD_OBJECT:CLEAR_RECORD",
-    recordId
+    recordId: e
   }),
   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);
-};
-const reducerIdGateAction = (reducerId, action) => ({
+}), B = (e, t) => (r, E) => {
+  let T = r == null ? t(void 0, {}) : r;
+  return !d(E) || e !== E.reducerId || E.type !== "REDUCER_ID_GATE:ACTION" ? T : t(T, E.action);
+}, f = (e, t) => ({
   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)
-  };
-};
-const wrapActionsWithReducerIdGate = (reducerId, actionCreators) => {
-  const boundActionCreators = {};
-  for (const key in actionCreators) {
-    const actionCreator = actionCreators[key];
-    boundActionCreators[key] = wrapActionWithReducerIdGate(reducerId, actionCreator);
-  }
-  return boundActionCreators;
-};
-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
-    })
-  };
-};
-const createCommitReducer = (id, initialState) => (state = initialState, action) => {
-  if (action.id !== id) {
-    return state;
+  action: t,
+  reducerId: e
+}), d = (e) => !!e.action && e.type === "REDUCER_ID_GATE:ACTION" && typeof e.reducerId == "string", i = (e, t) => (...r) => ({
+  type: "REDUCER_ID_GATE:ACTION",
+  reducerId: e,
+  action: t(...r)
+}), V = (e, t) => {
+  const r = {};
+  for (const E in t) {
+    const T = t[E];
+    r[E] = i(
+      e,
+      T
+    );
   }
-  switch (action.type) {
-    case `COMMIT_REDUCER.SET_VALUES`: {
-      const { values } = action;
+  return r;
+}, M = (e) => ({
+  setValues: (t) => ({
+    type: "COMMIT_REDUCER.SET_VALUES",
+    id: e,
+    values: t
+  }),
+  commitValues: () => ({
+    type: "COMMIT_REDUCER.COMMIT_VALUES",
+    id: e
+  }),
+  clearValues: () => ({
+    type: "COMMIT_REDUCER.CLEAR",
+    id: e
+  })
+}), w = (e, t) => (r = t, E) => {
+  if (E.id !== e)
+    return r;
+  switch (E.type) {
+    case "COMMIT_REDUCER.SET_VALUES": {
+      const { values: T } = E;
       return {
-        ...state,
+        ...r,
         workspace: {
-          ...state.workspace,
-          ...values
+          ...r.workspace,
+          ...T
         }
       };
     }
-    case `COMMIT_REDUCER.CLEAR`: {
+    case "COMMIT_REDUCER.CLEAR":
       return {
-        ...state,
+        ...r,
         workspace: {
-          ...initialState.workspace
+          ...t.workspace
         }
       };
-    }
-    case `COMMIT_REDUCER.COMMIT_VALUES`: {
+    case "COMMIT_REDUCER.COMMIT_VALUES":
       return {
-        ...state,
+        ...r,
         committed: {
-          ...state.workspace
+          ...r.workspace
         }
       };
-    }
     default:
-      return state;
+      return r;
   }
-};
-const createCommitReducerSelectors = (id, stateSelector) => {
-  return {
-    getWorkspaceValues: (state) => stateSelector(state, id).workspace,
-    getCommittedValues: (state) => stateSelector(state, id).committed
-  };
-};
-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
-    })
-  };
-};
-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;
-    }
+}, h = (e, t) => ({
+  getWorkspaceValues: (r) => t(r, e).workspace,
+  getCommittedValues: (r) => t(r, e).committed
+}), U = () => ({
+  addAtEnd: (e) => ({ type: "ENTITY_LIST:ADD_AT_END", entity: e }),
+  addAtStart: (e) => ({
+    entity: e,
+    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: (e) => ({
+    type: "ENTITY_LIST:REMOVE_AT_INDEX",
+    index: e
+  }),
+  removeByFieldMatch: (e) => ({
+    type: "ENTITY_LIST:REMOVE_BY_FIELD_MATCH",
+    fields: e
+  }),
+  remove: (e) => ({ type: "ENTITY_LIST:REMOVE", entity: e }),
+  setList: (e) => ({ type: "ENTITY_LIST:SET_LIST", list: e }),
+  toggle: (e) => ({ type: "ENTITY_LIST:TOGGLE", entity: e }),
+  actionByFieldsMatch: (e, t) => ({
+    type: "ENTITY_LIST:ACTION_BY_FIELDS_MATCH",
+    fields: e,
+    action: t
+  }),
+  actionByIndex: (e, t) => ({
+    type: "ENTITY_LIST:ACTION_BY_INDEX",
+    index: e,
+    action: t
+  }),
+  actionOnAll: (e) => ({
+    type: "ENTITY_LIST:ACTION_ON_ALL",
+    action: e
+  })
+}), c = (e, t) => {
+  const r = Object.keys(t);
+  if (r.length === 0)
+    return !1;
+  for (let E = 0; E < r.length; E++) {
+    const T = r[E];
+    if (e[T] !== t[T])
+      return !1;
   }
-  return true;
-};
-const createEntityListReducer = (reducer) => (state = [], action) => {
-  switch (action.type) {
+  return !0;
+}, m = (e) => (t = [], r) => {
+  switch (r.type) {
     case "ENTITY_LIST:SET_LIST": {
-      const { list } = action;
-      return list;
+      const { list: E } = r;
+      return E;
     }
-    case "ENTITY_LIST:CLEAR_LIST": {
+    case "ENTITY_LIST:CLEAR_LIST":
       return [];
-    }
     case "ENTITY_LIST:ADD_AT_END": {
-      const { entity } = action;
-      return [...state, entity];
+      const { entity: E } = r;
+      return [...t, E];
     }
     case "ENTITY_LIST:ADD_AT_START": {
-      const { entity } = action;
-      return [entity, ...state];
+      const { entity: E } = r;
+      return [E, ...t];
     }
     case "ENTITY_LIST:REMOVE_FIRST": {
-      if (state.length === 0) {
+      if (t.length === 0)
         throw new Error("Cannot remove, list is empty.");
-      }
-      const [, ...list] = state;
-      return list;
+      const [, ...E] = t;
+      return E;
     }
     case "ENTITY_LIST:REMOVE_LAST": {
-      if (state.length === 0) {
+      if (t.length === 0)
         throw new Error("Cannot remove, list is empty.");
-      }
-      const list = [...state];
-      list.pop();
-      return list;
+      const E = [...t];
+      return E.pop(), E;
     }
     case "ENTITY_LIST:REMOVE_AT_INDEX": {
-      const { index } = action;
-      if (index < 0) {
+      const { index: E } = r;
+      if (E < 0)
         throw new Error("Index is lower than 0.");
-      }
-      if (index >= state.length) {
+      if (E >= t.length)
         throw new Error("Index is outside of list bounds.");
-      }
-      const list = [...state];
-      list.splice(index, 1);
-      return list;
+      const T = [...t];
+      return T.splice(E, 1), T;
     }
     case "ENTITY_LIST:REMOVE_BY_FIELD_MATCH": {
-      const { fields } = action;
-      return state.filter((item) => !fieldsMatch(item, fields));
+      const { fields: E } = r;
+      return t.filter((T) => !c(T, E));
     }
     case "ENTITY_LIST:REMOVE": {
-      const { entity } = action;
-      return state.filter((item) => item !== entity);
+      const { entity: E } = r;
+      return t.filter((T) => T !== E);
     }
     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];
-      }
+      const { entity: E } = r, T = t.findIndex(
+        (n) => n === E || c(n, E)
+      );
+      if (T >= 0) {
+        const n = [...t];
+        return n.splice(T, T), n;
+      } else
+        return [...t, E];
     }
     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);
+      const { fields: E, action: T } = r;
+      if (!e)
+        throw new Error(
+          "No reducer specified, unable to handle 'actionByFieldsMatch'."
+        );
+      return t.map(
+        (n) => c(n, E) ? e(n, T) : n
+      );
     }
     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);
+      const { index: E, action: T } = r;
+      if (!e)
+        throw new Error(
+          "No reducer specified, unable to handle 'actionByIndex'."
+        );
+      return t.map(
+        (n, o) => E === o ? e(n, T) : n
+      );
     }
     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));
+      const { action: E } = r;
+      if (!e)
+        throw new Error(
+          "No reducer specified, unable to handle 'actionByIndex'."
+        );
+      return t.map((T) => e(T, E));
     }
     default:
-      return state;
+      return t;
   }
-};
-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
-            }
+}, v = (e) => ({
+  getList: (t) => e(t)
+}), S = { entities: {} }, I = () => (e = S, t) => {
+  switch (t.type) {
+    case "ENTITY_BY_ID:SET_ENTITY": {
+      const { entity: r } = t;
+      return {
+        ...e,
+        entities: {
+          ...e.entities,
+          [r.id]: r
+        }
+      };
+    }
+    case "ENTITY_BY_ID:SET_ENTITY_FIELDS": {
+      const { id: r, fields: E } = t;
+      return {
+        ...e,
+        entities: {
+          ...e.entities,
+          [r]: {
+            ...e.entities[r],
+            ...E
           }
-        };
-      }
-      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;
+        }
+      };
     }
-  };
-};
-const createEntityByIdActions = () => ({
-  setEntity: (entity) => ({
+    case "ENTITY_BY_ID:CLEAR_ALL_ENTITIES":
+      return {
+        ...e,
+        entities: {}
+      };
+    case "ENTITY_BY_ID:CLEAR_ENTITY": {
+      const { id: r } = t, E = {
+        ...e.entities
+      };
+      return delete E[r], {
+        ...e,
+        entities: E
+      };
+    }
+    default:
+      return e;
+  }
+}, s = () => ({
+  setEntity: (e) => ({
     type: "ENTITY_BY_ID:SET_ENTITY",
-    entity
+    entity: e
   }),
-  setEntityFields: (id, fields) => ({
+  setEntityFields: (e, t) => ({
     type: "ENTITY_BY_ID:SET_ENTITY_FIELDS",
-    id,
-    fields
+    id: e,
+    fields: t
   }),
-  clearEntity: (id) => ({
+  clearEntity: (e) => ({
     type: "ENTITY_BY_ID:CLEAR_ENTITY",
-    id
+    id: e
   }),
   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) {
+}), _ = (e) => ({
+  getState: e
+}), b = (e) => {
+  const t = e;
+  return (r = t, E) => {
+    switch (E.type) {
       case "ENTITY:SET_ENTITY": {
-        const { entity } = action;
-        return entity;
+        const { entity: T } = E;
+        return T;
       }
       case "ENTITY:SET_ENTITY_FIELDS": {
-        const { fields } = action;
+        const { fields: T } = E;
         return {
-          ...state,
-          ...fields
+          ...r,
+          ...T
         };
       }
       default:
-        return state;
+        return r;
     }
   };
-};
-const createEntityActions = () => ({
-  setEntity: (entity) => ({
+}, F = () => ({
+  setEntity: (e) => ({
     type: "ENTITY:SET_ENTITY",
-    entity
+    entity: e
   }),
-  setEntityFields: (fields) => ({
+  setEntityFields: (e) => ({
     type: "ENTITY:SET_ENTITY_FIELDS",
-    fields
+    fields: e
   })
-});
-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);
+}), g = (e) => ({
+  getEntity: (t) => e(t)
+}), R = () => I(), u = () => s(), A = (e) => _(e), x = (e) => {
+  const t = R(), r = u(), E = A(e);
   return {
-    reducer,
-    actions,
-    selectors
+    reducer: t,
+    actions: r,
+    selectors: E
   };
-};
-const createModifiedFieldRedux = (stateSelector) => {
-  const reducer = createEntityByIdReducer();
-  const selectors = createEntityByIdSelectors(stateSelector);
-  const actions = createEntityByIdActions();
+}, G = (e) => {
+  const t = I(), r = _(
+    e
+  ), E = s();
   return {
-    reducer,
-    selectors,
-    actions
+    reducer: t,
+    selectors: r,
+    actions: E
   };
-};
-const createEditableEntityReducer = (initialEntity, initialId) => {
-  const initialState = {
-    id: initialId,
-    editable: initialEntity,
-    persisted: initialEntity
+}, k = (e, t) => {
+  const r = {
+    id: t,
+    editable: e,
+    persisted: e
   };
-  return (state = initialState, action) => {
-    switch (action.type) {
+  return (E = r, T) => {
+    switch (T.type) {
       case "EDITABLE_ENTITY:SET_ENTITY_ID": {
-        const { id } = action;
+        const { id: n } = T;
         return {
-          ...state,
-          id
+          ...E,
+          id: n
         };
       }
       case "EDITABLE_ENTITY:SET_ENTITY": {
-        const { entity } = action;
+        const { entity: n } = T;
         return {
-          ...state,
-          persisted: entity,
-          editable: entity
+          ...E,
+          persisted: n,
+          editable: n
         };
       }
       case "EDITABLE_ENTITY:SET_PERSISTED_ENTITY": {
-        const { entity } = action;
+        const { entity: n } = T;
         return {
-          ...state,
-          persisted: entity
+          ...E,
+          persisted: n
         };
       }
       case "EDITABLE_ENTITY:SET_EDITABLE_ENTITY": {
-        const { entity } = action;
+        const { entity: n } = T;
         return {
-          ...state,
-          editable: entity
+          ...E,
+          editable: n
         };
       }
       case "EDITABLE_ENTITY:SET_EDITABLE_ENTITY_FIELDS": {
-        const { fields } = action;
+        const { fields: n } = T;
         return {
-          ...state,
+          ...E,
           editable: {
-            ...state.editable,
-            ...fields
+            ...E.editable,
+            ...n
           }
         };
       }
-      case "EDITABLE_ENTITY:REVERT_EDITABLE_ENTITY": {
+      case "EDITABLE_ENTITY:REVERT_EDITABLE_ENTITY":
         return {
-          ...state,
-          editable: state.persisted
+          ...E,
+          editable: E.persisted
         };
-      }
-      case "EDITABLE_ENTITY:COMMIT_EDITABLE_ENTITY_TO_PERSISTED": {
+      case "EDITABLE_ENTITY:COMMIT_EDITABLE_ENTITY_TO_PERSISTED":
         return {
-          ...state,
-          persisted: state.editable
+          ...E,
+          persisted: E.editable
         };
-      }
       default:
-        return state;
+        return E;
     }
   };
-};
-const createEditableEntityActions = () => ({
-  setEntityId: (id) => ({
+}, J = () => ({
+  setEntityId: (e) => ({
     type: "EDITABLE_ENTITY:SET_ENTITY_ID",
-    id
+    id: e
   }),
-  setEntity: (entity) => ({ type: "EDITABLE_ENTITY:SET_ENTITY", entity }),
-  setPersistedEntity: (entity) => ({
+  setEntity: (e) => ({ type: "EDITABLE_ENTITY:SET_ENTITY", entity: e }),
+  setPersistedEntity: (e) => ({
     type: "EDITABLE_ENTITY:SET_PERSISTED_ENTITY",
-    entity
+    entity: e
   }),
-  setEditableEntity: (entity) => ({
+  setEditableEntity: (e) => ({
     type: "EDITABLE_ENTITY:SET_EDITABLE_ENTITY",
-    entity
+    entity: e
   }),
-  setEditableEntityFields: (fields) => ({
+  setEditableEntityFields: (e) => ({
     type: "EDITABLE_ENTITY:SET_EDITABLE_ENTITY_FIELDS",
-    fields
+    fields: e
   }),
   revertEditableEntity: () => ({
     type: "EDITABLE_ENTITY:REVERT_EDITABLE_ENTITY"
@@ -478,176 +423,186 @@ const createEditableEntityActions = () => ({
   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) {
+}), L = (e = []) => ({
+  selectedIds: e
+}), l = L(), D = (e = l) => (t = e, r) => {
+  switch (r.type) {
     case "SELECTED_IDS:SET_SELECTED_IDS": {
-      const { selectedIds } = action;
+      const { selectedIds: E } = r;
       return {
-        ...state,
-        selectedIds
+        ...t,
+        selectedIds: E
       };
     }
-    case "SELECTED_IDS:CLEAR_SELECTED_IDS": {
+    case "SELECTED_IDS:CLEAR_SELECTED_IDS":
       return {
-        ...state,
+        ...t,
         selectedIds: []
       };
-    }
     default:
-      return state;
+      return t;
   }
-};
-const selectedIdsReducer = createSelectedIdsReducer();
-const createSelectedIdsActions = () => ({
-  setSelectedIds: (selectedIds) => ({
-    selectedIds,
+}, P = D(), y = () => ({
+  setSelectedIds: (e) => ({
+    selectedIds: e,
     type: "SELECTED_IDS:SET_SELECTED_IDS"
   }),
   clearSelectedIds: () => ({
     type: "SELECTED_IDS:CLEAR_SELECTED_IDS"
   })
-});
-const selectedIdsActions = createSelectedIdsActions();
-const createSelectedIdsSelectors = (stateSelector) => ({
-  getState: stateSelector
-});
-const INITIAL_STATE = {
+}), H = y(), X = (e) => ({
+  getState: e
+}), a = {
   ids: void 0
-};
-const createSortOrderByIdReducer = () => (state = INITIAL_STATE, action) => {
-  switch (action.type) {
+}, N = () => (e = a, t) => {
+  switch (t.type) {
     case "SORT_ORDER_BY_ID:SET_SORT_ORDER":
       return {
-        ...state,
-        ids: action.ids
+        ...e,
+        ids: t.ids
       };
     case "SORT_ORDER_BY_ID:CLEAR_SORT_ORDER":
       return {
-        ...state,
+        ...e,
         ids: void 0
       };
     default:
-      return state;
+      return e;
   }
-};
-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) {
+}, j = N(), O = () => ({
+  setSortOrder: (e) => ({
+    ids: e,
+    type: "SORT_ORDER_BY_ID:SET_SORT_ORDER"
+  }),
+  clearSortOrder: () => ({
+    type: "SORT_ORDER_BY_ID:CLEAR_SORT_ORDER"
+  })
+}), W = O(), $ = (e) => ({
+  getSortOrderByIdState: (t) => e(t),
+  getSortOrder: (t) => e(t).ids
+}), q = (e = void 0, t = !1) => ({
+  sortBy: e,
+  desc: t
+}), z = (e = { sortBy: void 0, desc: !1 }) => (t = e, r) => {
+  switch (r.type) {
     case "SORT_ORDER:SET_SORT_BY": {
-      const { sortBy, desc } = action;
+      const { sortBy: E, desc: T } = r;
       return {
-        ...state,
-        sortBy,
-        desc
+        ...t,
+        sortBy: E,
+        desc: T
       };
     }
-    case "SORT_ORDER:CLEAR_SORT_ORDER": {
+    case "SORT_ORDER:CLEAR_SORT_ORDER":
       return {
-        ...state,
+        ...t,
         sortBy: void 0,
-        desc: false
+        desc: !1
       };
-    }
     default:
-      return state;
+      return t;
   }
-};
-const createSortOrderActions = () => ({
-  sortBy: (sortBy, desc) => ({
-    desc,
-    sortBy,
+}, K = () => ({
+  sortBy: (e, t) => ({
+    desc: t,
+    sortBy: e,
     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;
+}), Q = (e) => ({
+  getState: e
+}), Y = { values: {} }, Z = (e = Y) => (t = e, r) => {
+  switch (r.type) {
+    case "VALUE_BY_ID:SET_VALUE": {
+      const { id: E, value: T } = r;
+      return {
+        ...t,
+        values: {
+          ...t.values,
+          [E]: T
+        }
+      };
     }
-  };
-};
-const createValueByIdActions = () => ({
-  setValue: (id, value) => ({
+    case "VALUE_BY_ID:CLEAR_ALL_VALUES":
+      return {
+        ...t,
+        values: {}
+      };
+    case "VALUE_BY_ID:CLEAR_VALUE": {
+      const { id: E } = r, T = {
+        ...t.values
+      };
+      return delete T[E], {
+        ...t,
+        values: T
+      };
+    }
+    default:
+      return t;
+  }
+}, ee = () => ({
+  setValue: (e, t) => ({
     type: "VALUE_BY_ID:SET_VALUE",
-    id,
-    value
+    id: e,
+    value: t
   }),
-  clearValue: (id) => ({
+  clearValue: (e) => ({
     type: "VALUE_BY_ID:CLEAR_VALUE",
-    id
+    id: e
   }),
   clearAllValues: () => ({
     type: "VALUE_BY_ID:CLEAR_ALL_VALUES"
   })
+}), te = (e) => ({
+  getState: e
 });
-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 };
+export {
+  w as createCommitReducer,
+  M as createCommitReducerActions,
+  h as createCommitReducerSelectors,
+  J as createEditableEntityActions,
+  k as createEditableEntityReducer,
+  F as createEntityActions,
+  s as createEntityByIdActions,
+  I as createEntityByIdReducer,
+  _ as createEntityByIdSelectors,
+  u as createEntityCrudStatusActions,
+  R as createEntityCrudStatusReducer,
+  x as createEntityCrudStatusRedux,
+  A as createEntityCrudStatusSelectors,
+  U as createEntityListActions,
+  m as createEntityListReducer,
+  v as createEntityListSelectors,
+  b as createEntityReducer,
+  g as createEntitySelectors,
+  G as createModifiedFieldRedux,
+  p as createRecordObjectActions,
+  C as createRecordObjectReducer,
+  y as createSelectedIdsActions,
+  D as createSelectedIdsReducer,
+  L as createSelectedIdsReducerInitialState,
+  X as createSelectedIdsSelectors,
+  K as createSortOrderActions,
+  O as createSortOrderByIdActions,
+  N as createSortOrderByIdReducer,
+  $ as createSortOrderByIdSelectors,
+  z as createSortOrderReducer,
+  q as createSortOrderReducerInitialState,
+  Q as createSortOrderSelectors,
+  ee as createValueByIdActions,
+  Z as createValueByIdReducer,
+  te as createValueByIdSelectors,
+  S as entityByIdInitialState,
+  B as reducerIdGate,
+  f as reducerIdGateAction,
+  H as selectedIdsActions,
+  P as selectedIdsReducer,
+  W as sortOrderByIdActions,
+  j as sortOrderByIdReducer,
+  Y as valueByIdInitialState,
+  i as wrapActionWithReducerIdGate,
+  V as wrapActionsWithReducerIdGate
+};
 //# sourceMappingURL=index.es.js.map