monorise 0.0.1

package/dist/react/index.js

@@ -0,0 +1,2344 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+
+// actions/app.action.ts
+import { produce } from "immer";
+import { useEffect, useState } from "react";
+var initAppActions = (store2) => {
+  let options = {};
+  const { modals = {} } = options;
+  const startLoading2 = ({
+    requestKey,
+    isInterruptive,
+    message,
+    request: request2
+  }) => {
+    store2.setState(
+      produce((state) => {
+        const stackType = isInterruptive ? "intLoadStack" : "loadStack";
+        const requestKeyCount = state.app[stackType].get(requestKey);
+        state.app.loadingMessage = typeof message === "string" ? message : "Loading";
+        state.app.ongoingRequests.set(requestKey, request2);
+        state.app[stackType].set(
+          requestKey,
+          requestKeyCount ? requestKeyCount + 1 : 1
+        );
+      }),
+      void 0,
+      `mr/start-loading/${requestKey}`
+    );
+  };
+  const endLoading2 = ({ requestKey, isInterruptive }) => {
+    setTimeout(() => {
+      store2.setState(
+        produce((state) => {
+          const stackType = isInterruptive ? "intLoadStack" : "loadStack";
+          const requestKeyCount = state.app[stackType].get(requestKey);
+          if (state.app.ongoingRequests.has(requestKey)) {
+            state.app.ongoingRequests.delete(requestKey);
+          }
+          if (typeof requestKeyCount === "number" && requestKeyCount > 1) {
+            state.app[stackType].set(requestKey, requestKeyCount - 1);
+          } else {
+            state.app[stackType].delete(requestKey);
+          }
+        }),
+        void 0,
+        `mr/end-loading/${requestKey}`
+      );
+    }, 500);
+  };
+  const checkIsLoading = (requestKey) => {
+    const { intLoadStack, loadStack } = store2.getState().app;
+    if (!requestKey) {
+      return intLoadStack.size > 0 || loadStack.size > 0;
+    }
+    const activeIntLoadingCount = intLoadStack.get(requestKey);
+    const isIntLoading = typeof activeIntLoadingCount === "number" && activeIntLoadingCount > 0;
+    const activeLoadingCount = loadStack.get(requestKey);
+    const isLoading = typeof activeLoadingCount === "number" && activeLoadingCount > 0;
+    return isIntLoading || isLoading;
+  };
+  const setError2 = ({ requestKey, error }) => store2.setState(
+    produce((state) => {
+      state.app.errorStack.set(requestKey, error);
+    }),
+    void 0,
+    `mr/set-error/${requestKey}`
+  );
+  const getError2 = (requestKey) => {
+    const { errorStack } = store2.getState().app;
+    return errorStack.get(requestKey);
+  };
+  const clearError2 = (requestKey) => {
+    const { errorStack } = store2.getState().app;
+    if (errorStack.has(requestKey)) {
+      store2.setState(
+        produce((state) => {
+          state.app.errorStack.delete(requestKey);
+        }),
+        void 0,
+        `mr/clear-error/${requestKey}`
+      );
+    }
+  };
+  const openModal2 = (modal) => store2.setState(
+    produce((state) => {
+      state.app.modal = modal;
+    }),
+    void 0,
+    `mr/open-modal/${modal.name}`
+  );
+  const closeModal2 = () => store2.setState(
+    produce((state) => {
+      state.app.modal = { name: null };
+    }),
+    void 0,
+    "mr/close-modal"
+  );
+  const useLoadStore2 = (requestKey) => {
+    const { loadStack, intLoadStack } = store2((state) => ({
+      loadStack: state.app.loadStack,
+      intLoadStack: state.app.intLoadStack
+    }));
+    const [isLoading, setIsLoading] = useState(false);
+    useEffect(() => {
+      if (loadStack && intLoadStack && requestKey) {
+        setIsLoading(checkIsLoading(requestKey));
+      }
+    }, [loadStack, intLoadStack, requestKey]);
+    return isLoading;
+  };
+  const useInterruptiveLoadStore2 = () => {
+    const { intLoadStack, loadingMessage } = store2((state) => ({
+      intLoadStack: state.app.intLoadStack,
+      loadingMessage: state.app.loadingMessage
+    }));
+    return {
+      isLoading: intLoadStack.size > 0,
+      message: loadingMessage
+    };
+  };
+  const useErrorStore2 = (requestKey) => {
+    const error = store2((state) => state.app.errorStack.get(requestKey));
+    useEffect(() => {
+      if (error) {
+        return () => {
+          clearError2(requestKey);
+        };
+      }
+    }, [error, requestKey]);
+    return error;
+  };
+  const useModalStore2 = () => {
+    return store2((state) => state.app.modal);
+  };
+  const setOptions = (opts) => {
+    options = __spreadValues(__spreadValues({}, options), opts);
+  };
+  return {
+    startLoading: startLoading2,
+    endLoading: endLoading2,
+    setError: setError2,
+    getError: getError2,
+    clearError: clearError2,
+    openModal: openModal2,
+    closeModal: closeModal2,
+    checkIsLoading,
+    useLoadStore: useLoadStore2,
+    useInterruptiveLoadStore: useInterruptiveLoadStore2,
+    useErrorStore: useErrorStore2,
+    useModalStore: useModalStore2,
+    setOptions
+  };
+};
+
+// actions/auth.action.ts
+import { produce as produce2 } from "immer";
+var initAuthActions = (store2, authService2) => {
+  const requestLogin2 = async (entityType, payload) => {
+    const { data } = await authService2.requestLoginMagicLink(
+      entityType,
+      payload
+    );
+    return data;
+  };
+  const useProfile2 = () => {
+    const profile = store2((state) => state.auth.profile);
+    return profile;
+  };
+  const getProfile2 = async () => {
+    try {
+      const {
+        data: _a
+      } = await authService2.getSessionProfile(), _b = _a, { displayName, email, accountId } = _b, rest = __objRest(_b, ["displayName", "email", "accountId"]);
+      store2.setState(
+        produce2((state) => {
+          state.auth.profile = __spreadValues({ displayName, email, accountId }, rest);
+          state.auth.isUnauthorized = false;
+          state.auth.isLoading = false;
+        }),
+        void 0,
+        "mr/auth/get-profile"
+      );
+    } catch (e) {
+      store2.setState(
+        produce2((state) => {
+          state.auth.profile = {};
+          state.auth.isUnauthorized = true;
+          state.auth.isLoading = false;
+        }),
+        void 0,
+        "mr/auth/get-profile"
+      );
+    }
+  };
+  const useIsUnauthorized2 = () => {
+    const { isUnauthorized, profile, isLoading } = store2((state) => state.auth);
+    return { isUnauthorized: isUnauthorized && !profile.accountId, isLoading };
+  };
+  const setIsUnauthorized2 = (isUnauthorized) => store2.setState(
+    produce2((state) => {
+      state.auth.isUnauthorized = isUnauthorized;
+    })
+  );
+  const logout2 = () => {
+    authService2.logout();
+    store2.setState(
+      produce2((state) => {
+        state.auth.isUnauthorized = true;
+        state.auth.profile = {};
+      })
+    );
+  };
+  return {
+    requestLogin: requestLogin2,
+    useProfile: useProfile2,
+    getProfile: getProfile2,
+    useIsUnauthorized: useIsUnauthorized2,
+    setIsUnauthorized: setIsUnauthorized2,
+    logout: logout2
+  };
+};
+
+// actions/config.action.ts
+import { produce as produce3 } from "immer";
+var initConfigActions = (store2) => {
+  const setConfig2 = (config) => {
+    const entityMaps = Object.keys(config).reduce(
+      (acc, entity) => {
+        acc[entity] = {
+          dataMap: /* @__PURE__ */ new Map(),
+          isFirstFetched: false,
+          lastKey: ""
+        };
+        return acc;
+      },
+      {}
+    );
+    store2.setState(
+      produce3((state) => {
+        state.config = config;
+        state.entity = entityMaps;
+      })
+    );
+  };
+  const getConfig2 = () => {
+    return store2.getState().config;
+  };
+  const useConfig2 = () => {
+    const config = store2((state) => state.config);
+    return config;
+  };
+  return {
+    setConfig: setConfig2,
+    getConfig: getConfig2,
+    useConfig: useConfig2
+  };
+};
+
+// actions/core.action.ts
+import { produce as produce4 } from "immer";
+import { useEffect as useEffect2, useState as useState2 } from "react";
+
+// lib/entity.ts
+var constructLocal = (entityType, entityId, data) => {
+  return {
+    entityType,
+    entityId,
+    data,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+};
+var constructMutual = (byEntityType, byEntityId2, entityType, entityId, mutualData, data) => {
+  return {
+    mutualId: `${byEntityId2}-${entityId}`,
+    byEntityType,
+    byEntityId: byEntityId2,
+    entityType,
+    entityId,
+    mutualData,
+    data,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    mutualUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+};
+var flipMutual = (mutual) => {
+  return __spreadProps(__spreadValues({}, mutual), {
+    entityId: mutual.byEntityId,
+    entityType: mutual.byEntityType,
+    byEntityId: mutual.entityId,
+    byEntityType: mutual.entityType
+  });
+};
+var byEntityId = (a, b) => {
+  if (b.entityId < a.entityId) return -1;
+  return 1;
+};
+
+// lib/utils.ts
+var convertToMap = (data, mapKey) => {
+  const map = /* @__PURE__ */ new Map();
+  for (const i in data) {
+    map.set(data[i][mapKey], data[i]);
+  }
+  return map;
+};
+var getMutualStateKey = (byEntity, byEntityId2, entity, entityId, chainEntityQuery) => {
+  return `${byEntity}/${byEntityId2}/${entity}${entityId ? `/${entityId}` : ""}${chainEntityQuery ? `?${chainEntityQuery}` : ""}`;
+};
+var getTagStateKey = (entityType, tagName, params = {}) => {
+  const _a = params, { lastKey } = _a, stateParams = __objRest(_a, ["lastKey"]);
+  const paramsKey = Object.keys(stateParams).map((key) => `${key}:${stateParams[key]}`).join("/");
+  return `${entityType}/${tagName}/${paramsKey}`;
+};
+var getUniqueFieldStateKey = (fieldName, fieldValue) => {
+  return `${fieldName}/${fieldValue}`;
+};
+var getEntityRequestKey = (mode, entityType, entityId) => {
+  return `entity/${entityType}/${mode}${entityId ? `/${entityId}` : ""}`;
+};
+var getMutualRequestKey = (mode, byEntityType, entityType, byEntityId2, entityId, chainEntityQuery) => {
+  return `mutual/${getMutualStateKey(byEntityType, byEntityId2, entityType, entityId, chainEntityQuery)}/${mode}`;
+};
+var getTagRequestKey = (mode, entityType, tagName, params = {}) => {
+  return `tag/${getTagStateKey(entityType, tagName, params)}/${mode}`;
+};
+var getUniqueFieldRequestKey = (entityType, fieldName, value) => {
+  return `entity/${entityType}/unique/${getUniqueFieldStateKey(fieldName, value)}`;
+};
+
+// actions/core.action.ts
+var defaultOnError = (error) => {
+  if (!(error instanceof Error) && error.status >= 500) {
+    throw error;
+  }
+};
+var initCoreActions = (monoriseStore, appActions, coreService2) => {
+  const { makeEntityService, makeMutualService } = coreService2;
+  const { checkIsLoading, getError: getError2, useLoadStore: useLoadStore2, useErrorStore: useErrorStore2 } = appActions;
+  const listEntities = async (entityType, params = {}, opts = {}) => {
+    var _a, _b;
+    const store2 = monoriseStore.getState();
+    const entityState = (_a = store2.entity[entityType]) != null ? _a : {};
+    const { isFirstFetched } = entityState;
+    const entityService = makeEntityService(entityType);
+    const { skRange } = params;
+    const requestKey = getEntityRequestKey("list", entityType);
+    const isLoading = checkIsLoading(requestKey);
+    const error = getError2(requestKey);
+    const onError = (_b = opts.onError) != null ? _b : defaultOnError;
+    if (error) {
+      onError(error);
+      return;
+    }
+    if (!opts.forceFetch && (isFirstFetched && !params.skRange || isLoading)) {
+      return;
+    }
+    try {
+      const { data: result } = await entityService.listEntities(
+        __spreadProps(__spreadValues({}, (params == null ? void 0 : params.all) ? {} : { limit: 20 }), {
+          start: skRange == null ? void 0 : skRange.start,
+          end: skRange == null ? void 0 : skRange.end
+        }),
+        opts
+      );
+      const newEntityMap = convertToMap(
+        result.data,
+        "entityId"
+      );
+      const mergedMap = new Map([
+        ...newEntityMap,
+        ...store2.entity[entityType].dataMap
+      ]);
+      monoriseStore.setState(
+        produce4((state) => {
+          state.entity[entityType] = {
+            dataMap: params.skRange ? newEntityMap : mergedMap,
+            isFirstFetched: true,
+            lastKey: result.lastKey
+          };
+        }),
+        void 0,
+        `mr/entity/list/${entityType}`
+      );
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Unknown error occurred");
+      return { error: error2 };
+    }
+  };
+  const listMoreEntities2 = async (entityType, opts = {}) => {
+    var _a;
+    const requestKey = getEntityRequestKey("list", entityType);
+    const store2 = monoriseStore.getState();
+    const entityState = store2.entity[entityType];
+    const { dataMap, lastKey } = entityState;
+    const entityService = makeEntityService(entityType);
+    const error = getError2(requestKey);
+    const onError = (_a = opts.onError) != null ? _a : defaultOnError;
+    if (!lastKey) {
+      return;
+    }
+    if (error) {
+      onError(error);
+      return;
+    }
+    try {
+      const { data: result } = await entityService.listEntities(
+        {
+          limit: 20,
+          lastKey
+        },
+        opts
+      );
+      monoriseStore.setState(
+        produce4((state) => {
+          state.entity[entityType].isFirstFetched = true;
+          state.entity[entityType].lastKey = result.lastKey;
+          for (const i in result.data) {
+            state.entity[entityType].dataMap.set(
+              result.data[i].entityId,
+              result.data[i]
+            );
+          }
+        }),
+        void 0,
+        `mr/entity/list-more/${entityType}`
+      );
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Unknown error occurred");
+      return { error: error2 };
+    }
+  };
+  const searchEntities = async (entityType, query, opts = {}) => {
+    var _a;
+    const requestKey = getEntityRequestKey("search", entityType);
+    const entityService = makeEntityService(entityType);
+    const error = getError2(requestKey);
+    const onError = (_a = opts.onError) != null ? _a : defaultOnError;
+    if (error) {
+      onError(error);
+      return;
+    }
+    try {
+      const { data: result } = await entityService.searchEntities(query, opts);
+      monoriseStore.setState(
+        produce4((state) => {
+          state.entity[entityType].searchResults = result.data;
+          for (const i in result.data) {
+            state.entity[entityType].dataMap.set(
+              result.data[i].entityId,
+              result.data[i]
+            );
+          }
+        })
+      );
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Unknown error occurred");
+      return { error: error2 };
+    }
+  };
+  const listEntitiesByTag = async (entityType, tagName, opts = {}) => {
+    var _a;
+    const tagKey = getTagStateKey(entityType, tagName, opts.params);
+    const state = monoriseStore.getState();
+    const tagState = state.tag[tagKey] || {};
+    const { isFirstFetched, dataMap } = tagState;
+    const entityService = makeEntityService(entityType);
+    const { forceFetch } = opts;
+    const requestKey = getTagRequestKey(
+      "list",
+      entityType,
+      tagName,
+      opts.params
+    );
+    const isLoading = checkIsLoading(requestKey);
+    const error = getError2(requestKey);
+    const onError = (_a = opts.onError) != null ? _a : defaultOnError;
+    if (!forceFetch) {
+      if (error) {
+        onError(error);
+        return { error };
+      }
+      if (isFirstFetched || isLoading) {
+        return {
+          data: {
+            entities: Array.from((dataMap == null ? void 0 : dataMap.values()) || []),
+            lastKey: null
+          }
+        };
+      }
+    }
+    try {
+      const { data } = await entityService.listEntitiesByTag(tagName, __spreadProps(__spreadValues({}, opts), {
+        requestKey
+      }));
+      const { entities, lastKey } = data;
+      monoriseStore.setState(
+        produce4((state2) => {
+          for (const entity of entities) {
+            state2.entity[entityType].dataMap.set(entity.entityId, entity);
+          }
+        })
+      );
+      monoriseStore.setState(
+        produce4((state2) => {
+          if (!state2.tag[tagKey]) {
+            state2.tag[tagKey] = {
+              dataMap: /* @__PURE__ */ new Map(),
+              isFirstFetched: false
+            };
+          }
+          for (const entity of entities) {
+            state2.tag[tagKey].dataMap.set(entity.entityId, entity);
+          }
+          state2.tag[tagKey].isFirstFetched = true;
+          state2.tag[tagKey].lastKey = lastKey;
+        })
+      );
+      return { data };
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Unknown error occurred");
+      return { error: error2 };
+    }
+  };
+  const getEntity2 = async (entityType, id, opts = {}) => {
+    var _a;
+    const store2 = monoriseStore.getState();
+    const entityState = store2.entity[entityType];
+    const { dataMap } = entityState;
+    const entityService = makeEntityService(entityType);
+    let entity = dataMap.get(id);
+    const requestKey = getEntityRequestKey("get", entityType, id);
+    const isLoading = checkIsLoading(requestKey);
+    const error = getError2(requestKey);
+    const { forceFetch } = opts;
+    const onError = (_a = opts.onError) != null ? _a : defaultOnError;
+    if (!forceFetch) {
+      if (error) {
+        onError == null ? void 0 : onError(error);
+        return { error };
+      }
+      if (entity) {
+        return { data: entity };
+      }
+      if (isLoading) {
+        return {};
+      }
+    }
+    try {
+      ({ data: entity } = await entityService.getEntity(id, opts));
+      monoriseStore.setState(
+        produce4((state) => {
+          state.entity[entityType].dataMap.set(entity == null ? void 0 : entity.entityId, entity);
+        }),
+        void 0,
+        `mr/entity/get/${entityType}/${id}`
+      );
+      return { data: entity };
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Unknown error occurred");
+      return { error: error2 };
+    }
+  };
+  const getEntityByUniqueField = async (entityType, fieldName, value, opts = {}) => {
+    var _a;
+    const store2 = monoriseStore.getState();
+    const entityState = store2.entity[entityType];
+    const { dataMap } = entityState;
+    const entityService = makeEntityService(entityType);
+    const stateKey = getUniqueFieldStateKey(fieldName, value);
+    let entity = dataMap.get(stateKey);
+    const requestKey = getUniqueFieldRequestKey(entityType, fieldName, value);
+    const isLoading = checkIsLoading(requestKey);
+    const error = getError2(requestKey);
+    const { forceFetch } = opts;
+    const onError = (_a = opts.onError) != null ? _a : defaultOnError;
+    if (!forceFetch) {
+      if (error) {
+        onError == null ? void 0 : onError(error);
+        return { error };
+      }
+      if (entity) {
+        return { data: entity };
+      }
+      if (isLoading) {
+        return {};
+      }
+    }
+    try {
+      ({ data: entity } = await entityService.getEntityByUniqueField(
+        fieldName,
+        value,
+        opts
+      ));
+      monoriseStore.setState(
+        produce4((state) => {
+          state.entity[entityType].dataMap.set(entity == null ? void 0 : entity.entityId, entity);
+          state.entity[entityType].dataMap.set(`${stateKey}`, entity);
+        }),
+        void 0,
+        `mr/entity/unique/${entityType}/${stateKey}`
+      );
+      return { data: entity };
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Unknown error occurred");
+      return { error: error2 };
+    }
+  };
+  const createEntity2 = async (entityType, entity, opts = {}) => {
+    var _a;
+    const entityService = makeEntityService(entityType);
+    const onError = (_a = opts.onError) != null ? _a : defaultOnError;
+    try {
+      const { data } = await entityService.createEntity(entity, opts);
+      monoriseStore.setState(
+        produce4((state) => {
+          state.entity[entityType].dataMap.set(data.entityId, data);
+        }),
+        void 0,
+        `mr/entity/create/${entityType}`
+      );
+      return { data };
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Unknown error occurred");
+      onError == null ? void 0 : onError(error);
+      return { error };
+    }
+  };
+  const upsertEntity2 = async (entityType, id, entity, opts = {}) => {
+    var _a;
+    const entityService = makeEntityService(entityType);
+    const onError = (_a = opts.onError) != null ? _a : defaultOnError;
+    try {
+      const { data } = await entityService.upsertEntity(id, entity, opts);
+      monoriseStore.setState(
+        produce4((state) => {
+          state.entity[entityType].dataMap.set(data.entityId, data);
+        }),
+        void 0,
+        `mr/entity/upsert/${entityType}/${id}`
+      );
+      return { data };
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Unknown error occurred");
+      onError(error);
+      return { error };
+    }
+  };
+  const editEntity2 = async (entityType, id, entity, opts = {}) => {
+    var _a;
+    const entityService = makeEntityService(entityType);
+    const onError = (_a = opts.onError) != null ? _a : defaultOnError;
+    try {
+      const { data } = await entityService.editEntity(id, entity, opts);
+      monoriseStore.setState(
+        produce4((state) => {
+          state.entity[entityType].dataMap.set(data.entityId, data);
+          for (const key of Object.keys(state.mutual)) {
+            const [_byEntity, _byId, _entityType] = key.split("/");
+            if (_entityType === entityType) {
+              const mutual = state.mutual[key].dataMap.get(id);
+              if (mutual) {
+                state.mutual[key].dataMap = new Map(
+                  state.mutual[key].dataMap
+                ).set(id, __spreadProps(__spreadValues({}, mutual), { data: data.data }));
+              }
+            }
+          }
+        }),
+        void 0,
+        `mr/entity/edit/${entityType}/${id}`
+      );
+      return { data };
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Unknown error occurred");
+      onError(error);
+      return { error };
+    }
+  };
+  const deleteEntity2 = async (entityType, id, opts = {}) => {
+    var _a;
+    const entityService = makeEntityService(entityType);
+    const onError = (_a = opts.onError) != null ? _a : defaultOnError;
+    try {
+      await entityService.deleteEntity(id, opts);
+      deleteLocalMutualsByEntity(entityType, id);
+      monoriseStore.setState(
+        produce4((state) => {
+          state.entity[entityType].dataMap.delete(id);
+          for (const key of Object.keys(state.mutual)) {
+            const [_byEntity, _byId, _entityType] = key.split("/");
+            if (_entityType === entityType) {
+              state.mutual[key].dataMap.delete(id);
+            }
+          }
+        }),
+        void 0,
+        `mr/entity/delete/${entityType}/${id}`
+      );
+      return { data: { entityId: id } };
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Unknown error occurred");
+      onError(error);
+      return { error };
+    }
+  };
+  const listEntitiesByEntity = async (byEntityType, entityType, id, opts = {}, chainEntityQuery) => {
+    var _a, _b, _c;
+    const onError = (_a = opts.onError) != null ? _a : defaultOnError;
+    const selfKey = (_b = opts.stateKey) != null ? _b : getMutualStateKey(
+      byEntityType,
+      id,
+      entityType,
+      void 0,
+      chainEntityQuery
+    );
+    const mutualService = makeMutualService(byEntityType, entityType);
+    const store2 = monoriseStore.getState();
+    const mutualState = store2.mutual[selfKey] || {};
+    const { isFirstFetched } = mutualState;
+    const requestKey = getMutualRequestKey(
+      "list",
+      byEntityType,
+      entityType,
+      id,
+      void 0,
+      chainEntityQuery
+    );
+    const isLoading = checkIsLoading(requestKey);
+    const error = getError2(requestKey);
+    const { forceFetch } = opts;
+    if (!forceFetch) {
+      if (error) {
+        onError(error);
+        return { error };
+      }
+      if (isFirstFetched || isLoading) {
+        return {
+          data: {
+            entities: Array.from(((_c = mutualState.dataMap) == null ? void 0 : _c.values()) || []),
+            lastKey: mutualState.lastKey
+          }
+        };
+      }
+    }
+    try {
+      const { data } = await mutualService.listEntitiesByEntity(
+        id,
+        opts,
+        chainEntityQuery
+      );
+      const { entities, lastKey } = data;
+      const newEntityDataMap = /* @__PURE__ */ new Map();
+      for (const i in entities) {
+        newEntityDataMap.set(entities[i].entityId, entities[i]);
+      }
+      monoriseStore.setState(
+        produce4((state) => {
+          var _a2;
+          for (const [key, value] of newEntityDataMap) {
+            (_a2 = state.entity[entityType]) == null ? void 0 : _a2.dataMap.set(key, value);
+          }
+          const existing = state.mutual[selfKey];
+          if (existing) {
+            const incoming = convertToMap(entities, "entityId");
+            for (const [k, v] of incoming) {
+              existing.dataMap.set(k, v);
+            }
+            existing.isFirstFetched = true;
+            existing.lastKey = lastKey;
+          } else {
+            state.mutual[selfKey] = {
+              dataMap: convertToMap(entities, "entityId"),
+              isFirstFetched: true,
+              lastKey
+            };
+          }
+        }),
+        void 0,
+        `mr/mutual/list/${selfKey}`
+      );
+      return { data };
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Unknown error occurred");
+      return { error: error2 };
+    }
+  };
+  const getMutual2 = async (byEntityType, entityType, byEntityId2, entityId, opts = {}) => {
+    var _a, _b, _c, _d;
+    const selfKey = getMutualStateKey(byEntityType, byEntityId2, entityType);
+    const mutualService = makeMutualService(byEntityType, entityType);
+    const store2 = monoriseStore.getState();
+    const mutualState = store2.mutual[selfKey] || {};
+    const requestKey = getMutualRequestKey(
+      "get",
+      byEntityType,
+      entityType,
+      byEntityId2,
+      entityId
+    );
+    const isLoading = checkIsLoading(requestKey);
+    const error = getError2(requestKey);
+    const onError = (_a = opts.onError) != null ? _a : defaultOnError;
+    if (error) {
+      onError == null ? void 0 : onError(error);
+      return { error };
+    }
+    if (!byEntityId2 || isLoading) {
+      return {
+        data: (_b = mutualState.dataMap) == null ? void 0 : _b.get(entityId)
+      };
+    }
+    if ((_c = mutualState.dataMap) == null ? void 0 : _c.get(entityId)) {
+      return {
+        data: mutualState.dataMap.get(entityId)
+      };
+    }
+    let mutual;
+    let hasRequestFailed = false;
+    try {
+      ({ data: mutual } = await mutualService.getMutual(
+        byEntityId2,
+        entityId,
+        opts
+      ));
+    } catch (err) {
+      if (!opts.defaultMutualData) {
+        const error2 = err instanceof Error ? err : new Error("Unknown error occurred");
+        return { error: error2 };
+      }
+      hasRequestFailed = true;
+      mutual = {
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        mutualId: `${byEntityId2}-${entityId}`,
+        mutualUpdatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        byEntityType,
+        byEntityId: byEntityId2,
+        entityType,
+        entityId,
+        mutualData: opts.defaultMutualData
+      };
+    }
+    const newMutualDataMap = new Map((_d = store2.mutual[selfKey]) == null ? void 0 : _d.dataMap);
+    newMutualDataMap.set(mutual.entityId, mutual);
+    if (!hasRequestFailed) {
+      const entityState = store2.entity[entityType];
+      const { dataMap: entityDataMap } = entityState;
+      const newEntityDataMap = new Map(entityDataMap);
+      newEntityDataMap.set(mutual.entityId, mutual);
+      monoriseStore.setState(
+        produce4((state) => {
+          state.mutual[selfKey] = __spreadProps(__spreadValues({}, state.mutual[selfKey] || {}), {
+            dataMap: newMutualDataMap
+          });
+          state.entity[entityType].dataMap = newEntityDataMap;
+        }),
+        void 0,
+        `mr/mutual/get/${getMutualStateKey(
+          byEntityType,
+          byEntityId2,
+          entityType,
+          entityId
+        )}`
+      );
+    }
+    return { data: mutual };
+  };
+  const createMutual2 = async (byEntityType, entityType, byEntityId2, entityId, payload = {}, opts = {}) => {
+    var _a;
+    const mutualService = makeMutualService(byEntityType, entityType);
+    const onError = (_a = opts.onError) != null ? _a : defaultOnError;
+    try {
+      const { data: mutual } = await mutualService.createMutual(
+        byEntityId2,
+        entityId,
+        payload,
+        opts
+      );
+      monoriseStore.setState(
+        produce4((state) => {
+          var _a2, _b;
+          const bySide = getMutualStateKey(
+            byEntityType,
+            byEntityId2,
+            entityType
+          );
+          const side = getMutualStateKey(entityType, entityId, byEntityType);
+          if (!state.mutual[bySide]) {
+            state.mutual[bySide] = {
+              dataMap: /* @__PURE__ */ new Map()
+            };
+          }
+          state.mutual[bySide].dataMap = new Map(
+            (_a2 = state.mutual[bySide]) == null ? void 0 : _a2.dataMap
+          ).set(mutual.entityId, mutual);
+          if (!state.mutual[side]) {
+            state.mutual[side] = {
+              dataMap: /* @__PURE__ */ new Map()
+            };
+          }
+          state.mutual[side].dataMap = new Map((_b = state.mutual[side]) == null ? void 0 : _b.dataMap).set(
+            mutual.byEntityId,
+            flipMutual(mutual)
+          );
+        }),
+        void 0,
+        `mr/mutual/create/${getMutualStateKey(byEntityType, byEntityId2, entityType, entityId)}`
+      );
+      return { data: mutual };
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Unknown error occurred");
+      onError(error);
+      return { error };
+    }
+  };
+  const createLocalMutual2 = async (byEntityType, entityType, byEntityId2, entityId, mutualData, data) => {
+    const mutual = constructMutual(
+      byEntityType,
+      byEntityId2,
+      entityType,
+      entityId,
+      mutualData,
+      data
+    );
+    monoriseStore.setState(
+      produce4((state) => {
+        var _a, _b;
+        const bySide = getMutualStateKey(byEntityType, byEntityId2, entityType);
+        const side = getMutualStateKey(entityType, entityId, byEntityType);
+        if (!state.mutual[bySide]) {
+          state.mutual[bySide] = {
+            dataMap: /* @__PURE__ */ new Map()
+          };
+        }
+        state.mutual[bySide].dataMap = new Map(
+          (_a = state.mutual[bySide]) == null ? void 0 : _a.dataMap
+        ).set(mutual.entityId, mutual);
+        if (!state.mutual[side]) {
+          state.mutual[side] = {
+            dataMap: /* @__PURE__ */ new Map()
+          };
+        }
+        state.mutual[side].dataMap = new Map((_b = state.mutual[side]) == null ? void 0 : _b.dataMap).set(
+          mutual.byEntityId,
+          flipMutual(mutual)
+        );
+      }),
+      void 0,
+      `mr/mutual/create/${getMutualStateKey(byEntityType, byEntityId2, entityType, entityId)}`
+    );
+  };
+  const updateLocalEntity2 = async (entityType, entityId, data = {}) => {
+    const createdEntity = constructLocal(entityType, entityId, data);
+    monoriseStore.setState(
+      produce4((state) => {
+        state.entity[entityType].dataMap.set(entityId, createdEntity);
+      }),
+      void 0,
+      `mr/entity/local-update/${entityType}/${entityId}`
+    );
+  };
+  const upsertLocalMutual2 = async (byEntityType, entityType, byEntityId2, entityId, mutualData, data = {}) => {
+    const mutual = constructMutual(
+      byEntityType,
+      byEntityId2,
+      entityType,
+      entityId,
+      mutualData,
+      data
+    );
+    monoriseStore.setState(
+      produce4((state) => {
+        var _a, _b;
+        const bySide = getMutualStateKey(byEntityType, byEntityId2, entityType);
+        const side = getMutualStateKey(entityType, entityId, byEntityType);
+        if (!state.mutual[bySide]) {
+          state.mutual[bySide] = {
+            dataMap: /* @__PURE__ */ new Map()
+          };
+        }
+        state.mutual[bySide].dataMap = new Map(
+          (_a = state.mutual[bySide]) == null ? void 0 : _a.dataMap
+        ).set(entityId, mutual);
+        if (!state.mutual[side]) {
+          state.mutual[side] = {
+            dataMap: /* @__PURE__ */ new Map()
+          };
+        }
+        state.mutual[side].dataMap = new Map((_b = state.mutual[side]) == null ? void 0 : _b.dataMap).set(
+          byEntityId2,
+          flipMutual(mutual)
+        );
+      }),
+      void 0,
+      `mr/mutual/local-update/${getMutualStateKey(byEntityType, byEntityId2, entityType, entityId)}`
+    );
+  };
+  const editMutual2 = async (byEntityType, entityType, byEntityId2, entityId, payload = {}, opts = {}) => {
+    var _a;
+    const mutualService = makeMutualService(byEntityType, entityType);
+    const onError = (_a = opts.onError) != null ? _a : defaultOnError;
+    try {
+      const { data: mutual } = await mutualService.editMutual(
+        byEntityId2,
+        entityId,
+        payload,
+        opts
+      );
+      monoriseStore.setState(
+        produce4((state) => {
+          var _a2, _b;
+          const bySide = getMutualStateKey(
+            byEntityType,
+            byEntityId2,
+            entityType
+          );
+          const side = getMutualStateKey(entityType, entityId, byEntityType);
+          if (!state.mutual[bySide]) {
+            state.mutual[bySide] = {
+              dataMap: /* @__PURE__ */ new Map()
+            };
+          }
+          state.mutual[bySide].dataMap = new Map(
+            (_a2 = state.mutual[bySide]) == null ? void 0 : _a2.dataMap
+          ).set(mutual.entityId, mutual);
+          if (!state.mutual[side]) {
+            state.mutual[side] = {
+              dataMap: /* @__PURE__ */ new Map()
+            };
+          }
+          state.mutual[side].dataMap = new Map((_b = state.mutual[side]) == null ? void 0 : _b.dataMap).set(
+            mutual.byEntityId,
+            flipMutual(mutual)
+          );
+        }),
+        void 0,
+        `mr/mutual/edit/${getMutualStateKey(byEntityType, byEntityId2, entityType, entityId)}`
+      );
+      return { data: mutual };
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Unknown error occurred");
+      onError(error);
+      return { error };
+    }
+  };
+  const deleteMutual2 = async (byEntityType, entityType, byEntityId2, entityId = "", opts = {}) => {
+    var _a;
+    const mutualService = makeMutualService(byEntityType, entityType);
+    const onError = (_a = opts.onError) != null ? _a : defaultOnError;
+    try {
+      const { data } = await mutualService.deleteMutual(
+        byEntityId2,
+        entityId,
+        opts
+      );
+      monoriseStore.setState(
+        produce4((state) => {
+          const bySide = getMutualStateKey(
+            byEntityType,
+            byEntityId2,
+            entityType
+          );
+          const side = getMutualStateKey(entityType, entityId, byEntityType);
+          state.mutual[bySide].dataMap.delete(data.entityId);
+          if (state.mutual[side]) {
+            state.mutual[side].dataMap.delete(data.byEntityId);
+          }
+        }),
+        void 0,
+        `mr/mutual/delete/${getMutualStateKey(byEntityType, byEntityId2, entityType, entityId)}`
+      );
+      return { data };
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Unknown error occurred");
+      onError(error);
+      return { error };
+    }
+  };
+  const deleteLocalMutual2 = (byEntityType, entityType, byEntityId2, entityId) => {
+    monoriseStore.setState(
+      produce4((state) => {
+        var _a, _b;
+        const bySide = getMutualStateKey(byEntityType, byEntityId2, entityType);
+        const side = getMutualStateKey(entityType, entityId, byEntityType);
+        const bySideDataMap = new Map((_a = state.mutual[bySide]) == null ? void 0 : _a.dataMap);
+        const sideDataMap = new Map((_b = state.mutual[side]) == null ? void 0 : _b.dataMap);
+        bySideDataMap.delete(entityId);
+        sideDataMap.delete(byEntityId2);
+        if (state.mutual[bySide]) {
+          state.mutual[bySide].dataMap.delete(entityId);
+        }
+        if (state.mutual[side]) {
+          state.mutual[side].dataMap.delete(byEntityId2);
+        }
+      }),
+      void 0,
+      `mr/mutual/local-delete/${getMutualStateKey(byEntityType, byEntityId2, entityType, entityId)}`
+    );
+  };
+  const deleteLocalMutualsByEntity = (entityType, id) => {
+    const store2 = monoriseStore.getState();
+    const entityConfig = store2.config;
+    let mutuals = [];
+    for (const i of Object.keys(entityConfig)) {
+      const mutualState = store2.mutual[`${entityType}/${id}/${i}`];
+      mutuals = [
+        ...mutuals,
+        ...Array.from((mutualState == null ? void 0 : mutualState.dataMap.values()) || [])
+      ];
+    }
+    const updatedState = mutuals.reduce(
+      (acc, mutual) => {
+        var _a;
+        const side = getMutualStateKey(
+          mutual.entityType,
+          mutual.entityId,
+          mutual.byEntityType
+        );
+        const dataMap = new Map((_a = store2.mutual[side]) == null ? void 0 : _a.dataMap);
+        dataMap.delete(id);
+        acc[side] = __spreadProps(__spreadValues({}, store2.mutual[side]), {
+          dataMap
+        });
+        return acc;
+      },
+      {}
+    );
+    monoriseStore.setState(
+      produce4((state) => {
+        for (const key in updatedState) {
+          state.mutual[key] = updatedState[key];
+        }
+      }),
+      void 0,
+      `mr/mutual/local-delete-by-entity/${entityType}/${id}`
+    );
+  };
+  const useEntity2 = (entityType, id, opts = {}) => {
+    const dataMap = monoriseStore(
+      (state) => {
+        var _a;
+        return ((_a = state.entity[entityType]) == null ? void 0 : _a.dataMap) || /* @__PURE__ */ new Map();
+      }
+    );
+    const isFirstFetched = monoriseStore(
+      (state) => {
+        var _a;
+        return (_a = state.entity[entityType]) == null ? void 0 : _a.isFirstFetched;
+      }
+    );
+    const requestKey = getEntityRequestKey("get", entityType, id);
+    const isLoading = useLoadStore2(requestKey);
+    const error = useErrorStore2(requestKey);
+    useEffect2(() => {
+      if (id) {
+        getEntity2(entityType, id, opts);
+      }
+    }, [id, entityType, opts]);
+    return {
+      entity: id ? dataMap.get(id) : void 0,
+      isLoading,
+      error,
+      requestKey,
+      isFirstFetched,
+      refetch: async () => {
+        if (id) {
+          const { data, error: fetchError } = await getEntity2(entityType, id, __spreadProps(__spreadValues({}, opts), {
+            forceFetch: true
+          }));
+          if (fetchError) {
+          }
+          return data;
+        }
+      }
+    };
+  };
+  const useEntityByUniqueField2 = (entityType, fieldName, value, opts = {}) => {
+    const dataMap = monoriseStore(
+      (state) => {
+        var _a;
+        return ((_a = state.entity[entityType]) == null ? void 0 : _a.dataMap) || /* @__PURE__ */ new Map();
+      }
+    );
+    const isFirstFetched = monoriseStore(
+      (state) => {
+        var _a;
+        return (_a = state.entity[entityType]) == null ? void 0 : _a.isFirstFetched;
+      }
+    );
+    const stateKey = getUniqueFieldStateKey(fieldName, value || "");
+    const requestKey = getUniqueFieldRequestKey(
+      entityType,
+      fieldName,
+      value || ""
+    );
+    const isLoading = useLoadStore2(requestKey);
+    const error = useErrorStore2(requestKey);
+    useEffect2(() => {
+      if (value) {
+        getEntityByUniqueField(entityType, fieldName, value, opts);
+      }
+    }, [fieldName, value, entityType, opts]);
+    return {
+      entity: value ? dataMap.get(`${stateKey}`) : void 0,
+      isLoading,
+      error,
+      requestKey,
+      isFirstFetched,
+      refetch: async () => {
+        if (value) {
+          const { data, error: fetchError } = await getEntityByUniqueField(
+            entityType,
+            fieldName,
+            value,
+            __spreadProps(__spreadValues({}, opts), {
+              forceFetch: true
+            })
+          );
+          if (fetchError) {
+          }
+          return data;
+        }
+      }
+    };
+  };
+  const useEntities2 = (entityType, params = {}, opts = {}) => {
+    const requestKey = getEntityRequestKey("list", entityType);
+    const isListing = useLoadStore2(requestKey);
+    const error = useErrorStore2(requestKey);
+    const state = monoriseStore((state2) => state2.entity[entityType]);
+    const { dataMap, searchResults, isFirstFetched, lastKey } = state != null ? state : {
+      dataMap: /* @__PURE__ */ new Map()
+    };
+    const [entities, setEntities] = useState2();
+    const [query, setQuery] = useState2("");
+    const [skRange, setBetween] = useState2(params.skRange);
+    const [all, setAll] = useState2(params.all);
+    const [isSearching, setIsSearching] = useState2(false);
+    const isLoading = isListing || isSearching;
+    useEffect2(() => {
+      if ((params == null ? void 0 : params.skRange) && (skRange == null ? void 0 : skRange.start) !== params.skRange.start && (skRange == null ? void 0 : skRange.end) !== params.skRange.end) {
+        setBetween(params.skRange);
+      }
+    }, [skRange == null ? void 0 : skRange.end, skRange == null ? void 0 : skRange.start, params.skRange]);
+    useEffect2(() => {
+      if ((params == null ? void 0 : params.all) !== all) {
+        setAll(params.all);
+      }
+    }, [all, params.all]);
+    useEffect2(() => {
+      if (!isFirstFetched) {
+        listEntities(entityType, { skRange, all }, opts);
+      }
+    }, [all, entityType, skRange, opts, isFirstFetched]);
+    useEffect2(() => {
+      var _a;
+      let queryTimeout;
+      if (query == null ? void 0 : query.length) {
+        setIsSearching(true);
+        queryTimeout = setTimeout(async () => {
+          await searchEntities(entityType, query);
+          setIsSearching(false);
+        }, (_a = opts.searchInterval) != null ? _a : 700);
+      }
+      return () => queryTimeout && clearTimeout(queryTimeout);
+    }, [entityType, query]);
+    useEffect2(() => {
+      if (!query && dataMap.size !== (entities == null ? void 0 : entities.length)) {
+        setIsSearching(false);
+        setEntities(
+          Array.from(dataMap.values()).sort(byEntityId)
+        );
+      }
+      if (query) {
+        setEntities(searchResults);
+      }
+    }, [
+      dataMap,
+      dataMap.size,
+      entities == null ? void 0 : entities.length,
+      query,
+      searchResults,
+      searchResults == null ? void 0 : searchResults.length
+    ]);
+    const handleQueryChange = (event) => {
+      setQuery(event.target.value);
+    };
+    const searchField = {
+      value: query,
+      onChange: handleQueryChange
+    };
+    return {
+      entities,
+      entitiesMap: dataMap,
+      searchField,
+      isLoading,
+      error,
+      requestKey,
+      isFirstFetched,
+      lastKey,
+      refetch: async () => {
+        if (entityType && query) {
+          await searchEntities(entityType, query);
+          return;
+        }
+        await listEntities(
+          entityType,
+          { skRange, all },
+          __spreadProps(__spreadValues({}, opts), {
+            forceFetch: true
+          })
+        );
+      },
+      listMore: async () => {
+        if (!lastKey) return;
+        await listMoreEntities2(entityType, __spreadProps(__spreadValues({}, opts), {
+          forceFetch: true
+        }));
+      }
+    };
+  };
+  const useMutual2 = (byEntityType, entityType, byId, id, opts = {}) => {
+    const stateKey = getMutualStateKey(byEntityType, byId, entityType);
+    const state = monoriseStore((state2) => state2.mutual[stateKey]);
+    const requestKey = getMutualRequestKey(
+      "get",
+      byEntityType,
+      entityType,
+      byId,
+      id
+    );
+    const isLoading = useLoadStore2(requestKey);
+    const error = useErrorStore2(requestKey);
+    const { dataMap } = state || {
+      dataMap: /* @__PURE__ */ new Map()
+    };
+    useEffect2(() => {
+      if (!dataMap.get(id)) {
+        getMutual2(byEntityType, entityType, byId, id, opts);
+      }
+    }, [byEntityType, byId, entityType, id, opts, dataMap]);
+    return {
+      mutual: dataMap.get(id),
+      isLoading,
+      error,
+      requestKey
+    };
+  };
+  const useMutuals2 = (byEntityType, entityType, byId, opts = {}, chainEntityQuery) => {
+    const stateKey = getMutualStateKey(
+      byEntityType,
+      byId || "",
+      entityType,
+      void 0,
+      chainEntityQuery
+    );
+    const state = monoriseStore((state2) => state2.mutual[stateKey]);
+    const { dataMap, isFirstFetched, lastKey } = state || {
+      dataMap: /* @__PURE__ */ new Map()
+    };
+    const [mutuals, setMutuals] = useState2([]);
+    const requestKey = getMutualRequestKey(
+      "list",
+      byEntityType,
+      entityType,
+      byId || "",
+      void 0,
+      chainEntityQuery
+    );
+    const isLoading = useLoadStore2(requestKey);
+    const error = useErrorStore2(requestKey);
+    useEffect2(() => {
+      if (!isFirstFetched && byEntityType && entityType && byId) {
+        listEntitiesByEntity(
+          byEntityType,
+          entityType,
+          byId,
+          __spreadProps(__spreadValues({}, opts), { stateKey }),
+          chainEntityQuery
+        );
+      }
+    }, [
+      isFirstFetched,
+      byEntityType,
+      byId,
+      entityType,
+      opts,
+      chainEntityQuery,
+      stateKey,
+      opts == null ? void 0 : opts.forceFetch,
+      opts == null ? void 0 : opts.noData
+    ]);
+    useEffect2(() => {
+      const dataMapArray = Array.from(dataMap.values());
+      if (dataMap.size !== (mutuals == null ? void 0 : mutuals.length) || dataMapArray.some(
+        (item, index) => JSON.stringify(item) !== JSON.stringify(mutuals[index])
+      )) {
+        setMutuals(dataMapArray);
+      }
+    }, [dataMap, dataMap.size, mutuals == null ? void 0 : mutuals.length]);
+    return __spreadValues({
+      mutuals,
+      mutualsMap: dataMap,
+      isLoading,
+      requestKey,
+      error,
+      isFirstFetched,
+      lastKey
+    }, lastKey && {
+      listMore: () => {
+        if (byEntityType && entityType && byId) {
+          listEntitiesByEntity(
+            byEntityType,
+            entityType,
+            byId,
+            __spreadProps(__spreadValues({}, opts), {
+              forceFetch: true,
+              params: __spreadProps(__spreadValues({}, opts.params), { lastKey }),
+              stateKey
+            }),
+            chainEntityQuery
+          );
+        }
+      }
+    });
+  };
+  const useTaggedEntities2 = (entityType, tagName, opts = {}) => {
+    const { params } = opts || {};
+    const stateKey = getTagStateKey(entityType, tagName, params);
+    const state = monoriseStore((state2) => state2.tag[stateKey]);
+    const { dataMap, isFirstFetched, lastKey } = state || {
+      dataMap: /* @__PURE__ */ new Map()
+    };
+    const [entities, setEntities] = useState2([]);
+    const requestKey = getTagRequestKey("list", entityType, tagName, params);
+    const isLoading = useLoadStore2(requestKey);
+    const error = useErrorStore2(requestKey);
+    useEffect2(() => {
+      if (entityType && tagName && Object.keys(params).length > 0) {
+        listEntitiesByTag(entityType, tagName, opts);
+      }
+    }, [entityType, opts, tagName, params, opts == null ? void 0 : opts.forceFetch]);
+    useEffect2(() => {
+      const dataMapArray = Array.from(dataMap.values());
+      if (dataMap.size !== (entities == null ? void 0 : entities.length) || dataMapArray.some(
+        (item, index) => JSON.stringify(item) !== JSON.stringify(entities[index])
+      )) {
+        setEntities(dataMapArray);
+      }
+    }, [dataMap, dataMap.size, entities == null ? void 0 : entities.length]);
+    return {
+      entities,
+      entitiesMap: dataMap,
+      isLoading,
+      requestKey,
+      error,
+      isFirstFetched,
+      lastKey,
+      refetch: async () => {
+        if (entityType && tagName && (params == null ? void 0 : params.group)) {
+          return await listEntitiesByTag(entityType, tagName, __spreadProps(__spreadValues({}, opts), {
+            forceFetch: true
+          }));
+        }
+      },
+      listMore: async () => {
+        if (entityType && tagName && (params == null ? void 0 : params.group)) {
+          return await listEntitiesByTag(entityType, tagName, __spreadProps(__spreadValues({}, opts), {
+            forceFetch: true,
+            params: __spreadProps(__spreadValues({}, params), { lastKey })
+          }));
+        }
+      }
+    };
+  };
+  const useEntityState2 = (entityType) => {
+    return monoriseStore((state) => state.entity[entityType]);
+  };
+  const updateLocalTaggedEntity2 = (entityType, entityId, tagName, data = {}, params) => {
+    const tagKey = getTagStateKey(
+      entityType,
+      tagName,
+      params
+    );
+    monoriseStore.setState(
+      produce4((state) => {
+        var _a, _b;
+        const entity = (_b = (_a = state.tag[tagKey]) == null ? void 0 : _a.dataMap) == null ? void 0 : _b.get(entityId);
+        if (entity) {
+          state.tag[tagKey].dataMap.set(entityId, __spreadProps(__spreadValues({}, entity), {
+            data: __spreadValues(__spreadValues({}, entity.data), data)
+          }));
+        }
+      }),
+      void 0,
+      `mr/tag/local-update/${entityType}/${entityId}`
+    );
+  };
+  const deleteLocalTaggedEntity2 = (entityType, entityId, tagName, params) => {
+    const tagKey = getTagStateKey(
+      entityType,
+      tagName,
+      params
+    );
+    monoriseStore.setState(
+      produce4((state) => {
+        var _a, _b;
+        if ((_b = (_a = state.tag[tagKey]) == null ? void 0 : _a.dataMap) == null ? void 0 : _b.has(entityId)) {
+          state.tag[tagKey].dataMap.delete(entityId);
+        }
+      }),
+      void 0,
+      `mr/tag/local-delete/${entityType}/${entityId}`
+    );
+  };
+  return {
+    listMoreEntities: listMoreEntities2,
+    createEntity: createEntity2,
+    upsertEntity: upsertEntity2,
+    getEntity: getEntity2,
+    editEntity: editEntity2,
+    deleteEntity: deleteEntity2,
+    getMutual: getMutual2,
+    updateLocalEntity: updateLocalEntity2,
+    createMutual: createMutual2,
+    createLocalMutual: createLocalMutual2,
+    upsertLocalMutual: upsertLocalMutual2,
+    editMutual: editMutual2,
+    deleteMutual: deleteMutual2,
+    deleteLocalMutual: deleteLocalMutual2,
+    useEntity: useEntity2,
+    useEntityByUniqueField: useEntityByUniqueField2,
+    useEntities: useEntities2,
+    useMutual: useMutual2,
+    useMutuals: useMutuals2,
+    useTaggedEntities: useTaggedEntities2,
+    useEntityState: useEntityState2,
+    updateLocalTaggedEntity: updateLocalTaggedEntity2,
+    deleteLocalTaggedEntity: deleteLocalTaggedEntity2
+  };
+};
+
+// lib/api.ts
+import request from "axios";
+var initAxiosInterceptor = (store2, appActions) => {
+  const { startLoading: startLoading2 } = appActions;
+  const axiosInstance = request.create();
+  function makeRequest(url, config, data) {
+    const { requestKey, isInterruptive = false, feedback } = config;
+    const { ongoingRequests } = store2.getState().app;
+    if (ongoingRequests.has(requestKey)) {
+      return ongoingRequests.get(requestKey);
+    }
+    const promise = axiosInstance.request(__spreadProps(__spreadValues({}, config), {
+      url,
+      data,
+      headers: __spreadProps(__spreadValues({}, config.headers || {}), {
+        "Mr-Interruptive": String(isInterruptive)
+      })
+    }));
+    startLoading2({
+      requestKey,
+      isInterruptive,
+      message: feedback == null ? void 0 : feedback.loading,
+      request: promise
+    });
+    return promise;
+  }
+  const axios2 = __spreadProps(__spreadValues({}, axiosInstance), {
+    post: (url, data, config) => makeRequest(url, __spreadProps(__spreadValues({}, config), { method: "POST" }), data),
+    put: (url, data, config) => makeRequest(url, __spreadProps(__spreadValues({}, config), { method: "PUT" }), data),
+    patch: (url, data, config) => makeRequest(url, __spreadProps(__spreadValues({}, config), { method: "PATCH" }), data),
+    delete: (url, config) => makeRequest(url, __spreadProps(__spreadValues({}, config), { method: "DELETE" })),
+    get: (url, config) => makeRequest(url, __spreadProps(__spreadValues({}, config), { method: "GET" }))
+  });
+  return axios2;
+};
+var injectAxiosInterceptor = (appActions, authActions, axios2, opts) => {
+  let options = opts || {};
+  const { endLoading: endLoading2, setError: setError2, clearError: clearError2 } = appActions;
+  const { setIsUnauthorized: setIsUnauthorized2 } = authActions;
+  const unknownError = {
+    status: 500,
+    code: "UNKNOWN_EXCEPTION",
+    message: "Ops, something doesn't seems right"
+  };
+  axios2.interceptors.response.use(
+    (response) => {
+      var _a;
+      const { requestKey, isInterruptive, feedback } = response.config;
+      endLoading2({ requestKey, isInterruptive });
+      clearError2(requestKey);
+      if (feedback == null ? void 0 : feedback.success) {
+        (_a = options.onApiSuccess) == null ? void 0 : _a.call(options, response, feedback.success);
+      }
+      return Promise.resolve(response);
+    },
+    (error) => {
+      var _a, _b, _c, _d, _e;
+      const { requestKey, isInterruptive } = error.config;
+      endLoading2({ requestKey, isInterruptive });
+      const appError = ((_a = error.response) == null ? void 0 : _a.data) ? {
+        code: (_b = error.response) == null ? void 0 : _b.statusText,
+        status: (_c = error.response) == null ? void 0 : _c.status,
+        message: (_d = error.response) == null ? void 0 : _d.data
+      } : unknownError;
+      setError2({ requestKey, error: appError });
+      if (((_e = error.response) == null ? void 0 : _e.status) === 401) {
+        setIsUnauthorized2(true);
+      }
+      return Promise.reject(error);
+    }
+  );
+  const setOptions = (opts2) => {
+    options = __spreadValues(__spreadValues({}, options), opts2);
+  };
+  return { setOptions };
+};
+
+// services/auth.service.ts
+var initAuthService = (axios2) => {
+  let options = {};
+  const { apiBaseUrl = "/api/auth" } = options;
+  const requestLoginMagicLink = (entityType, payload) => {
+    return axios2.post(
+      `${apiBaseUrl}/${entityType}`,
+      {
+        body: __spreadValues({}, payload)
+      },
+      {
+        requestKey: `auth/${entityType}/request-login`,
+        isInterruptive: true,
+        feedback: {
+          loading: "Requesting login link"
+        }
+      }
+    );
+  };
+  const getSessionProfile = () => axios2.get("/session", {
+    requestKey: "auth/session"
+  });
+  const logout2 = () => axios2.get("/logout", {
+    requestKey: "auth/logout"
+  });
+  const setOptions = (opts) => {
+    options = __spreadValues(__spreadValues({}, options), opts);
+  };
+  return {
+    requestLoginMagicLink,
+    getSessionProfile,
+    logout: logout2,
+    setOptions
+  };
+};
+var auth_service_default = initAuthService;
+
+// services/core.service.ts
+var ENTITY_API_BASE_URL = "/api/core/entity";
+var MUTUAL_API_BASE_URL = "/api/core/mutual";
+var TAG_API_BASE_URL = "/api/core/tag";
+var initCoreService = (monoriseStore, axios2, opts) => {
+  let options = opts || {};
+  const listEntities = (entityType, payload, opts2 = {}) => {
+    const { entityApiBaseUrl = ENTITY_API_BASE_URL } = options;
+    return axios2.get(opts2.customUrl || `${entityApiBaseUrl}/${entityType}`, {
+      requestKey: getEntityRequestKey("list", entityType),
+      params: payload != null ? payload : void 0,
+      isInterruptive: opts2.isInterruptive,
+      feedback: opts2.feedback
+    });
+  };
+  const searchEntities = (entityType, query, opts2 = {}) => {
+    const { entityApiBaseUrl = ENTITY_API_BASE_URL } = options;
+    return axios2.get(
+      opts2.customUrl || `${entityApiBaseUrl}/${entityType}`,
+      {
+        requestKey: getEntityRequestKey("search", entityType),
+        params: { query },
+        isInterruptive: opts2.isInterruptive,
+        feedback: opts2.feedback
+      }
+    );
+  };
+  const listEntitiesByTag = (entityType, tagName, opts2 = {}) => {
+    const { tagApiBaseUrl = TAG_API_BASE_URL } = options;
+    return axios2.get(
+      opts2.customUrl || `${tagApiBaseUrl}/${entityType}/${tagName}`,
+      {
+        requestKey: opts2.requestKey || getTagRequestKey("list", entityType, tagName, opts2.params),
+        params: opts2.params,
+        isInterruptive: opts2.isInterruptive,
+        feedback: opts2.feedback
+      }
+    );
+  };
+  const getEntity2 = (entityType, id, opts2 = {}) => {
+    const { entityApiBaseUrl = ENTITY_API_BASE_URL } = options;
+    return axios2.get(
+      opts2.customUrl || `${entityApiBaseUrl}/${entityType}/${id}`,
+      {
+        requestKey: getEntityRequestKey("get", entityType, id),
+        isInterruptive: opts2.isInterruptive,
+        feedback: __spreadValues({
+          loading: `Retrieving ${entityType}`
+        }, opts2.feedback || {})
+      }
+    );
+  };
+  const getEntityByUniqueField = (entityType, fieldName, value, opts2 = {}) => {
+    const { entityApiBaseUrl = ENTITY_API_BASE_URL } = options;
+    return axios2.get(
+      opts2.customUrl || `${entityApiBaseUrl}/${entityType}/unique/${getUniqueFieldStateKey(fieldName, value)}`,
+      {
+        requestKey: getUniqueFieldRequestKey(entityType, fieldName, value),
+        isInterruptive: opts2.isInterruptive,
+        feedback: __spreadValues({
+          loading: `Retrieving ${entityType}`
+        }, opts2.feedback || {})
+      }
+    );
+  };
+  const createEntity2 = (entityType, values, opts2 = {}) => {
+    var _a;
+    const { entityApiBaseUrl = ENTITY_API_BASE_URL } = options;
+    const entityConfig = monoriseStore.getState().config;
+    return axios2.post(
+      opts2.customUrl || `${entityApiBaseUrl}/${entityType}`,
+      values,
+      {
+        requestKey: opts2.requestKey || getEntityRequestKey("create", entityType),
+        isInterruptive: (_a = opts2.isInterruptive) != null ? _a : true,
+        feedback: __spreadValues({
+          loading: `Creating ${entityConfig[entityType].displayName}`,
+          success: `${entityConfig[entityType].displayName} created`
+        }, opts2.feedback || {})
+      }
+    );
+  };
+  const upsertEntity2 = (entityType, id, values, opts2 = {}) => {
+    var _a;
+    const { entityApiBaseUrl = ENTITY_API_BASE_URL } = options;
+    const entityConfig = monoriseStore.getState().config;
+    return axios2.put(
+      opts2.customUrl || `${entityApiBaseUrl}/${entityType}/${id}`,
+      values,
+      {
+        requestKey: getEntityRequestKey("upsert", entityType, id),
+        isInterruptive: (_a = opts2.isInterruptive) != null ? _a : true,
+        feedback: __spreadValues({
+          loading: `Updating ${entityConfig[entityType].displayName}`,
+          success: `${entityConfig[entityType].displayName} updated`
+        }, opts2.feedback || {})
+      }
+    );
+  };
+  const editEntity2 = (entityType, id, values, opts2 = {}) => {
+    var _a;
+    const { entityApiBaseUrl = ENTITY_API_BASE_URL } = options;
+    const entityConfig = monoriseStore.getState().config;
+    return axios2.patch(
+      opts2.customUrl || `${entityApiBaseUrl}/${entityType}/${id}`,
+      values,
+      {
+        requestKey: getEntityRequestKey("edit", entityType, id),
+        isInterruptive: (_a = opts2.isInterruptive) != null ? _a : true,
+        feedback: __spreadValues({
+          loading: `Updating ${entityConfig[entityType].displayName}`,
+          success: `${entityConfig[entityType].displayName} updated`
+        }, opts2.feedback || {})
+      }
+    );
+  };
+  const deleteEntity2 = (entityType, id, opts2 = {}) => {
+    var _a;
+    const { entityApiBaseUrl = ENTITY_API_BASE_URL } = options;
+    const entityConfig = monoriseStore.getState().config;
+    return axios2.delete(
+      opts2.customUrl || `${entityApiBaseUrl}/${entityType}/${id}`,
+      {
+        requestKey: getEntityRequestKey("delete", entityType, id),
+        isInterruptive: (_a = opts2.isInterruptive) != null ? _a : true,
+        feedback: __spreadValues({
+          loading: `Deleting ${entityConfig[entityType].displayName}`,
+          success: `${entityConfig[entityType].displayName} deleted`
+        }, opts2.feedback || {})
+      }
+    );
+  };
+  const listEntitiesByEntity = (byEntityType, entityType, byEntityId2, opts2 = {}, chainEntityQuery) => {
+    const { mutualApiBaseUrl = MUTUAL_API_BASE_URL } = options;
+    return axios2.get(
+      opts2.customUrl || `${mutualApiBaseUrl}/${byEntityType}/${byEntityId2}/${entityType}`,
+      {
+        requestKey: getMutualRequestKey(
+          "list",
+          byEntityType,
+          entityType,
+          byEntityId2,
+          void 0,
+          chainEntityQuery
+        ),
+        isInterruptive: opts2.isInterruptive,
+        feedback: opts2.feedback,
+        params: __spreadValues(__spreadValues({
+          chainEntityQuery,
+          limit: opts2.limit
+        }, opts2.params), opts2.noData && { projection: "no-data" })
+      }
+    );
+  };
+  const getMutual2 = (byEntityType, entityType, byEntityId2, entityId, opts2 = {}) => {
+    var _a;
+    const { mutualApiBaseUrl = MUTUAL_API_BASE_URL } = options;
+    return axios2.get(
+      opts2.customUrl || `${mutualApiBaseUrl}/${getMutualStateKey(byEntityType, byEntityId2, entityType, entityId)}`,
+      {
+        requestKey: getMutualRequestKey(
+          "get",
+          byEntityType,
+          entityType,
+          byEntityId2,
+          entityId
+        ),
+        isInterruptive: (_a = opts2.isInterruptive) != null ? _a : false,
+        feedback: opts2.feedback
+      }
+    );
+  };
+  const createMutual2 = (byEntityType, entityType, byEntityId2, entityId, payload, opts2 = {}) => {
+    var _a;
+    const { mutualApiBaseUrl = MUTUAL_API_BASE_URL } = options;
+    return axios2.post(
+      opts2.customUrl || `${mutualApiBaseUrl}/${getMutualStateKey(byEntityType, byEntityId2, entityType, entityId)}`,
+      payload,
+      {
+        requestKey: getMutualRequestKey(
+          "create",
+          byEntityType,
+          entityType,
+          byEntityId2
+        ),
+        isInterruptive: (_a = opts2.isInterruptive) != null ? _a : true,
+        feedback: __spreadValues({
+          loading: "Creating linkage",
+          success: "Linkage created"
+        }, opts2.feedback || {})
+      }
+    );
+  };
+  const editMutual2 = (byEntityType, entityType, byEntityId2, entityId, payload, opts2 = {}) => {
+    var _a;
+    const { mutualApiBaseUrl = MUTUAL_API_BASE_URL } = options;
+    return axios2.patch(
+      opts2.customUrl || `${mutualApiBaseUrl}/${getMutualStateKey(byEntityType, byEntityId2, entityType, entityId)}`,
+      payload,
+      {
+        requestKey: getMutualRequestKey(
+          "update",
+          byEntityType,
+          entityType,
+          byEntityId2,
+          entityId
+        ),
+        isInterruptive: (_a = opts2.isInterruptive) != null ? _a : true,
+        feedback: __spreadValues({
+          loading: "Updating linkage",
+          success: "Linkage updated"
+        }, opts2.feedback || {})
+      }
+    );
+  };
+  const deleteMutual2 = (byEntityType, entityType, byEntityId2, entityId, opts2 = {}) => {
+    var _a;
+    const { mutualApiBaseUrl = MUTUAL_API_BASE_URL } = options;
+    return axios2.delete(
+      opts2.customUrl || `${mutualApiBaseUrl}/${getMutualStateKey(byEntityType, byEntityId2, entityType, entityId)}`,
+      {
+        requestKey: getMutualRequestKey(
+          "delete",
+          byEntityType,
+          entityType,
+          byEntityId2,
+          entityId
+        ),
+        isInterruptive: (_a = opts2.isInterruptive) != null ? _a : true,
+        feedback: __spreadValues({
+          loading: "Removing linkage",
+          success: "Linkage removed"
+        }, opts2.feedback || {})
+      }
+    );
+  };
+  const makeEntityService = (entityType) => ({
+    listEntities: (payload, opts2 = {}) => listEntities(entityType, payload, opts2),
+    searchEntities: (query, opts2 = {}) => searchEntities(entityType, query, opts2),
+    listEntitiesByTag: (tagName, opts2 = {}) => listEntitiesByTag(entityType, tagName, opts2),
+    getEntity: (id, opts2 = {}) => getEntity2(entityType, id, opts2),
+    getEntityByUniqueField: (fieldName, value, opts2 = {}) => getEntityByUniqueField(entityType, fieldName, value, opts2),
+    createEntity: (values, opts2 = {}) => createEntity2(entityType, values, opts2),
+    upsertEntity: (id, values, opts2 = {}) => upsertEntity2(entityType, id, values, opts2),
+    editEntity: (id, values, opts2 = {}) => editEntity2(entityType, id, values, opts2),
+    updateEntity: (id, values, opts2 = {}) => editEntity2(entityType, id, values, opts2),
+    deleteEntity: (id, opts2 = {}) => deleteEntity2(entityType, id, opts2)
+  });
+  const makeMutualService = (byEntityType, entityType) => ({
+    listEntitiesByEntity: (byEntityId2, opts2 = {}, chainEntityQuery) => listEntitiesByEntity(
+      byEntityType,
+      entityType,
+      byEntityId2,
+      opts2,
+      chainEntityQuery
+    ),
+    getMutual: (byEntityId2, entityId, opts2 = {}) => getMutual2(byEntityType, entityType, byEntityId2, entityId, opts2),
+    createMutual: (byEntityId2, entityId, payload, opts2 = {}) => createMutual2(
+      byEntityType,
+      entityType,
+      byEntityId2,
+      entityId,
+      payload,
+      opts2
+    ),
+    editMutual: (byEntityId2, entityId, payload, opts2 = {}) => editMutual2(byEntityType, entityType, byEntityId2, entityId, payload, opts2),
+    deleteMutual: (byEntityId2, entityId, opts2 = {}) => deleteMutual2(byEntityType, entityType, byEntityId2, entityId, opts2)
+  });
+  const setOptions = (opts2) => {
+    options = __spreadValues(__spreadValues({}, options), opts2);
+  };
+  return {
+    makeEntityService,
+    makeMutualService,
+    setOptions
+  };
+};
+var core_service_default = initCoreService;
+
+// services/filestore.service.ts
+var initFilestoreService = (axios2) => {
+  let options = {};
+  const { apiBaseUrl = "/api/file" } = options;
+  const uploadFile = async ({
+    file,
+    scope,
+    directory,
+    name,
+    disableLoading,
+    onProgress
+  }) => {
+    const { data } = await axios2.get(`${apiBaseUrl}/upload`, {
+      requestKey: `filestore/presign/file/${name}`,
+      isInterruptive: !disableLoading,
+      feedback: {
+        loading: "Preparing upload"
+      },
+      params: {
+        scope,
+        directory,
+        filename: name
+      }
+    });
+    return axios2.put(data.url, file, {
+      requestKey: `filestore/upload/${name}`,
+      isInterruptive: !disableLoading,
+      feedback: {
+        loading: "Uploading file"
+      },
+      headers: {
+        "Content-Type": file.type,
+        "Content-Disposition": "inline"
+      },
+      onUploadProgress: (progressEvent) => {
+        if (onProgress && progressEvent.total) {
+          const progress = Math.round(
+            progressEvent.loaded / progressEvent.total * 100
+          );
+          onProgress(progress);
+        }
+      }
+    });
+  };
+  const deleteFiles = async (keys) => {
+    console.log("Deleting files", keys);
+    const { data } = await axios2.post(
+      `${apiBaseUrl}/delete`,
+      {
+        keys
+      },
+      {
+        requestKey: "filestore/delete"
+      }
+    );
+    return data;
+  };
+  const uploadVideo = async ({
+    file,
+    scope,
+    directory,
+    name
+  }) => {
+    const { data: presign } = await axios2.get(`${apiBaseUrl}/upload`, {
+      requestKey: `filestore/presign/video/${name}`,
+      isInterruptive: true,
+      feedback: {
+        loading: "Preparing upload"
+      },
+      params: {
+        scope,
+        directory,
+        filename: name
+      }
+    });
+    await axios2.put(presign.url, file, {
+      requestKey: `filestore/upload/video/${name}`,
+      isInterruptive: true,
+      feedback: {
+        loading: "Uploading video"
+      },
+      headers: {
+        "Content-Type": file.type
+      }
+    });
+    const { data } = await axios2.post(
+      `${apiBaseUrl}/video/convert`,
+      {
+        scope,
+        directory,
+        filename: name
+      },
+      {
+        requestKey: "filestore/convert/video",
+        isInterruptive: true,
+        feedback: {
+          loading: "Triggering video conversion"
+        }
+      }
+    );
+    return data;
+  };
+  const uploadAudio = async ({
+    file,
+    scope,
+    directory,
+    name
+  }) => {
+    const { data: presign } = await axios2.get(`${apiBaseUrl}/upload`, {
+      requestKey: `filestore/presign/audio/${name}`,
+      isInterruptive: true,
+      feedback: {
+        loading: "Preparing upload"
+      },
+      params: {
+        scope,
+        directory,
+        filename: name
+      }
+    });
+    await axios2.put(presign.url, file, {
+      requestKey: `filestore/upload/audio/${name}`,
+      isInterruptive: true,
+      feedback: {
+        loading: "Uploading audio"
+      },
+      headers: {
+        "Content-Type": file.type
+      }
+    });
+    const { data } = await axios2.post(
+      `${apiBaseUrl}/audio/convert`,
+      {
+        scope,
+        directory,
+        filename: name
+      },
+      {
+        requestKey: "filestore/convert/audio",
+        isInterruptive: true,
+        feedback: {
+          loading: "Triggering audio conversion"
+        }
+      }
+    );
+    return data;
+  };
+  const getJobStatus = async (id) => {
+    const { data } = await axios2.get(`${apiBaseUrl}/job/${id}`, {
+      requestKey: `filestore/get-job/${id}`
+    });
+    return data;
+  };
+  const setOptions = (opts) => {
+    options = __spreadValues(__spreadValues({}, options), opts);
+  };
+  return {
+    uploadFile,
+    deleteFiles,
+    uploadVideo,
+    uploadAudio,
+    getJobStatus,
+    setOptions
+  };
+};
+var filestore_service_default = initFilestoreService;
+
+// store/monorise.store.ts
+import { enableMapSet } from "immer";
+import { create } from "zustand";
+import { devtools } from "zustand/middleware";
+enableMapSet();
+var configureDevtools = (storeName) => {
+  var _a;
+  return {
+    name: `${storeName} Store`,
+    anonymousActionType: `${storeName.toLowerCase()}/action`,
+    enabled: !["prod", "dev"].includes((_a = process.env.NEXT_PUBLIC_ENVIRONMENT) != null ? _a : ""),
+    serialize: {
+      options: {
+        map: true
+      }
+    }
+  };
+};
+var initMonoriseStore = () => {
+  let options = {};
+  const { modals = {} } = options;
+  const monoriseStore = create(
+    devtools(
+      () => ({
+        app: {
+          ongoingRequests: /* @__PURE__ */ new Map(),
+          loadStack: /* @__PURE__ */ new Map(),
+          intLoadStack: /* @__PURE__ */ new Map(),
+          loadingMessage: "",
+          errorStack: /* @__PURE__ */ new Map(),
+          modal: {
+            name: null
+          }
+        },
+        config: {},
+        entity: {},
+        mutual: {},
+        tag: {},
+        auth: {
+          isUnauthorized: false,
+          profile: {
+            displayName: "",
+            email: "",
+            accountId: ""
+          },
+          isLoading: true
+        }
+      }),
+      configureDevtools("monorise")
+    )
+  );
+  const setOptions = (opts) => {
+    options = __spreadValues(__spreadValues({}, options), opts);
+  };
+  return { setOptions, monoriseStore };
+};
+
+// index.ts
+var initMonorise = () => {
+  const { monoriseStore: store2, setOptions: setMonoriseOptions } = initMonoriseStore();
+  const appActions = initAppActions(store2);
+  const configActions = initConfigActions(store2);
+  const axios2 = initAxiosInterceptor(store2, appActions);
+  const authService2 = auth_service_default(axios2);
+  const filestoreService2 = filestore_service_default(axios2);
+  const coreService2 = core_service_default(store2, axios2);
+  const authActions = initAuthActions(store2, authService2);
+  const coreActions = initCoreActions(store2, appActions, coreService2);
+  const axiosInterceptor = injectAxiosInterceptor(
+    appActions,
+    authActions,
+    axios2
+  );
+  const config = (opts) => {
+    setMonoriseOptions({
+      modals: opts.modals
+    });
+    configActions.setConfig(opts.entityConfig);
+    authService2.setOptions({
+      apiBaseUrl: opts.authBaseUrl
+    });
+    filestoreService2.setOptions({
+      apiBaseUrl: opts.filestoreBaseUrl
+    });
+    coreService2.setOptions({
+      entityApiBaseUrl: opts.entityBaseUrl,
+      mutualApiBaseUrl: opts.mutualBaseUrl,
+      tagApiBaseUrl: opts.tagBaseUrl
+    });
+    axiosInterceptor.setOptions({
+      onApiSuccess: opts.onApiSuccess
+    });
+  };
+  return __spreadValues(__spreadValues(__spreadValues(__spreadValues({
+    config,
+    store: store2,
+    axios: axios2,
+    authService: authService2,
+    filestoreService: filestoreService2,
+    coreService: coreService2
+  }, configActions), appActions), authActions), coreActions);
+};
+var Monorise = initMonorise();
+var {
+  store,
+  axios,
+  authService,
+  filestoreService,
+  coreService,
+  setConfig,
+  getConfig,
+  useConfig,
+  startLoading,
+  endLoading,
+  setError,
+  getError,
+  clearError,
+  openModal,
+  closeModal,
+  useLoadStore,
+  useInterruptiveLoadStore,
+  useErrorStore,
+  useModalStore,
+  requestLogin,
+  useProfile,
+  getProfile,
+  useIsUnauthorized,
+  setIsUnauthorized,
+  logout,
+  listMoreEntities,
+  createEntity,
+  upsertEntity,
+  editEntity,
+  updateLocalEntity,
+  deleteEntity,
+  getMutual,
+  createMutual,
+  createLocalMutual,
+  upsertLocalMutual,
+  editMutual,
+  deleteMutual,
+  deleteLocalMutual,
+  useEntity,
+  useEntityByUniqueField,
+  useEntities,
+  useMutual,
+  useMutuals,
+  useTaggedEntities,
+  useEntityState,
+  getEntity,
+  updateLocalTaggedEntity,
+  deleteLocalTaggedEntity
+} = Monorise;
+var index_default = Monorise;
+export {
+  authService,
+  axios,
+  clearError,
+  closeModal,
+  coreService,
+  createEntity,
+  createLocalMutual,
+  createMutual,
+  index_default as default,
+  deleteEntity,
+  deleteLocalMutual,
+  deleteLocalTaggedEntity,
+  deleteMutual,
+  editEntity,
+  editMutual,
+  endLoading,
+  filestoreService,
+  getConfig,
+  getEntity,
+  getEntityRequestKey,
+  getError,
+  getMutual,
+  getMutualRequestKey,
+  getProfile,
+  getTagRequestKey,
+  getUniqueFieldRequestKey,
+  listMoreEntities,
+  logout,
+  openModal,
+  requestLogin,
+  setConfig,
+  setError,
+  setIsUnauthorized,
+  startLoading,
+  store,
+  updateLocalEntity,
+  updateLocalTaggedEntity,
+  upsertEntity,
+  upsertLocalMutual,
+  useConfig,
+  useEntities,
+  useEntity,
+  useEntityByUniqueField,
+  useEntityState,
+  useErrorStore,
+  useInterruptiveLoadStore,
+  useIsUnauthorized,
+  useLoadStore,
+  useModalStore,
+  useMutual,
+  useMutuals,
+  useProfile,
+  useTaggedEntities
+};
+//# sourceMappingURL=index.js.map