@akanjs/signal 0.0.96 → 0.0.98

package/src/{gql.mjs → gql.cjs}

@@ -1,30 +1,46 @@
-import {
-  applyFnToArrayObjects,
-  DataList,
-  dayjs,
-  Enum,
-  Float,
-  getNonArrayModel,
-  ID,
-  Int,
-  isGqlScalar,
-  JSON as GqlJSON,
-  scalarDefaultMap
-} from "@akanjs/base";
-import { capitalize, Logger, lowerlize } from "@akanjs/common";
-import {
-  getClassMeta,
-  getFieldMetaMap,
-  getFieldMetas,
-  getGqlTypeStr,
-  getLightModelRef
-} from "@akanjs/constant";
-import { client, immerify } from ".";
-import {
-  getArgMetas,
-  getGqlMetas,
-  getSigMeta
-} from "./signalDecorators";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 gql_exports = {};
+__export(gql_exports, {
+  CrystalizeStorage: () => CrystalizeStorage,
+  DefaultStorage: () => DefaultStorage,
+  FragmentStorage: () => FragmentStorage,
+  GqlStorage: () => GqlStorage,
+  PurifyStorage: () => PurifyStorage,
+  deserializeArg: () => deserializeArg,
+  fetchOf: () => fetchOf,
+  getGqlOnStorage: () => getGqlOnStorage,
+  getGqlStr: () => getGqlStr,
+  gqlOf: () => gqlOf,
+  makeCrystalize: () => makeCrystalize,
+  makeDefault: () => makeDefault,
+  makeFetch: () => makeFetch,
+  makeFragment: () => makeFragment,
+  makePurify: () => makePurify,
+  scalarUtilOf: () => scalarUtilOf,
+  serializeArg: () => serializeArg
+});
+module.exports = __toCommonJS(gql_exports);
+var import_base = require("@akanjs/base");
+var import_common = require("@akanjs/common");
+var import_constant = require("@akanjs/constant");
+var import__ = require(".");
+var import_signalDecorators = require("./signalDecorators");
 function graphql(literals, ...args) {
   if (typeof literals === "string")
     literals = [literals];
@@ -49,12 +65,12 @@ class DefaultStorage {
 class CrystalizeStorage {
 }
 const scalarUtilOf = (name, target) => {
-  const refName = getClassMeta(target).refName;
-  const [fieldName, className] = [lowerlize(refName), capitalize(refName)];
+  const refName = (0, import_constant.getClassMeta)(target).refName;
+  const [fieldName, className] = [(0, import_common.lowerlize)(refName), (0, import_common.capitalize)(refName)];
   const graphQL = {
     refName,
     [className]: target,
-    [`default${className}`]: immerify(target, Object.assign(new target(), makeDefault(target))),
+    [`default${className}`]: (0, import__.immerify)(target, Object.assign(new target(), makeDefault(target))),
     [`purify${className}`]: makePurify(target),
     [`crystalize${className}`]: makeCrystalize(target),
     [`${fieldName}Fragment`]: makeFragment(target)
@@ -72,8 +88,8 @@ const setGqlOnStorage = (refName, modelGql) => {
 };
 const gqlOf = (constant, sigRef, option = {}) => {
   const refName = constant.refName;
-  const [fieldName, className] = [lowerlize(refName), capitalize(refName)];
-  const sigMeta = getSigMeta(sigRef);
+  const [fieldName, className] = [(0, import_common.lowerlize)(refName), (0, import_common.capitalize)(refName)];
+  const sigMeta = (0, import_signalDecorators.getSigMeta)(sigRef);
   const names = {
     refName,
     model: fieldName,
@@ -120,7 +136,7 @@ const gqlOf = (constant, sigRef, option = {}) => {
     [names.crystalizeModel]: makeCrystalize(constant.Full, option),
     [names.lightCrystalizeModel]: makeCrystalize(constant.Light, option),
     [names.crystalizeModelInsight]: makeCrystalize(constant.Insight, option),
-    [names.defaultModel]: immerify(
+    [names.defaultModel]: (0, import__.immerify)(
       constant.Full,
       Object.assign(new constant.Full(), makeDefault(constant.Full, option))
     ),
@@ -129,7 +145,7 @@ const gqlOf = (constant, sigRef, option = {}) => {
       makeDefault(constant.Insight, option)
     )
   };
-  const gql = Object.assign(option.overwrite ?? { client }, fetchOf(sigRef));
+  const gql = Object.assign(option.overwrite ?? { client: import__.client }, fetchOf(sigRef));
   const util = {
     [names.addModelFiles]: async (files, id, option2) => {
       const fileGql = getGqlOnStorage("file");
@@ -237,7 +253,7 @@ const gqlOf = (constant, sigRef, option = {}) => {
         const modelInit = await getInitFn(...args);
         const modelObjList = modelInit[names.modelObjList];
         const modelObjInsight = modelInit[names.modelObjInsight];
-        const modelList = new DataList(
+        const modelList = new import_base.DataList(
           modelObjList.map((modelObj) => base[names.lightCrystalizeModel](modelObj))
         );
         const modelInsight = base[names.crystalizeModelInsight](modelObjInsight);
@@ -273,13 +289,13 @@ const setPredefinedDefault = (refName, defaultData) => {
   Reflect.defineMetadata(refName, defaultData, DefaultStorage.prototype);
 };
 const makeDefault = (target, option = {}) => {
-  const classMeta = getClassMeta(target);
+  const classMeta = (0, import_constant.getClassMeta)(target);
   const predefinedDefault = getPredefinedDefault(classMeta.refName);
   if (predefinedDefault && !option.overwrite)
     return predefinedDefault;
   if (option.isChild && classMeta.type !== "scalar")
     return null;
-  const metadatas = getFieldMetas(target);
+  const metadatas = (0, import_constant.getFieldMetas)(target);
   const result = {};
   for (const metadata of metadatas) {
     if (metadata.fieldType === "hidden")
@@ -287,7 +303,7 @@ const makeDefault = (target, option = {}) => {
     else if (metadata.default) {
       if (typeof metadata.default === "function")
         result[metadata.key] = metadata.default();
-      else if (metadata.default instanceof Enum)
+      else if (metadata.default instanceof import_base.Enum)
         result[metadata.key] = [...metadata.default.values];
       else
         result[metadata.key] = metadata.default;
@@ -298,7 +314,7 @@ const makeDefault = (target, option = {}) => {
     else if (metadata.isClass)
       result[metadata.key] = metadata.isScalar ? makeDefault(metadata.modelRef) : null;
     else
-      result[metadata.key] = scalarDefaultMap.get(metadata.modelRef);
+      result[metadata.key] = import_base.scalarDefaultMap.get(metadata.modelRef);
   }
   setPredefinedDefault(classMeta.refName, result);
   return result;
@@ -354,16 +370,16 @@ const mutate = async (fetchClient, mutation, variables = {}, option = {}) => {
   return data;
 };
 const scalarPurifyMap = /* @__PURE__ */ new Map([
-  [Date, (value) => dayjs(value).toDate()],
+  [Date, (value) => (0, import_base.dayjs)(value).toDate()],
   [String, (value) => value],
-  [ID, (value) => value],
+  [import_base.ID, (value) => value],
   [Boolean, (value) => value],
-  [Int, (value) => value],
-  [Float, (value) => value],
-  [GqlJSON, (value) => value]
+  [import_base.Int, (value) => value],
+  [import_base.Float, (value) => value],
+  [import_base.JSON, (value) => value]
 ]);
 const getPurifyFn = (modelRef) => {
-  const [valueRef] = getNonArrayModel(modelRef);
+  const [valueRef] = (0, import_base.getNonArrayModel)(modelRef);
   return scalarPurifyMap.get(valueRef) ?? ((value) => value);
 };
 const purify = (metadata, value, self) => {
@@ -383,12 +399,12 @@ const purify = (metadata, value, self) => {
   if (metadata.isMap && metadata.of) {
     const purifyFn2 = getPurifyFn(metadata.of);
     return Object.fromEntries(
-      [...value.entries()].map(([key, val]) => [key, applyFnToArrayObjects(val, purifyFn2)])
+      [...value.entries()].map(([key, val]) => [key, (0, import_base.applyFnToArrayObjects)(val, purifyFn2)])
     );
   }
   if (metadata.isClass)
     return makePurify(metadata.modelRef)(value, true);
-  if (metadata.name === "Date" && dayjs(value).isBefore(dayjs(/* @__PURE__ */ new Date("0000"))))
+  if (metadata.name === "Date" && (0, import_base.dayjs)(value).isBefore((0, import_base.dayjs)(/* @__PURE__ */ new Date("0000"))))
     throw new Error(`Invalid Date Value (Default) in ${metadata.key} for value ${value}`);
   if (["String", "ID"].includes(metadata.name) && (value === "" || !value))
     throw new Error(`Invalid String Value (Default) in ${metadata.key} for value ${value}`);
@@ -407,11 +423,11 @@ const setPredefinedPurifyFn = (refName, purify2) => {
   Reflect.defineMetadata(refName, purify2, PurifyStorage.prototype);
 };
 const makePurify = (target, option = {}) => {
-  const classMeta = getClassMeta(target);
+  const classMeta = (0, import_constant.getClassMeta)(target);
   const purifyFn = getPredefinedPurifyFn(classMeta.refName);
   if (purifyFn && !option.overwrite)
     return purifyFn;
-  const metadatas = getFieldMetas(target);
+  const metadatas = (0, import_constant.getFieldMetas)(target);
   const fn = (self, isChild) => {
     try {
       if (isChild && classMeta.type !== "scalar") {
@@ -429,7 +445,7 @@ const makePurify = (target, option = {}) => {
     } catch (err) {
       if (isChild)
         throw new Error(err);
-      Logger.debug(err);
+      import_common.Logger.debug(err);
       return null;
     }
   };
@@ -437,13 +453,13 @@ const makePurify = (target, option = {}) => {
   return fn;
 };
 const scalarCrystalizeMap = /* @__PURE__ */ new Map([
-  [Date, (value) => dayjs(value)],
+  [Date, (value) => (0, import_base.dayjs)(value)],
   [String, (value) => value],
-  [ID, (value) => value],
+  [import_base.ID, (value) => value],
   [Boolean, (value) => value],
-  [Int, (value) => value],
-  [Float, (value) => value],
-  [GqlJSON, (value) => value]
+  [import_base.Int, (value) => value],
+  [import_base.Float, (value) => value],
+  [import_base.JSON, (value) => value]
 ]);
 const crystalize = (metadata, value) => {
   if (value === void 0 || value === null)
@@ -451,16 +467,16 @@ const crystalize = (metadata, value) => {
   if (metadata.isArray && Array.isArray(value))
     return value.map((v) => crystalize({ ...metadata, isArray: false }, v));
   if (metadata.isMap) {
-    const [valueRef] = getNonArrayModel(metadata.of);
+    const [valueRef] = (0, import_base.getNonArrayModel)(metadata.of);
     const crystalizeValue = scalarCrystalizeMap.get(valueRef) ?? ((value2) => value2);
     return new Map(
-      Object.entries(value).map(([key, val]) => [key, applyFnToArrayObjects(val, crystalizeValue)])
+      Object.entries(value).map(([key, val]) => [key, (0, import_base.applyFnToArrayObjects)(val, crystalizeValue)])
     );
   }
   if (metadata.isClass)
     return makeCrystalize(metadata.modelRef)(value, true);
   if (metadata.name === "Date")
-    return dayjs(value);
+    return (0, import_base.dayjs)(value);
   return (scalarCrystalizeMap.get(metadata.modelRef) ?? ((value2) => value2))(value);
 };
 const getPredefinedCrystalizeFn = (refName) => {
@@ -471,11 +487,11 @@ const setPredefinedCrystalizeFn = (refName, crystalize2) => {
   Reflect.defineMetadata(refName, crystalize2, CrystalizeStorage.prototype);
 };
 const makeCrystalize = (target, option = {}) => {
-  const classMeta = getClassMeta(target);
+  const classMeta = (0, import_constant.getClassMeta)(target);
   const crystalizeFn = getPredefinedCrystalizeFn(classMeta.refName);
   if (crystalizeFn && !option.overwrite && !option.partial?.length)
     return crystalizeFn;
-  const fieldMetaMap = getFieldMetaMap(target);
+  const fieldMetaMap = (0, import_constant.getFieldMetaMap)(target);
   const fieldKeys = option.partial?.length ? classMeta.type === "scalar" ? option.partial : ["id", ...option.partial, "updatedAt"] : [...fieldMetaMap.keys()];
   const metadatas = fieldKeys.map((key) => fieldMetaMap.get(key));
   const fn = (self, isChild) => {
@@ -498,16 +514,16 @@ const makeCrystalize = (target, option = {}) => {
   return fn;
 };
 const fragmentize = (target, fragMap = /* @__PURE__ */ new Map(), partial) => {
-  const classMeta = getClassMeta(target);
-  const metadatas = getFieldMetas(target);
+  const classMeta = (0, import_constant.getClassMeta)(target);
+  const metadatas = (0, import_constant.getFieldMetas)(target);
   const selectKeys = partial ? ["id", ...partial, "updatedAt"] : metadatas.map((metadata) => metadata.key);
   const selectKeySet = new Set(selectKeys);
-  const fragment = `fragment ${lowerlize(classMeta.refName)}Fragment on ${capitalize(
+  const fragment = `fragment ${(0, import_common.lowerlize)(classMeta.refName)}Fragment on ${(0, import_common.capitalize)(
     classMeta.type === "light" ? classMeta.refName.slice(5) : classMeta.refName
   )} {
 ` + metadatas.filter((metadata) => metadata.fieldType !== "hidden" && selectKeySet.has(metadata.key)).map((metadata) => {
     return metadata.isClass ? `  ${metadata.key} {
-    ...${lowerlize(metadata.name)}Fragment
+    ...${(0, import_common.lowerlize)(metadata.name)}Fragment
   }` : `  ${metadata.key}`;
   }).join(`
 `) + `
@@ -524,7 +540,7 @@ const setPredefinedFragment = (refName, fragment) => {
   Reflect.defineMetadata(refName, fragment, FragmentStorage.prototype);
 };
 const makeFragment = (target, option = {}) => {
-  const classMeta = getClassMeta(target);
+  const classMeta = (0, import_constant.getClassMeta)(target);
   const fragment = getPredefinedFragment(classMeta.refName);
   if (fragment && !option.overwrite && !option.excludeSelf && !option.partial?.length)
     return fragment;
@@ -537,25 +553,25 @@ const makeFragment = (target, option = {}) => {
   return gqlStr;
 };
 const getGqlStr = (modelRef, gqlMeta, argMetas, returnRef, partial) => {
-  const isScalar = isGqlScalar(modelRef);
+  const isScalar = (0, import_base.isGqlScalar)(modelRef);
   const argStr = makeArgStr(argMetas);
   const argAssignStr = makeArgAssignStr(argMetas);
   const returnStr = makeReturnStr(returnRef, partial);
   const gqlStr = `${isScalar ? "" : makeFragment(returnRef, { excludeSelf: !!partial?.length, partial })}
-${lowerlize(gqlMeta.type) + " " + gqlMeta.key + argStr}{
+${(0, import_common.lowerlize)(gqlMeta.type) + " " + gqlMeta.key + argStr}{
   ${gqlMeta.key}${argAssignStr}${returnStr}
 }
 `;
   return gqlStr;
 };
 const scalarSerializeMap = /* @__PURE__ */ new Map([
-  [Date, (value) => dayjs(value).toDate()],
+  [Date, (value) => (0, import_base.dayjs)(value).toDate()],
   [String, (value) => value],
-  [ID, (value) => value],
+  [import_base.ID, (value) => value],
   [Boolean, (value) => value],
-  [Int, (value) => value],
-  [Float, (value) => value],
-  [GqlJSON, (value) => value]
+  [import_base.Int, (value) => value],
+  [import_base.Float, (value) => value],
+  [import_base.JSON, (value) => value]
 ]);
 const getSerializeFn = (inputRef) => {
   const serializeFn = scalarSerializeMap.get(inputRef);
@@ -568,28 +584,28 @@ const serializeInput = (value, inputRef, arrDepth) => {
   if (arrDepth && Array.isArray(value))
     return value.map((v) => serializeInput(v, inputRef, arrDepth - 1));
   else if (inputRef.prototype === Map.prototype) {
-    const [valueRef] = getNonArrayModel(inputRef);
+    const [valueRef] = (0, import_base.getNonArrayModel)(inputRef);
     const serializeFn = getSerializeFn(valueRef);
     return Object.fromEntries(
-      [...value.entries()].map(([key, val]) => [key, applyFnToArrayObjects(val, serializeFn)])
+      [...value.entries()].map(([key, val]) => [key, (0, import_base.applyFnToArrayObjects)(val, serializeFn)])
     );
-  } else if (isGqlScalar(inputRef)) {
+  } else if ((0, import_base.isGqlScalar)(inputRef)) {
     const serializeFn = getSerializeFn(inputRef);
     return serializeFn(value);
   }
-  const classMeta = getClassMeta(inputRef);
+  const classMeta = (0, import_constant.getClassMeta)(inputRef);
   if (classMeta.type !== "scalar")
     return value;
   else
     return Object.fromEntries(
-      getFieldMetas(inputRef).map((fieldMeta) => [
+      (0, import_constant.getFieldMetas)(inputRef).map((fieldMeta) => [
         fieldMeta.key,
         serializeInput(value[fieldMeta.key], fieldMeta.modelRef, fieldMeta.arrDepth)
       ])
     );
 };
 const serializeArg = (argMeta, value) => {
-  const [returnRef, arrDepth] = getNonArrayModel(argMeta.returns());
+  const [returnRef, arrDepth] = (0, import_base.getNonArrayModel)(argMeta.returns());
   if (argMeta.argsOption.nullable && (value === null || value === void 0))
     return null;
   else if (!argMeta.argsOption.nullable && (value === null || value === void 0))
@@ -597,13 +613,13 @@ const serializeArg = (argMeta, value) => {
   return serializeInput(value, returnRef, arrDepth);
 };
 const scalarDeserializeMap = /* @__PURE__ */ new Map([
-  [Date, (value) => dayjs(value)],
+  [Date, (value) => (0, import_base.dayjs)(value)],
   [String, (value) => value],
-  [ID, (value) => value],
+  [import_base.ID, (value) => value],
   [Boolean, (value) => value],
-  [Int, (value) => value],
-  [Float, (value) => value],
-  [GqlJSON, (value) => value]
+  [import_base.Int, (value) => value],
+  [import_base.Float, (value) => value],
+  [import_base.JSON, (value) => value]
 ]);
 const getDeserializeFn = (inputRef) => {
   const deserializeFn = scalarDeserializeMap.get(inputRef);
@@ -615,28 +631,28 @@ const deserializeInput = (value, inputRef, arrDepth) => {
   if (arrDepth && Array.isArray(value))
     return value.map((v) => deserializeInput(v, inputRef, arrDepth - 1));
   else if (inputRef.prototype === Map.prototype) {
-    const [valueRef] = getNonArrayModel(inputRef);
+    const [valueRef] = (0, import_base.getNonArrayModel)(inputRef);
     const deserializeFn = getDeserializeFn(valueRef);
     return Object.fromEntries(
-      [...value.entries()].map(([key, val]) => [key, applyFnToArrayObjects(val, deserializeFn)])
+      [...value.entries()].map(([key, val]) => [key, (0, import_base.applyFnToArrayObjects)(val, deserializeFn)])
     );
-  } else if (isGqlScalar(inputRef)) {
+  } else if ((0, import_base.isGqlScalar)(inputRef)) {
     const deserializeFn = getDeserializeFn(inputRef);
     return deserializeFn(value);
   }
-  const classMeta = getClassMeta(inputRef);
+  const classMeta = (0, import_constant.getClassMeta)(inputRef);
   if (classMeta.type !== "scalar")
     return value;
   else
     return Object.fromEntries(
-      getFieldMetas(inputRef).map((fieldMeta) => [
+      (0, import_constant.getFieldMetas)(inputRef).map((fieldMeta) => [
         fieldMeta.key,
         deserializeInput(value[fieldMeta.key], fieldMeta.modelRef, fieldMeta.arrDepth)
       ])
     );
 };
 const deserializeArg = (argMeta, value) => {
-  const [returnRef, arrDepth] = getNonArrayModel(argMeta.returns());
+  const [returnRef, arrDepth] = (0, import_base.getNonArrayModel)(argMeta.returns());
   if (argMeta.argsOption.nullable && (value === null || value === void 0))
     return null;
   else if (!argMeta.argsOption.nullable && (value === null || value === void 0))
@@ -645,16 +661,16 @@ const deserializeArg = (argMeta, value) => {
 };
 const fetchOf = (sigRef) => {
   const gqls = {};
-  const gqlMetas = getGqlMetas(sigRef);
+  const gqlMetas = (0, import_signalDecorators.getGqlMetas)(sigRef);
   gqlMetas.filter((gqlMeta) => !gqlMeta.signalOption.default).forEach((gqlMeta) => {
     if (gqlMeta.type === "Message") {
-      const [returnRef, arrDepth] = getNonArrayModel(gqlMeta.returns());
-      const [argMetas] = getArgMetas(sigRef, gqlMeta.signalOption.name ?? gqlMeta.key);
-      const isScalar = isGqlScalar(returnRef);
+      const [returnRef, arrDepth] = (0, import_base.getNonArrayModel)(gqlMeta.returns());
+      const [argMetas] = (0, import_signalDecorators.getArgMetas)(sigRef, gqlMeta.signalOption.name ?? gqlMeta.key);
+      const isScalar = (0, import_base.isGqlScalar)(returnRef);
       const emitEvent = function(...args) {
         const fetchPolicy = args[argMetas.length] ?? { crystalize: true };
         if (!this.client.io && !fetchPolicy.url) {
-          Logger.warn(`${gqlMeta.key} emit suppressed - socket is not connected`);
+          import_common.Logger.warn(`${gqlMeta.key} emit suppressed - socket is not connected`);
           return;
         }
         const message = Object.fromEntries(
@@ -666,13 +682,13 @@ const fetchOf = (sigRef) => {
           const uri = fetchPolicy.url ?? "udpout:localhost:4000";
           const [host, port] = uri.split(":").slice(1);
           this.client.udp.send(JSON.stringify(message), parseInt(port), host);
-          Logger.debug(`udp emit: ${gqlMeta.key}: ${dayjs().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
+          import_common.Logger.debug(`udp emit: ${gqlMeta.key}: ${(0, import_base.dayjs)().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
           return;
         } else {
           const io = this.client.getIo(fetchPolicy.url);
           void this.client.waitUntilWebSocketConnected(fetchPolicy.url).then(() => {
             io.emit(gqlMeta.key, message);
-            Logger.debug(`socket emit: ${gqlMeta.key}: ${dayjs().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
+            import_common.Logger.debug(`socket emit: ${gqlMeta.key}: ${(0, import_base.dayjs)().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
           });
         }
       };
@@ -680,7 +696,7 @@ const fetchOf = (sigRef) => {
         const crystalize2 = (data) => {
           if (isScalar) {
             if (returnRef.prototype === Date.prototype)
-              return dayjs(data);
+              return (0, import_base.dayjs)(data);
             else
               return data;
           } else if (Array.isArray(data))
@@ -689,32 +705,32 @@ const fetchOf = (sigRef) => {
             return makeCrystalize(returnRef)(data);
         };
         const handle = (data) => {
-          Logger.debug(`socket listened: ${gqlMeta.key}: ${dayjs().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
+          import_common.Logger.debug(`socket listened: ${gqlMeta.key}: ${(0, import_base.dayjs)().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
           handleEvent(crystalize2(data));
         };
         const io = this.client.getIo(fetchPolicy.url);
         this.client.waitUntilWebSocketConnected(fetchPolicy.url).then(() => {
           io.removeListener(gqlMeta.key, handle);
           io.on(gqlMeta.key, handle);
-          Logger.debug(`socket listen start: ${gqlMeta.key}: ${dayjs().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
+          import_common.Logger.debug(`socket listen start: ${gqlMeta.key}: ${(0, import_base.dayjs)().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
         });
         return async () => {
           await this.client.waitUntilWebSocketConnected(fetchPolicy.url);
-          Logger.debug(`socket listen end: ${gqlMeta.key}: ${dayjs().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
+          import_common.Logger.debug(`socket listen end: ${gqlMeta.key}: ${(0, import_base.dayjs)().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
           io.removeListener(gqlMeta.key, handle);
         };
       };
       gqls[gqlMeta.key] = emitEvent;
-      gqls[`listen${capitalize(gqlMeta.key)}`] = listenEvent;
+      gqls[`listen${(0, import_common.capitalize)(gqlMeta.key)}`] = listenEvent;
     } else if (gqlMeta.type === "Pubsub") {
-      const [returnRef] = getNonArrayModel(gqlMeta.returns());
-      const [argMetas] = getArgMetas(sigRef, gqlMeta.signalOption.name ?? gqlMeta.key);
-      const isScalar = isGqlScalar(returnRef);
+      const [returnRef] = (0, import_base.getNonArrayModel)(gqlMeta.returns());
+      const [argMetas] = (0, import_signalDecorators.getArgMetas)(sigRef, gqlMeta.signalOption.name ?? gqlMeta.key);
+      const isScalar = (0, import_base.isGqlScalar)(returnRef);
       const makeRoomId = (gqlKey, argValues) => `${gqlKey}-${argValues.join("-")}`;
       const crystalize2 = (data) => {
         if (isScalar) {
           if (returnRef.prototype === Date.prototype)
-            return dayjs(data);
+            return (0, import_base.dayjs)(data);
           else
             return data;
         } else if (Array.isArray(data))
@@ -739,26 +755,26 @@ const fetchOf = (sigRef) => {
         );
         const io = this.client.getIo(fetchPolicy.url);
         void this.client.waitUntilWebSocketConnected(fetchPolicy.url).then(() => {
-          Logger.debug(`socket subscribe start: ${gqlMeta.key}: ${dayjs().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
+          import_common.Logger.debug(`socket subscribe start: ${gqlMeta.key}: ${(0, import_base.dayjs)().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
           io.subscribe({ key: gqlMeta.key, roomId, message, handleEvent });
         });
         return async () => {
           //! 앱에서 다른 앱 넘어갈 때 언마운트 되버리면서 subscribe가 끊기는 일이 있음.
           await this.client.waitUntilWebSocketConnected(fetchPolicy.url);
-          Logger.debug(`socket unsubscribe: ${gqlMeta.key}: ${dayjs().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
+          import_common.Logger.debug(`socket unsubscribe: ${gqlMeta.key}: ${(0, import_base.dayjs)().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
           io.unsubscribe(roomId, handleEvent);
         };
       };
-      gqls[`subscribe${capitalize(gqlMeta.key)}`] = subscribeEvent;
+      gqls[`subscribe${(0, import_common.capitalize)(gqlMeta.key)}`] = subscribeEvent;
     } else if (gqlMeta.type === "Query" || gqlMeta.type === "Mutation") {
       const name = gqlMeta.signalOption.name ?? gqlMeta.key;
       const makeReq = ({ resolve }) => async function(...args) {
-        Logger.debug(`fetch: ${gqlMeta.key} start: ${dayjs().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
+        import_common.Logger.debug(`fetch: ${gqlMeta.key} start: ${(0, import_base.dayjs)().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
         const now = Date.now();
-        const [argMetas] = getArgMetas(sigRef, gqlMeta.signalOption.name ?? gqlMeta.key);
-        const [modelRef, arrDepth] = getNonArrayModel(gqlMeta.returns());
-        const isScalar = isGqlScalar(modelRef);
-        const returnRef = isScalar || !arrDepth ? modelRef : getLightModelRef(modelRef);
+        const [argMetas] = (0, import_signalDecorators.getArgMetas)(sigRef, gqlMeta.signalOption.name ?? gqlMeta.key);
+        const [modelRef, arrDepth] = (0, import_base.getNonArrayModel)(gqlMeta.returns());
+        const isScalar = (0, import_base.isGqlScalar)(modelRef);
+        const returnRef = isScalar || !arrDepth ? modelRef : (0, import_constant.getLightModelRef)(modelRef);
         const fetchPolicy = args[argMetas.length] ?? { crystalize: true };
         const partial = fetchPolicy.partial ?? gqlMeta.signalOption.partial;
         const crystalize2 = (data) => {
@@ -766,7 +782,7 @@ const fetchOf = (sigRef) => {
             return data;
           if (isScalar) {
             if (returnRef.prototype === Date.prototype)
-              return dayjs(data);
+              return (0, import_base.dayjs)(data);
             else
               return data;
           } else if (Array.isArray(data))
@@ -784,12 +800,12 @@ const fetchOf = (sigRef) => {
             fetchPolicy
           ))[name];
           const data = resolve ? crystalize2(res) : res;
-          Logger.debug(
-            `fetch: ${gqlMeta.key} end: ${dayjs().format("YYYY-MM-DD HH:mm:ss.SSS")} ${Date.now() - now}ms`
+          import_common.Logger.debug(
+            `fetch: ${gqlMeta.key} end: ${(0, import_base.dayjs)().format("YYYY-MM-DD HH:mm:ss.SSS")} ${Date.now() - now}ms`
           );
           return data;
         } catch (e) {
-          Logger.error(`fetch: ${gqlMeta.key} error: ${e}`);
+          import_common.Logger.error(`fetch: ${gqlMeta.key} error: ${e}`);
           throw e;
         }
       };
@@ -804,9 +820,9 @@ const makeFetch = (fetch1, fetch2, fetch3, fetch4, fetch5, fetch6, fetch7, fetch
 };
 const makeArgStr = (argMetas) => {
   return argMetas.length ? `(${argMetas.map((argMeta) => {
-    const [argRef, arrDepth] = getNonArrayModel(argMeta.returns());
-    const argRefType = isGqlScalar(argRef) ? "gqlScalar" : getClassMeta(argRef).type === "scalar" ? "scalar" : "model";
-    const gqlTypeStr = "[".repeat(arrDepth) + (getGqlTypeStr(argRef) + (argRefType === "scalar" ? "Input" : "")) + "!]".repeat(arrDepth);
+    const [argRef, arrDepth] = (0, import_base.getNonArrayModel)(argMeta.returns());
+    const argRefType = (0, import_base.isGqlScalar)(argRef) ? "gqlScalar" : (0, import_constant.getClassMeta)(argRef).type === "scalar" ? "scalar" : "model";
+    const gqlTypeStr = "[".repeat(arrDepth) + ((0, import_constant.getGqlTypeStr)(argRef) + (argRefType === "scalar" ? "Input" : "")) + "!]".repeat(arrDepth);
     return `$${argMeta.name}: ` + gqlTypeStr + (argMeta.argsOption.nullable ? "" : "!");
   }).join(", ")})` : "";
 };
@@ -814,40 +830,21 @@ const makeArgAssignStr = (argMetas) => {
   return argMetas.length ? `(${argMetas.map((argMeta) => `${argMeta.name}: $${argMeta.name}`).join(", ")})` : "";
 };
 const makeReturnStr = (returnRef, partial) => {
-  const isScalar = isGqlScalar(returnRef);
+  const isScalar = (0, import_base.isGqlScalar)(returnRef);
   if (isScalar)
     return "";
-  const classMeta = getClassMeta(returnRef);
+  const classMeta = (0, import_constant.getClassMeta)(returnRef);
   if (!partial?.length)
     return ` {
-    ...${lowerlize(classMeta.refName)}Fragment
+    ...${(0, import_common.lowerlize)(classMeta.refName)}Fragment
   }`;
   const targetKeys = classMeta.type === "scalar" ? partial : [.../* @__PURE__ */ new Set(["id", ...partial, "updatedAt"])];
-  const fieldMetaMap = getFieldMetaMap(returnRef);
+  const fieldMetaMap = (0, import_constant.getFieldMetaMap)(returnRef);
   return ` {
 ${targetKeys.map((key) => fieldMetaMap.get(key)).filter((metadata) => metadata && metadata.fieldType !== "hidden").map(
     (fieldMeta) => fieldMeta.isClass ? `    ${fieldMeta.key} {
-      ...${lowerlize(fieldMeta.name)}Fragment
+      ...${(0, import_common.lowerlize)(fieldMeta.name)}Fragment
     }` : `    ${fieldMeta.key}`
   ).join("\n")}
   }`;
 };
-export {
-  CrystalizeStorage,
-  DefaultStorage,
-  FragmentStorage,
-  GqlStorage,
-  PurifyStorage,
-  deserializeArg,
-  fetchOf,
-  getGqlOnStorage,
-  getGqlStr,
-  gqlOf,
-  makeCrystalize,
-  makeDefault,
-  makeFetch,
-  makeFragment,
-  makePurify,
-  scalarUtilOf,
-  serializeArg
-};