@akanjs/store 0.0.38 → 0.0.40

package/src/storeDecorators.js

@@ -0,0 +1,1244 @@
+"use client";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var storeDecorators_exports = {};
+__export(storeDecorators_exports, {
+  MixStore: () => MixStore,
+  Store: () => Store,
+  Toast: () => Toast,
+  createActions: () => createActions,
+  createState: () => createState,
+  makeStore: () => makeStore,
+  rootStoreOf: () => rootStoreOf,
+  scalarStateOf: () => scalarStateOf,
+  st: () => st,
+  stateOf: () => stateOf
+});
+module.exports = __toCommonJS(storeDecorators_exports);
+var import_base = require("@akanjs/base");
+var import_common = require("@akanjs/common");
+var import_constant = require("@akanjs/constant");
+var import_dictionary = require("@akanjs/dictionary");
+var import_signal = require("@akanjs/signal");
+var import_react = require("react");
+var import_zustand = require("zustand");
+var import_middleware = require("zustand/middleware");
+var import_immer = require("zustand/middleware/immer");
+const st = {};
+let StoreStorage = class StoreStorage2 {
+  static {
+    __name(this, "StoreStorage");
+  }
+};
+const getStoreMeta = /* @__PURE__ */ __name((storeName) => {
+  const storeMeta = Reflect.getMetadata(storeName, StoreStorage.prototype);
+  if (!storeMeta) throw new Error(`storeMeta is not defined: ${storeName}`);
+  return storeMeta;
+}, "getStoreMeta");
+const setStoreMeta = /* @__PURE__ */ __name((storeName, storeMeta) => {
+  Reflect.defineMetadata(storeName, storeMeta, StoreStorage.prototype);
+}, "setStoreMeta");
+const getStoreNames = /* @__PURE__ */ __name(() => {
+  const storeNames = Reflect.getMetadataKeys(StoreStorage.prototype);
+  if (!storeNames) throw new Error(`storeNames is not defined`);
+  return storeNames;
+}, "getStoreNames");
+const createState = /* @__PURE__ */ __name((gql) => {
+  const [fieldName, className] = [
+    (0, import_common.lowerlize)(gql.refName),
+    (0, import_common.capitalize)(gql.refName)
+  ];
+  const names = {
+    model: fieldName,
+    Model: className,
+    modelLoading: `${fieldName}Loading`,
+    modelForm: `${fieldName}Form`,
+    modelFormLoading: `${fieldName}FormLoading`,
+    modelSubmit: `${fieldName}Submit`,
+    modelViewAt: `${fieldName}ViewAt`,
+    modelModal: `${fieldName}Modal`,
+    modelOperation: `${fieldName}Operation`,
+    defaultModel: `default${className}`,
+    defaultModelInsight: `default${className}Insight`,
+    modelList: `${fieldName}List`,
+    modelListLoading: `${fieldName}ListLoading`,
+    modelInitList: `${fieldName}InitList`,
+    modelInitAt: `${fieldName}InitAt`,
+    modelSelection: `${fieldName}Selection`,
+    modelInsight: `${fieldName}Insight`,
+    lastPageOfModel: `lastPageOf${className}`,
+    pageOfModel: `pageOf${className}`,
+    limitOfModel: `limitOf${className}`,
+    queryArgsOfModel: `queryArgsOf${className}`,
+    sortOfModel: `sortOf${className}`
+  };
+  const baseState = {
+    [names.model]: null,
+    [names.modelLoading]: true,
+    [names.modelForm]: {
+      ...gql[names.defaultModel]
+    },
+    [names.modelFormLoading]: true,
+    [names.modelSubmit]: {
+      disabled: true,
+      loading: false,
+      times: 0
+    },
+    [names.modelViewAt]: /* @__PURE__ */ new Date(0),
+    [names.modelModal]: null,
+    [names.modelOperation]: "sleep"
+  };
+  const sliceState = gql.slices.reduce((acc, { sliceName, defaultArgs }) => {
+    const SliceName = (0, import_common.capitalize)(sliceName);
+    const namesOfSlice = {
+      defaultModel: SliceName.replace(names.Model, names.defaultModel),
+      modelList: sliceName.replace(names.model, names.modelList),
+      modelListLoading: sliceName.replace(names.model, names.modelListLoading),
+      modelInitList: sliceName.replace(names.model, names.modelInitList),
+      modelInitAt: sliceName.replace(names.model, names.modelInitAt),
+      modelSelection: sliceName.replace(names.model, names.modelSelection),
+      modelInsight: sliceName.replace(names.model, names.modelInsight),
+      lastPageOfModel: SliceName.replace(names.Model, names.lastPageOfModel),
+      pageOfModel: SliceName.replace(names.Model, names.pageOfModel),
+      limitOfModel: SliceName.replace(names.Model, names.limitOfModel),
+      queryArgsOfModel: SliceName.replace(names.Model, names.queryArgsOfModel),
+      sortOfModel: SliceName.replace(names.Model, names.sortOfModel)
+    };
+    const singleSliceState = {
+      [namesOfSlice.defaultModel]: {
+        ...gql[names.defaultModel]
+      },
+      [namesOfSlice.modelList]: new import_base.DataList(),
+      [namesOfSlice.modelListLoading]: true,
+      [namesOfSlice.modelInitList]: new import_base.DataList(),
+      [namesOfSlice.modelInitAt]: /* @__PURE__ */ new Date(0),
+      [namesOfSlice.modelSelection]: new import_base.DataList(),
+      [namesOfSlice.modelInsight]: gql[names.defaultModelInsight],
+      [namesOfSlice.lastPageOfModel]: 1,
+      [namesOfSlice.pageOfModel]: 1,
+      [namesOfSlice.limitOfModel]: 20,
+      [namesOfSlice.queryArgsOfModel]: defaultArgs,
+      [namesOfSlice.sortOfModel]: "latest"
+    };
+    return Object.assign(acc, singleSliceState);
+  }, {});
+  return {
+    ...baseState,
+    ...sliceState
+  };
+}, "createState");
+const createActions = /* @__PURE__ */ __name((gql) => {
+  const formSetterActions = makeFormSetter(gql);
+  const baseActions = makeActions(gql);
+  return {
+    ...formSetterActions,
+    ...baseActions
+  };
+}, "createActions");
+const makeFormSetter = /* @__PURE__ */ __name((gql) => {
+  const fileGql = (0, import_signal.getGqlOnStorage)("file");
+  const [fieldName, className] = [
+    (0, import_common.lowerlize)(gql.refName),
+    (0, import_common.capitalize)(gql.refName)
+  ];
+  const modelRef = (0, import_constant.getFullModelRef)(gql.refName);
+  const fieldMetas = (0, import_constant.getFieldMetas)(modelRef);
+  const names = {
+    model: fieldName,
+    Model: className,
+    modelForm: `${fieldName}Form`,
+    writeOnModel: `writeOn${className}`,
+    addModelFiles: `add${className}Files`
+  };
+  const baseSetAction = {
+    [names.writeOnModel]: function(path, value) {
+      this.set((state) => {
+        (0, import_common.pathSet)(state[names.modelForm], path, value);
+      });
+    }
+  };
+  const fieldSetAction = fieldMetas.reduce((acc, fieldMeta) => {
+    const [fieldKeyName, classKeyName] = [
+      (0, import_common.lowerlize)(fieldMeta.key),
+      (0, import_common.capitalize)(fieldMeta.key)
+    ];
+    const namesOfField = {
+      field: fieldKeyName,
+      Field: classKeyName,
+      setFieldOnModel: `set${classKeyName}On${className}`,
+      addFieldOnModel: `add${classKeyName}On${className}`,
+      subFieldOnModel: `sub${classKeyName}On${className}`,
+      addOrSubFieldOnModel: `addOrSub${classKeyName}On${className}`,
+      uploadFieldOnModel: `upload${classKeyName}On${className}`
+    };
+    const singleFieldSetAction = {
+      [namesOfField.setFieldOnModel]: function(value) {
+        this.set((state) => {
+          const setValue = fieldMeta.isClass ? (0, import_signal.immerify)(fieldMeta.modelRef, value) : value;
+          state[names.modelForm][namesOfField.field] = setValue;
+        });
+      },
+      ...fieldMeta.isArray ? {
+        [namesOfField.addFieldOnModel]: function(value, options = {}) {
+          const form = this.get()[names.modelForm];
+          const length = form[namesOfField.field].length;
+          if (options.limit && options.limit <= length) return;
+          const idx = options.idx ?? length;
+          const setValue = fieldMeta.isClass ? (0, import_signal.immerify)(fieldMeta.modelRef, value) : value;
+          this.set((state) => {
+            state[names.modelForm][namesOfField.field] = [
+              ...form[namesOfField.field].slice(0, idx),
+              ...Array.isArray(setValue) ? setValue : [
+                setValue
+              ],
+              ...form[namesOfField.field].slice(idx)
+            ];
+          });
+        },
+        [namesOfField.subFieldOnModel]: function(idx) {
+          const form = this.get()[names.modelForm];
+          this.set((state) => {
+            state[names.modelForm][namesOfField.field] = typeof idx === "number" ? form[namesOfField.field].filter((_, i) => i !== idx) : form[namesOfField.field].filter((_, i) => !idx.includes(i));
+          });
+        },
+        [namesOfField.addOrSubFieldOnModel]: function(value, options = {}) {
+          const { [names.modelForm]: form } = this.get();
+          const index = form[namesOfField.field].findIndex((v) => v === value);
+          if (index === -1) this[namesOfField.addFieldOnModel](value, options);
+          else this[namesOfField.subFieldOnModel](index);
+        }
+      } : {},
+      ...fieldMeta.name === "File" ? {
+        [namesOfField.uploadFieldOnModel]: async function(fileList, index) {
+          const form = this.get()[names.modelForm];
+          if (!fileList.length) return;
+          const files = await gql[names.addModelFiles](fileList, form.id);
+          if (fieldMeta.isArray) {
+            const idx = index ?? form[namesOfField.field].length;
+            this.set((state) => {
+              state[names.modelForm][namesOfField.field] = [
+                ...form[namesOfField.field].slice(0, idx),
+                ...files,
+                ...form[namesOfField.field].slice(idx)
+              ];
+            });
+          } else {
+            this.set((state) => {
+              state[names.modelForm][namesOfField.field] = files[0];
+            });
+          }
+          files.map((file) => {
+            const intervalKey = setInterval(() => {
+              void (async () => {
+                const currentFile = await fileGql.file(file.id);
+                if (fieldMeta.isArray) this.set((state) => {
+                  state[names.modelForm][namesOfField.field] = state[names.modelForm][namesOfField.field].map((file2) => file2.id === currentFile.id ? currentFile : file2);
+                });
+                else this.set((state) => {
+                  state[names.modelForm][namesOfField.field] = currentFile;
+                });
+                if (currentFile.status !== "uploading") clearInterval(intervalKey);
+              })();
+            }, 3e3);
+          });
+        }
+      } : {}
+    };
+    return Object.assign(acc, singleFieldSetAction);
+  }, {});
+  return Object.assign(fieldSetAction, baseSetAction);
+}, "makeFormSetter");
+const makeActions = /* @__PURE__ */ __name((gql) => {
+  const [fieldName, className] = [
+    (0, import_common.lowerlize)(gql.refName),
+    (0, import_common.capitalize)(gql.refName)
+  ];
+  const modelRef = (0, import_constant.getFullModelRef)(className);
+  const lightModelRef = (0, import_constant.getLightModelRef)(modelRef);
+  const names = {
+    model: fieldName,
+    _model: `_${fieldName}`,
+    Model: className,
+    purifyModel: `purify${className}`,
+    crystalizeModel: `crystalize${className}`,
+    lightCrystalizeModel: `lightCrystalize${className}`,
+    crystalizeInsight: `crystalize${className}Insight`,
+    modelOperation: `${fieldName}Operation`,
+    defaultModel: `default${className}`,
+    modelInsight: `${fieldName}Insight`,
+    modelForm: `${fieldName}Form`,
+    modelSubmit: `${fieldName}Submit`,
+    modelLoading: `${fieldName}Loading`,
+    modelFormLoading: `${fieldName}FormLoading`,
+    modelList: `${fieldName}List`,
+    modelListLoading: `${fieldName}ListLoading`,
+    modelSelection: `${fieldName}Selection`,
+    createModelInForm: `create${className}InForm`,
+    updateModelInForm: `modify${className}InForm`,
+    createModel: `create${className}`,
+    updateModel: `update${className}`,
+    removeModel: `remove${className}`,
+    checkModelSubmitable: `check${className}Submitable`,
+    submitModel: `submit${className}`,
+    newModel: `new${className}`,
+    editModel: `edit${className}`,
+    mergeModel: `merge${className}`,
+    viewModel: `view${className}`,
+    setModel: `set${className}`,
+    resetModel: `reset${className}`,
+    modelViewAt: `${fieldName}ViewAt`,
+    modelModal: `${fieldName}Modal`,
+    initModel: `init${className}`,
+    modelInitList: `${fieldName}InitList`,
+    modelInitAt: `${fieldName}InitAt`,
+    refreshModel: `refresh${className}`,
+    selectModel: `select${className}`,
+    setPageOfModel: `setPageOf${className}`,
+    addPageOfModel: `addPageOf${className}`,
+    setLimitOfModel: `setLimitOf${className}`,
+    setQueryArgsOfModel: `setQueryArgsOf${className}`,
+    setSortOfModel: `setSortOf${className}`,
+    lastPageOfModel: `lastPageOf${className}`,
+    pageOfModel: `pageOf${className}`,
+    limitOfModel: `limitOf${className}`,
+    queryArgsOfModel: `queryArgsOf${className}`,
+    sortOfModel: `sortOf${className}`
+  };
+  const baseAction = {
+    [names.createModelInForm]: async function({ idx, path, modal, sliceName = names.model, onError, onSuccess } = {}) {
+      const SliceName = (0, import_common.capitalize)(sliceName);
+      const namesOfSlice = {
+        defaultModel: SliceName.replace(names.Model, names.defaultModel),
+        modelList: sliceName.replace(names.model, names.modelList),
+        modelListLoading: sliceName.replace(names.model, names.modelListLoading),
+        modelInsight: sliceName.replace(names.model, names.modelInsight)
+      };
+      const currentState = this.get();
+      const modelForm = currentState[names.modelForm];
+      const modelList = currentState[namesOfSlice.modelList];
+      const modelListLoading = currentState[namesOfSlice.modelListLoading];
+      const modelInsight = currentState[namesOfSlice.modelInsight];
+      const defaultModel = currentState[namesOfSlice.defaultModel];
+      const modelInput = gql[names.purifyModel](modelForm);
+      if (!modelInput) return;
+      this.set({
+        [names.modelLoading]: true
+      });
+      const model = await gql[names.createModel](modelInput, {
+        onError
+      });
+      const newModelList = modelListLoading ? modelList : new import_base.DataList([
+        ...modelList.slice(0, idx ?? 0),
+        model,
+        ...modelList.slice(idx ?? 0)
+      ]);
+      const newModelInsight = gql[names.crystalizeInsight]({
+        ...modelInsight,
+        count: modelInsight.count + 1
+      });
+      this.set({
+        [names.modelForm]: (0, import_signal.immerify)(modelRef, defaultModel),
+        [names.model]: model,
+        [names.modelLoading]: false,
+        [namesOfSlice.modelList]: newModelList,
+        [namesOfSlice.modelInsight]: newModelInsight,
+        [names.modelViewAt]: /* @__PURE__ */ new Date(),
+        [names.modelModal]: modal ?? null,
+        ...typeof path === "string" && path ? {
+          [path]: model
+        } : {}
+      });
+      await onSuccess?.(model);
+    },
+    [names.updateModelInForm]: async function({ path, modal, sliceName = names.model, onError, onSuccess } = {}) {
+      const SliceName = (0, import_common.capitalize)(sliceName);
+      const namesOfSlice = {
+        defaultModel: SliceName.replace(names.Model, names.defaultModel)
+      };
+      const currentState = this.get();
+      const model = currentState[names.model];
+      const modelForm = currentState[names.modelForm];
+      const defaultModel = currentState[namesOfSlice.defaultModel];
+      const modelInput = gql[names.purifyModel](modelForm);
+      if (!modelInput) return;
+      if (model?.id === modelForm.id) this.set({
+        [names.modelLoading]: modelForm.id
+      });
+      const updatedModel = await gql[names.updateModel](modelForm.id, modelInput, {
+        onError
+      });
+      this.set({
+        ...model?.id === updatedModel.id ? {
+          [names.model]: updatedModel,
+          [names.modelLoading]: false,
+          [names.modelViewAt]: /* @__PURE__ */ new Date()
+        } : {},
+        [names.modelForm]: (0, import_signal.immerify)(modelRef, defaultModel),
+        [names.modelModal]: modal ?? null,
+        ...typeof path === "string" && path ? {
+          [path]: updatedModel
+        } : {}
+      });
+      const updatedLightModel = gql[names.lightCrystalizeModel](updatedModel);
+      gql.slices.forEach(({ sliceName: sliceName2 }) => {
+        const namesOfSlice2 = {
+          modelList: sliceName2.replace(names.model, names.modelList),
+          modelListLoading: sliceName2.replace(names.model, names.modelListLoading)
+        };
+        const currentState2 = this.get();
+        const modelList = currentState2[namesOfSlice2.modelList];
+        const modelListLoading = currentState2[namesOfSlice2.modelListLoading];
+        if (modelListLoading || !modelList.has(updatedModel.id)) return;
+        const newModelList = new import_base.DataList(modelList).set(updatedLightModel);
+        this.set({
+          [namesOfSlice2.modelList]: newModelList
+        });
+      });
+      await onSuccess?.(updatedModel);
+    },
+    [names.createModel]: async function(data, { idx, path, modal, sliceName = names.model, onError, onSuccess } = {}) {
+      const SliceName = (0, import_common.capitalize)(sliceName);
+      const namesOfSlice = {
+        defaultModel: SliceName.replace(names.Model, names.defaultModel),
+        modelList: sliceName.replace(names.model, names.modelList),
+        modelListLoading: sliceName.replace(names.model, names.modelListLoading),
+        modelInsight: sliceName.replace(names.model, names.modelInsight)
+      };
+      const currentState = this.get();
+      const modelList = currentState[namesOfSlice.modelList];
+      const modelListLoading = currentState[namesOfSlice.modelListLoading];
+      const modelInsight = currentState[namesOfSlice.modelInsight];
+      const modelInput = gql[names.purifyModel](data);
+      if (!modelInput) return;
+      this.set({
+        [names.modelLoading]: true
+      });
+      const model = await gql[names.createModel](modelInput, {
+        onError
+      });
+      const newModelList = modelListLoading ? modelList : new import_base.DataList([
+        ...modelList.slice(0, idx ?? 0),
+        model,
+        ...modelList.slice(idx ?? 0)
+      ]);
+      const newModelInsight = gql[names.crystalizeInsight]({
+        ...modelInsight,
+        count: modelInsight.count + 1
+      });
+      this.set({
+        [names.model]: model,
+        [names.modelLoading]: false,
+        [namesOfSlice.modelList]: newModelList,
+        [namesOfSlice.modelInsight]: newModelInsight,
+        [names.modelViewAt]: /* @__PURE__ */ new Date(),
+        [names.modelModal]: modal ?? null,
+        ...typeof path === "string" && path ? {
+          [path]: model
+        } : {}
+      });
+      await onSuccess?.(model);
+    },
+    [names.updateModel]: async function(id, data, { idx, path, modal, sliceName = names.model, onError, onSuccess } = {}) {
+      const currentState = this.get();
+      const model = currentState[names.model];
+      const modelInput = gql[names.purifyModel](data);
+      if (!modelInput) return;
+      if (model?.id === id) this.set({
+        [names.modelLoading]: id
+      });
+      const updatedModel = await gql[names.updateModel](id, modelInput, {
+        onError
+      });
+      this.set({
+        ...model?.id === updatedModel.id ? {
+          [names.model]: updatedModel,
+          [names.modelLoading]: false,
+          [names.modelViewAt]: /* @__PURE__ */ new Date()
+        } : {},
+        [names.modelModal]: modal ?? null,
+        ...typeof path === "string" && path ? {
+          [path]: updatedModel
+        } : {}
+      });
+      const updatedLightModel = gql[names.lightCrystalizeModel](updatedModel);
+      gql.slices.forEach(({ sliceName: sliceName2 }) => {
+        const namesOfSlice = {
+          modelList: sliceName2.replace(names.model, names.modelList),
+          modelListLoading: sliceName2.replace(names.model, names.modelListLoading)
+        };
+        const currentState2 = this.get();
+        const modelList = currentState2[namesOfSlice.modelList];
+        const modelListLoading = currentState2[namesOfSlice.modelListLoading];
+        if (modelListLoading || !modelList.has(updatedModel.id)) return;
+        const newModelList = new import_base.DataList(modelList).set(updatedLightModel);
+        this.set({
+          [namesOfSlice.modelList]: newModelList
+        });
+      });
+      await onSuccess?.(updatedModel);
+    },
+    [names.removeModel]: async function(id, options) {
+      const { modal, ...fetchPolicyOptions } = options ?? {};
+      const model = await gql[names.removeModel](id, fetchPolicyOptions);
+      const lightModel = gql[names.lightCrystalizeModel](model);
+      gql.slices.forEach(({ sliceName }) => {
+        const namesOfSlice = {
+          modelList: sliceName.replace(names.model, names.modelList),
+          modelListLoading: sliceName.replace(names.model, names.modelListLoading),
+          modelSelection: sliceName.replace(names.model, names.modelSelection),
+          modelInsight: sliceName.replace(names.model, names.modelInsight)
+        };
+        const currentState = this.get();
+        const modelList = currentState[namesOfSlice.modelList];
+        const modelListLoading = currentState[namesOfSlice.modelListLoading];
+        const modelSelection = currentState[namesOfSlice.modelSelection];
+        const modelInsight = currentState[namesOfSlice.modelInsight];
+        if (modelListLoading || !modelList.has(model.id)) return;
+        const newModelList = new import_base.DataList(modelList);
+        if (model.removedAt) {
+          newModelList.delete(id);
+          const newModelInsight = gql[names.crystalizeInsight]({
+            ...modelInsight,
+            count: modelInsight.count - 1
+          });
+          const newModelSelection = new import_base.DataList(modelSelection);
+          newModelSelection.delete(id);
+          this.set({
+            [namesOfSlice.modelList]: newModelList,
+            [namesOfSlice.modelInsight]: newModelInsight,
+            ...modelSelection.has(model.id) ? {
+              [namesOfSlice.modelSelection]: newModelSelection
+            } : {},
+            ...modal !== void 0 ? {
+              [names.modelModal]: modal
+            } : {}
+          });
+        } else {
+          newModelList.set(lightModel);
+          this.set({
+            [namesOfSlice.modelList]: newModelList,
+            ...modal !== void 0 ? {
+              [names.modelModal]: modal
+            } : {}
+          });
+        }
+      });
+    },
+    [names.checkModelSubmitable]: function(disabled) {
+      const currentState = this.get();
+      const modelForm = currentState[names.modelForm];
+      const modelSubmit = currentState[names.modelSubmit];
+      const modelInput = gql[names.purifyModel](modelForm);
+      this.set({
+        [names.modelSubmit]: {
+          ...modelSubmit,
+          disabled: !modelInput || disabled
+        }
+      });
+    },
+    [names.submitModel]: async function(option) {
+      const currentState = this.get();
+      const modelForm = currentState[names.modelForm];
+      const modelSubmit = currentState[names.modelSubmit];
+      this.set({
+        [names.modelSubmit]: {
+          ...modelSubmit,
+          loading: true
+        }
+      });
+      if (modelForm.id) await this[names.updateModelInForm](option);
+      else await this[names.createModelInForm](option);
+      this.set({
+        [names.modelSubmit]: {
+          ...modelSubmit,
+          loading: false,
+          times: modelSubmit.times + 1
+        }
+      });
+    },
+    [names.newModel]: function(partial = {}, { modal, setDefault, sliceName = names.model } = {}) {
+      const SliceName = (0, import_common.capitalize)(sliceName);
+      const namesOfSlice = {
+        defaultModel: SliceName.replace(names.Model, names.defaultModel)
+      };
+      const currentState = this.get();
+      const defaultModel = currentState[namesOfSlice.defaultModel];
+      this.set({
+        [names.modelForm]: (0, import_signal.immerify)(modelRef, {
+          ...defaultModel,
+          ...partial
+        }),
+        [namesOfSlice.defaultModel]: setDefault ? (0, import_signal.immerify)(modelRef, {
+          ...defaultModel,
+          ...partial
+        }) : defaultModel,
+        [names.model]: null,
+        [names.modelModal]: modal ?? "edit",
+        [names.modelFormLoading]: false
+      });
+    },
+    [names.editModel]: async function(modelOrId, { modal, onError } = {}) {
+      const id = typeof modelOrId === "string" ? modelOrId : modelOrId.id;
+      this.set({
+        [names.modelFormLoading]: id,
+        [names.modelModal]: modal ?? "edit"
+      });
+      this.set((state) => {
+        state[names.modelForm].id = id;
+      });
+      const model = await gql[names.model](id, {
+        onError
+      });
+      const modelForm = (0, import_common.deepObjectify)(model);
+      this.set({
+        [names.model]: model,
+        [names.modelFormLoading]: false,
+        [names.modelViewAt]: /* @__PURE__ */ new Date(),
+        [names.modelForm]: modelForm
+      });
+    },
+    [names.mergeModel]: async function(modelOrId, data, options) {
+      const id = typeof modelOrId === "string" ? modelOrId : modelOrId.id;
+      const currentState = this.get();
+      const model = currentState[names.model];
+      if (id === model?.id) this.set({
+        modelLoading: id
+      });
+      const updatedModel = await gql[names.mergeModel](modelOrId, data, options);
+      this.set({
+        [names.model]: id === model?.id ? updatedModel : model,
+        [names.modelLoading]: false
+      });
+      const updatedLightModel = gql[names.lightCrystalizeModel](updatedModel);
+      gql.slices.forEach(({ sliceName }) => {
+        const namesOfSlice = {
+          modelList: sliceName.replace(names.model, names.modelList),
+          modelListLoading: sliceName.replace(names.model, names.modelListLoading)
+        };
+        const currentState2 = this.get();
+        const modelList = currentState2[namesOfSlice.modelList];
+        const modelListLoading = currentState2[namesOfSlice.modelListLoading];
+        if (modelListLoading || !modelList.has(updatedModel.id)) return;
+        const newModelList = new import_base.DataList(modelList).set(updatedLightModel);
+        this.set({
+          [namesOfSlice.modelList]: newModelList
+        });
+      });
+    },
+    [names.viewModel]: async function(modelOrId, { modal, onError } = {}) {
+      const id = typeof modelOrId === "string" ? modelOrId : modelOrId.id;
+      this.set({
+        [names.modelModal]: modal ?? "view",
+        [names.modelLoading]: id
+      });
+      const model = await gql[names.model](id, {
+        onError
+      });
+      this.set({
+        [names.model]: model,
+        [names.modelViewAt]: /* @__PURE__ */ new Date(),
+        [names.modelLoading]: false
+      });
+    },
+    [names.setModel]: function(fullOrLightModel) {
+      const currentState = this.get();
+      const model = currentState[names.model];
+      const isFull = fullOrLightModel instanceof modelRef;
+      if (isFull) {
+        const crystalizedModel = gql[names.crystalizeModel](fullOrLightModel);
+        this.set({
+          [names.model]: crystalizedModel
+        });
+      } else if (model?.id === fullOrLightModel.id) {
+        const crystalizedModel = gql[names.crystalizeModel]({
+          ...model,
+          ...fullOrLightModel
+        });
+        this.set({
+          [names.model]: crystalizedModel
+        });
+      }
+      const lightModel = gql[names.lightCrystalizeModel](fullOrLightModel);
+      gql.slices.forEach(({ sliceName }) => {
+        const namesOfSlice = {
+          modelList: sliceName.replace(names.model, names.modelList),
+          modelListLoading: sliceName.replace(names.model, names.modelListLoading)
+        };
+        const modelList = currentState[namesOfSlice.modelList];
+        const modelListLoading = currentState[namesOfSlice.modelListLoading];
+        if (modelListLoading || !modelList.has(lightModel.id)) return;
+        this.set({
+          [namesOfSlice.modelList]: modelList.set(lightModel).save()
+        });
+      });
+    },
+    [names.resetModel]: function(model) {
+      const currentState = this.get();
+      const defaultModel = currentState[names.defaultModel];
+      this.set({
+        [names.model]: model ?? null,
+        [names.modelViewAt]: /* @__PURE__ */ new Date(0),
+        [names.modelForm]: (0, import_signal.immerify)(modelRef, defaultModel),
+        [names.modelModal]: null
+      });
+      return model ?? null;
+    }
+  };
+  const sliceAction = gql.slices.reduce((acc, { sliceName, argLength }) => {
+    const SliceName = (0, import_common.capitalize)(sliceName);
+    const namesOfSlice = {
+      defaultModel: SliceName.replace(names.Model, names.defaultModel),
+      modelInsight: sliceName.replace(names.model, names.modelInsight),
+      modelList: sliceName.replace(names.model, names.modelList),
+      modelListLoading: sliceName.replace(names.model, names.modelListLoading),
+      initModel: SliceName.replace(names.Model, names.initModel),
+      modelInitList: SliceName.replace(names.Model, names.modelInitList),
+      modelInitAt: SliceName.replace(names.Model, names.modelInitAt),
+      refreshModel: SliceName.replace(names.Model, names.refreshModel),
+      selectModel: SliceName.replace(names.Model, names.selectModel),
+      setPageOfModel: SliceName.replace(names.Model, names.setPageOfModel),
+      addPageOfModel: SliceName.replace(names.Model, names.addPageOfModel),
+      setLimitOfModel: SliceName.replace(names.Model, names.setLimitOfModel),
+      setQueryArgsOfModel: SliceName.replace(names.Model, names.setQueryArgsOfModel),
+      setSortOfModel: SliceName.replace(names.Model, names.setSortOfModel),
+      lastPageOfModel: SliceName.replace(names.Model, names.lastPageOfModel),
+      pageOfModel: SliceName.replace(names.Model, names.pageOfModel),
+      limitOfModel: SliceName.replace(names.Model, names.limitOfModel),
+      queryArgsOfModel: SliceName.replace(names.Model, names.queryArgsOfModel),
+      sortOfModel: SliceName.replace(names.Model, names.sortOfModel),
+      modelSelection: SliceName.replace(names.Model, names.modelSelection)
+    };
+    const singleSliceAction = {
+      [namesOfSlice.initModel]: async function(...args) {
+        const initArgLength = Math.min(args.length, argLength);
+        const initForm = {
+          invalidate: false,
+          ...args[argLength] ?? {}
+        };
+        const queryArgs = new Array(initArgLength).fill(null).map((_, i) => args[i]);
+        const defaultModel = (0, import_signal.immerify)(modelRef, {
+          ...gql[names.defaultModel],
+          ...initForm.default ?? {}
+        });
+        this.set({
+          [names.defaultModel]: defaultModel
+        });
+        await this[namesOfSlice.refreshModel](...initArgLength === argLength ? [
+          ...queryArgs,
+          initForm
+        ] : queryArgs);
+      },
+      [namesOfSlice.refreshModel]: async function(...args) {
+        const refreshArgLength = Math.min(args.length, argLength);
+        const currentState = this.get();
+        const existingQueryArgs = currentState[namesOfSlice.queryArgsOfModel];
+        const queryArgs = [
+          ...new Array(refreshArgLength).fill(null).map((_, i) => args[i]),
+          ...existingQueryArgs.slice(refreshArgLength, argLength)
+        ];
+        const initForm = args[argLength] ?? {};
+        const { page = currentState[namesOfSlice.pageOfModel], limit = currentState[namesOfSlice.limitOfModel], sort = currentState[namesOfSlice.sortOfModel], invalidate = true } = initForm;
+        const modelOperation = currentState[names.modelOperation];
+        const queryArgsOfModel = currentState[namesOfSlice.queryArgsOfModel];
+        const pageOfModel = currentState[namesOfSlice.pageOfModel];
+        const limitOfModel = currentState[namesOfSlice.limitOfModel];
+        const sortOfModel = currentState[namesOfSlice.sortOfModel];
+        if (!invalidate && ![
+          "sleep",
+          "reset"
+        ].includes(modelOperation) && (0, import_common.isQueryEqual)(queryArgs, queryArgsOfModel) && page === pageOfModel && limit === limitOfModel && (0, import_common.isQueryEqual)(sort, sortOfModel)) return;
+        else this.set({
+          [namesOfSlice.modelListLoading]: true
+        });
+        const [modelDataList, modelInsight] = await Promise.all([
+          gql[namesOfSlice.modelList](...queryArgs, (page - 1) * limit, limit, sort, {
+            onError: initForm.onError
+          }),
+          gql[namesOfSlice.modelInsight](...queryArgs, {
+            onError: initForm.onError
+          })
+        ]);
+        const modelList = new import_base.DataList(modelDataList);
+        this.set({
+          [namesOfSlice.modelList]: modelList,
+          [namesOfSlice.modelListLoading]: false,
+          [namesOfSlice.modelInsight]: modelInsight,
+          [namesOfSlice.modelInitList]: modelList,
+          [namesOfSlice.modelInitAt]: /* @__PURE__ */ new Date(),
+          [namesOfSlice.lastPageOfModel]: Math.max(Math.floor((modelInsight.count - 1) / limit) + 1, 1),
+          [namesOfSlice.limitOfModel]: limit,
+          [namesOfSlice.queryArgsOfModel]: queryArgs,
+          [namesOfSlice.sortOfModel]: sort,
+          [namesOfSlice.pageOfModel]: page,
+          [names.modelOperation]: "idle"
+        });
+      },
+      [namesOfSlice.selectModel]: function(model, { refresh, remove } = {}) {
+        const models = Array.isArray(model) ? model : [
+          model
+        ];
+        const currentState = this.get();
+        const modelSelection = currentState[namesOfSlice.modelSelection];
+        if (refresh) this.set({
+          [namesOfSlice.modelSelection]: new import_base.DataList(models)
+        });
+        else if (remove) {
+          const newModelSelection = new import_base.DataList(modelSelection);
+          models.map((model2) => newModelSelection.delete(model2.id));
+          this.set({
+            [namesOfSlice.modelSelection]: newModelSelection
+          });
+        } else {
+          this.set({
+            [namesOfSlice.modelSelection]: new import_base.DataList([
+              ...modelSelection.values,
+              ...models
+            ])
+          });
+        }
+      },
+      [namesOfSlice.setPageOfModel]: async function(page, options) {
+        const currentState = this.get();
+        const queryArgsOfModel = currentState[namesOfSlice.queryArgsOfModel];
+        const pageOfModel = currentState[namesOfSlice.pageOfModel];
+        const limitOfModel = currentState[namesOfSlice.limitOfModel];
+        const sortOfModel = currentState[namesOfSlice.sortOfModel];
+        if (pageOfModel === page) return;
+        this.set({
+          [namesOfSlice.modelListLoading]: true
+        });
+        const modelDataList = await gql[namesOfSlice.modelList](...queryArgsOfModel, (page - 1) * limitOfModel, limitOfModel, sortOfModel, options);
+        const modelList = new import_base.DataList(modelDataList);
+        this.set({
+          [namesOfSlice.modelList]: modelList,
+          [namesOfSlice.pageOfModel]: page,
+          [namesOfSlice.modelListLoading]: false
+        });
+      },
+      [namesOfSlice.addPageOfModel]: async function(page, options) {
+        const currentState = this.get();
+        const modelList = currentState[namesOfSlice.modelList];
+        const queryArgsOfModel = currentState[namesOfSlice.queryArgsOfModel];
+        const pageOfModel = currentState[namesOfSlice.pageOfModel];
+        const limitOfModel = currentState[namesOfSlice.limitOfModel];
+        const sortOfModel = currentState[namesOfSlice.sortOfModel];
+        if (pageOfModel === page) return;
+        const addFront = page < pageOfModel;
+        const modelDataList = await gql[namesOfSlice.modelList](...queryArgsOfModel, (page - 1) * limitOfModel, limitOfModel, sortOfModel, options);
+        const newModelList = new import_base.DataList(addFront ? [
+          ...modelDataList,
+          ...modelList
+        ] : [
+          ...modelList,
+          ...modelDataList
+        ]);
+        this.set({
+          [namesOfSlice.modelList]: newModelList,
+          [namesOfSlice.pageOfModel]: page
+        });
+      },
+      [namesOfSlice.setLimitOfModel]: async function(limit, options) {
+        const currentState = this.get();
+        const modelInsight = currentState[namesOfSlice.modelInsight];
+        const queryArgsOfModel = currentState[namesOfSlice.queryArgsOfModel];
+        const pageOfModel = currentState[namesOfSlice.pageOfModel];
+        const limitOfModel = currentState[namesOfSlice.limitOfModel];
+        const sortOfModel = currentState[namesOfSlice.sortOfModel];
+        if (limitOfModel === limit) return;
+        const skip = (pageOfModel - 1) * limitOfModel;
+        const page = Math.max(Math.floor((skip - 1) / limit) + 1, 1);
+        const modelDataList = await gql[namesOfSlice.modelList](...queryArgsOfModel, (page - 1) * limit, limit, sortOfModel, options);
+        const modelList = new import_base.DataList(modelDataList);
+        this.set({
+          [namesOfSlice.modelList]: modelList,
+          [namesOfSlice.lastPageOfModel]: Math.max(Math.floor((modelInsight.count - 1) / limit) + 1, 1),
+          [namesOfSlice.limitOfModel]: limit,
+          [namesOfSlice.pageOfModel]: page
+        });
+      },
+      [namesOfSlice.setQueryArgsOfModel]: async function(...args) {
+        const queryArgs = new Array(argLength).fill(null).map((_, i) => args[i]);
+        const options = args[argLength];
+        const currentState = this.get();
+        const queryArgsOfModel = currentState[namesOfSlice.queryArgsOfModel];
+        const limitOfModel = currentState[namesOfSlice.limitOfModel];
+        const sortOfModel = currentState[namesOfSlice.sortOfModel];
+        if ((0, import_common.isQueryEqual)(queryArgsOfModel, queryArgs)) {
+          import_common.Logger.trace(`${namesOfSlice.queryArgsOfModel} store-level cache hit`);
+          return;
+        }
+        this.set({
+          [namesOfSlice.modelListLoading]: true
+        });
+        const [modelDataList, modelInsight] = await Promise.all([
+          gql[namesOfSlice.modelList](...queryArgs, 0, limitOfModel, sortOfModel, options),
+          gql[namesOfSlice.modelInsight](...queryArgs, options)
+        ]);
+        const modelList = new import_base.DataList(modelDataList);
+        this.set({
+          [namesOfSlice.queryArgsOfModel]: queryArgs,
+          [namesOfSlice.modelList]: modelList,
+          [namesOfSlice.modelInsight]: modelInsight,
+          [namesOfSlice.lastPageOfModel]: Math.max(Math.floor((modelInsight.count - 1) / limitOfModel) + 1, 1),
+          [namesOfSlice.pageOfModel]: 1,
+          [namesOfSlice.modelSelection]: /* @__PURE__ */ new Map(),
+          [namesOfSlice.modelListLoading]: false
+        });
+      },
+      [namesOfSlice.setSortOfModel]: async function(sort, options) {
+        const currentState = this.get();
+        const queryArgsOfModel = currentState[namesOfSlice.queryArgsOfModel];
+        const limitOfModel = currentState[namesOfSlice.limitOfModel];
+        const sortOfModel = currentState[namesOfSlice.sortOfModel];
+        if (sortOfModel === sort) return;
+        this.set({
+          [namesOfSlice.modelListLoading]: true
+        });
+        const modelDataList = await gql[namesOfSlice.modelList](...queryArgsOfModel, 0, limitOfModel, sort, options);
+        const modelList = new import_base.DataList(modelDataList);
+        this.set({
+          [namesOfSlice.modelList]: modelList,
+          [namesOfSlice.sortOfModel]: sort,
+          [namesOfSlice.pageOfModel]: 1,
+          [namesOfSlice.modelListLoading]: false
+        });
+      }
+    };
+    return Object.assign(acc, singleSliceAction);
+  }, {});
+  return {
+    ...baseAction,
+    ...sliceAction
+  };
+}, "makeActions");
+const stateOf = /* @__PURE__ */ __name((gql, state) => {
+  const applyState = Object.assign(createState(gql), state);
+  const applyAction = createActions(gql);
+  setStoreMeta(gql.refName, {
+    refName: gql.refName,
+    useKeys: Object.keys(applyState),
+    doKeys: Object.keys(applyAction),
+    slices: gql.slices
+  });
+  const applyStore = {
+    ...applyState,
+    ...applyAction
+  };
+  let StateStore = class StateStore {
+    static {
+      __name(this, "StateStore");
+    }
+    get;
+    set;
+    pick;
+  };
+  Object.keys(applyStore).forEach((key) => Object.defineProperty(StateStore.prototype, key, {
+    value: applyStore[key]
+  }));
+  return StateStore;
+}, "stateOf");
+const scalarStateOf = /* @__PURE__ */ __name((refName, state) => {
+  const applyState = state;
+  setStoreMeta(refName, {
+    refName,
+    useKeys: Object.keys(applyState),
+    doKeys: [],
+    slices: []
+  });
+  let StateStore = class StateStore {
+    static {
+      __name(this, "StateStore");
+    }
+    get;
+    set;
+    pick;
+  };
+  Object.keys(applyState).forEach((key) => Object.defineProperty(StateStore.prototype, key, {
+    value: applyState[key]
+  }));
+  return StateStore;
+}, "scalarStateOf");
+const Store = /* @__PURE__ */ __name((returnsOrObj) => {
+  const refName = typeof returnsOrObj === "object" ? returnsOrObj.name : (0, import_common.lowerlize)((0, import_constant.getClassMeta)(returnsOrObj()).refName);
+  const storeMeta = getStoreMeta(refName);
+  return function(target) {
+    const customDoKeys = Object.getOwnPropertyNames(target.prototype).filter((key) => key !== "constructor");
+    setStoreMeta(refName, {
+      ...storeMeta,
+      doKeys: [
+        ...storeMeta.doKeys,
+        ...customDoKeys
+      ]
+    });
+  };
+}, "Store");
+const createSelectors = /* @__PURE__ */ __name((_store, store = {}) => {
+  store.get = _store.getState;
+  store.set = (s) => {
+    if (typeof s === "function") _store.setState((st2) => {
+      s(st2);
+    });
+    else _store.setState(s);
+  };
+  store.sel = (selectFn, equals) => _store(selectFn, equals);
+  const state = store.get();
+  store.sub = _store.subscribe;
+  const useReference = /* @__PURE__ */ __name((selectFn) => {
+    const ref = (0, import_react.useRef)(selectFn(store.get()));
+    (0, import_react.useEffect)(() => {
+      return store.sub(selectFn, (val) => ref.current = val);
+    }, []);
+    return ref;
+  }, "useReference");
+  store.ref = useReference;
+  const existingUse = store.use;
+  const existingDo = store.do;
+  const existingSlice = store.slice;
+  if (!existingUse) Object.assign(store, {
+    use: {}
+  });
+  if (!existingDo) Object.assign(store, {
+    do: {}
+  });
+  if (!existingSlice) Object.assign(store, {
+    slice: {}
+  });
+  for (const k of Object.keys(state)) {
+    if (typeof state[k] !== "function") {
+      store.use[k] = () => store.sel((s) => s[k]);
+      const setKey = `set${(0, import_common.capitalize)(k)}`;
+      if (!state[setKey]) store.do[setKey] = (value) => {
+        store.set({
+          [k]: value
+        });
+      };
+    } else {
+      store.do[k] = async (...args) => {
+        try {
+          import_common.Logger.verbose(`${k} action loading...`);
+          const start = Date.now();
+          await state[k](...args);
+          const end = Date.now();
+          import_common.Logger.verbose(`=> ${k} action dispatched (${end - start}ms)`);
+        } catch (e) {
+          const errKey = typeof e === "string" ? e : e.message;
+          import_dictionary.msg.error(errKey, {
+            key: k
+          });
+          throw e;
+        }
+      };
+    }
+  }
+  const storeNames = getStoreNames();
+  for (const storeName of storeNames) {
+    const [fieldName, className] = [
+      (0, import_common.lowerlize)(storeName),
+      (0, import_common.capitalize)(storeName)
+    ];
+    const names = {
+      model: fieldName,
+      Model: className,
+      defaultModel: `default${className}`,
+      modelInsight: `${fieldName}Insight`,
+      modelList: `${fieldName}List`,
+      modelListLoading: `${fieldName}ListLoading`,
+      modelInitList: `${fieldName}InitList`,
+      modelInitAt: `${fieldName}InitAt`,
+      pageOfModel: `pageOf${className}`,
+      limitOfModel: `limitOf${className}`,
+      queryArgsOfModel: `queryArgsOf${className}`,
+      sortOfModel: `sortOf${className}`,
+      modelSelection: `${fieldName}Selection`,
+      initModel: `init${className}`,
+      refreshModel: `refresh${className}`,
+      selectModel: `select${className}`,
+      setPageOfModel: `setPageOf${className}`,
+      addPageOfModel: `addPageOf${className}`,
+      setLimitOfModel: `setLimitOf${className}`,
+      setQueryArgsOfModel: `setQueryArgsOf${className}`,
+      setSortOfModel: `setSortOf${className}`,
+      lastPageOfModel: `lastPageOf${className}`
+    };
+    const storeMeta = getStoreMeta(storeName);
+    storeMeta.slices.forEach(({ sliceName, argLength, refName }) => {
+      const SliceName = (0, import_common.capitalize)(sliceName);
+      const namesOfSliceState = {
+        defaultModel: SliceName.replace(names.Model, names.defaultModel),
+        modelInitList: SliceName.replace(names.Model, names.modelInitList),
+        modelInsight: sliceName.replace(names.model, names.modelInsight),
+        modelList: sliceName.replace(names.model, names.modelList),
+        modelListLoading: sliceName.replace(names.model, names.modelListLoading),
+        modelInitAt: SliceName.replace(names.Model, names.modelInitAt),
+        lastPageOfModel: SliceName.replace(names.Model, names.lastPageOfModel),
+        pageOfModel: SliceName.replace(names.Model, names.pageOfModel),
+        limitOfModel: SliceName.replace(names.Model, names.limitOfModel),
+        queryArgsOfModel: SliceName.replace(names.Model, names.queryArgsOfModel),
+        sortOfModel: SliceName.replace(names.Model, names.sortOfModel),
+        modelSelection: SliceName.replace(names.Model, names.modelSelection)
+      };
+      const namesOfSliceAction = {
+        initModel: SliceName.replace(names.Model, names.initModel),
+        refreshModel: SliceName.replace(names.Model, names.refreshModel),
+        selectModel: SliceName.replace(names.Model, names.selectModel),
+        setPageOfModel: SliceName.replace(names.Model, names.setPageOfModel),
+        addPageOfModel: SliceName.replace(names.Model, names.addPageOfModel),
+        setLimitOfModel: SliceName.replace(names.Model, names.setLimitOfModel),
+        setQueryArgsOfModel: SliceName.replace(names.Model, names.setQueryArgsOfModel),
+        setSortOfModel: SliceName.replace(names.Model, names.setSortOfModel)
+      };
+      store.slice[sliceName] = {
+        do: {},
+        use: {}
+      };
+      const targetSlice = store.slice[sliceName];
+      Object.keys(namesOfSliceAction).forEach((key) => {
+        targetSlice.do[names[key]] = store.do[namesOfSliceAction[key]];
+      });
+      Object.keys(namesOfSliceState).map((key) => {
+        targetSlice.use[names[key]] = store.use[namesOfSliceState[key]];
+        targetSlice.do[`set${(0, import_common.capitalize)(names[key])}`] = store.do[`set${(0, import_common.capitalize)(namesOfSliceState[key])}`];
+      });
+      targetSlice.sliceName = sliceName;
+      targetSlice.refName = refName;
+      targetSlice.argLength = argLength;
+    });
+  }
+  return store;
+}, "createSelectors");
+const makePicker = /* @__PURE__ */ __name((set, get) => (...fields) => {
+  const state = get();
+  const ret = {};
+  for (const field of fields) {
+    const val = state[field];
+    if (!val) throw new Error(`Field ${field} is not ready`);
+    if (typeof val === "string" && val.length === 0) throw new Error(`Field is empty string (${field})`);
+    else if ([
+      "self",
+      "me"
+    ].includes(field) && !state[field].id?.length) throw new Error("Self or Me Id is not defined");
+    ret[field] = val;
+  }
+  return ret;
+}, "makePicker");
+const makeStore = /* @__PURE__ */ __name((st2, storeRef, { library } = {}) => {
+  if (library) return st2;
+  const zustandStore = (0, import_zustand.create)((0, import_middleware.devtools)((0, import_middleware.subscribeWithSelector)((0, import_immer.immer)((set, get) => {
+    const store = {};
+    const pick = makePicker(set, get);
+    Object.getOwnPropertyNames(storeRef.prototype).forEach((key) => {
+      const descriptor = Object.getOwnPropertyDescriptor(storeRef.prototype, key);
+      if (descriptor) store[key] = descriptor.value;
+    });
+    Object.assign(store, {
+      set,
+      get,
+      pick
+    });
+    return store;
+  })), {
+    name: "root",
+    anonymousActionType: "root",
+    type: "root"
+  }));
+  return createSelectors(zustandStore, st2);
+}, "makeStore");
+const MixStore = /* @__PURE__ */ __name((s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20, s21, s22, s23, s24, s25, s26, s27, s28, s29, s30) => {
+  const stores = [
+    s1,
+    s2,
+    s3,
+    s4,
+    s5,
+    s6,
+    s7,
+    s8,
+    s9,
+    s10,
+    s11,
+    s12,
+    s13,
+    s14,
+    s15,
+    s16,
+    s17,
+    s18,
+    s19,
+    s20,
+    s21,
+    s22,
+    s23,
+    s24,
+    s25,
+    s26,
+    s27,
+    s28,
+    s29,
+    s30
+  ].filter((s) => !!s);
+  let Mix = class Mix {
+    static {
+      __name(this, "Mix");
+    }
+  };
+  (0, import_common.applyMixins)(Mix, stores);
+  return Mix;
+}, "MixStore");
+const rootStoreOf = /* @__PURE__ */ __name((store) => {
+  return Object.getPrototypeOf(store);
+}, "rootStoreOf");
+const Toast = /* @__PURE__ */ __name(({ root, duration = 3 } = {}) => {
+  return function(target, key, descriptor) {
+    const originMethod = descriptor.value;
+    descriptor.value = async function(...args) {
+      try {
+        import_dictionary.msg.loading(`${root ? `${root}.` : ""}${key}-loading`, {
+          key,
+          duration
+        });
+        const result = await originMethod.apply(this, args);
+        import_dictionary.msg.success(`${root ? `${root}.` : ""}${key}-success`, {
+          key,
+          duration
+        });
+        return result;
+      } catch (err) {
+        const errKey = typeof err === "string" ? err : err.message;
+        import_dictionary.msg.error(errKey, {
+          key,
+          duration
+        });
+        import_common.Logger.error(`${key} action error return: ${err}`);
+      }
+    };
+  };
+}, "Toast");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MixStore,
+  Store,
+  Toast,
+  createActions,
+  createState,
+  makeStore,
+  rootStoreOf,
+  scalarStateOf,
+  st,
+  stateOf
+});