@mionjs/core 0.8.0-alpha.0

package/.dist/esm/src/routerUtils.js

@@ -0,0 +1,209 @@
+import { JIT_FUNCTION_IDS, EMPTY_HASH, ROUTE_PATH_ROOT, PATH_SEPARATOR, ROUTER_ITEM_SEPARATOR_CHAR } from "./constants.js";
+import { getJitUtils } from "./jit/jitUtils.js";
+const methodsCache = {};
+const methodsOptionsCache = {};
+const jitFunctionsCache = /* @__PURE__ */ new Map();
+const headerJitFunctionsCache = /* @__PURE__ */ new Map();
+const routesCache = {
+  /**
+   * Get method metadata from the router cache by id.
+   * @param id - The method id
+   * @returns The method metadata or undefined if not found
+   */
+  getMetadata(id) {
+    return methodsCache[id];
+  },
+  /**
+   * Set method metadata in the router cache
+   * @param id - The method id
+   * @param methodData - The method metadata
+   */
+  setMetadata(id, methodData) {
+    methodsCache[id] = methodData;
+  },
+  /**
+   * Check if the router cache contains a method by id.
+   * @param id - The method id
+   * @returns True if the method exists in the cache
+   */
+  hasMetadata(id) {
+    return id in methodsCache;
+  },
+  /**
+   * Get the raw router cache object.
+   * Use with caution - prefer using get/set/has methods.
+   * @returns The router cache object
+   */
+  getCache() {
+    return methodsCache;
+  },
+  /**
+   * Get method metadata with JIT functions restored from the router cache by id.
+   * This augments the MethodWithOptions with paramsJitFns and returnJitFns.
+   * JIT functions are cached in the entry after first access for performance.
+   * @param id - The method id
+   * @returns The method metadata with JIT functions or undefined if not found
+   */
+  getMethodJitFns(id) {
+    if (id in methodsCache) {
+      const cached = methodsCache[id];
+      if (cached.paramsJitFns && cached.returnJitFns) {
+        return cached;
+      }
+    }
+    const metadata = this.getMetadata(id);
+    if (!metadata) return void 0;
+    const paramsJitFns = getJitFunctionsFromHash(metadata.paramsJitHash);
+    const returnJitFns = getJitFunctionsFromHash(metadata.returnJitHash);
+    const headersParam = metadata.headersParam ? { ...metadata.headersParam, jitFns: getHeaderJitFunctionsFromHash(metadata.headersParam.jitHash) } : void 0;
+    const headersReturn = metadata.headersReturn ? { ...metadata.headersReturn, jitFns: getHeaderJitFunctionsFromHash(metadata.headersReturn.jitHash) } : void 0;
+    const result = {
+      ...metadata,
+      paramsJitFns,
+      returnJitFns,
+      headersParam,
+      headersReturn
+    };
+    methodsCache[id] = result;
+    return result;
+  },
+  /**
+   * Get method metadata with JIT functions restored from the router cache by id.
+   * @param id
+   * @returns
+   */
+  useMethodJitFns(id) {
+    const MethodWithOptsAndJitFns = this.getMethodJitFns(id);
+    if (!MethodWithOptsAndJitFns) throw new Error(`Metadata for remote method ${id} not found`);
+    return MethodWithOptsAndJitFns;
+  },
+  /**
+   * Set method metadata with JIT functions in the router cache.
+   * This stores the complete MethodWithOptsAndJitFns object directly.
+   * @param id - The method id
+   * @param MethodWithOptsAndJitFns - The method metadata with JIT functions
+   */
+  setMethodJitFns(id, MethodWithOptsAndJitFns) {
+    methodsCache[id] = MethodWithOptsAndJitFns;
+  }
+};
+const methodOptsCache = {
+  getMethodOptions(id) {
+    return methodsOptionsCache[id];
+  },
+  setMethodOptions(id, options) {
+    methodsOptionsCache[id] = options;
+  }
+};
+function addRoutesToCache(newCache) {
+  for (const key in newCache) {
+    if (!(key in methodsCache)) {
+      methodsCache[key] = { ...newCache[key] };
+    }
+  }
+}
+function getJitFnHashes(jitHash) {
+  return {
+    isType: `${JIT_FUNCTION_IDS.isType}_${jitHash}`,
+    typeErrors: `${JIT_FUNCTION_IDS.typeErrors}_${jitHash}`,
+    prepareForJson: `${JIT_FUNCTION_IDS.prepareForJson}_${jitHash}`,
+    restoreFromJson: `${JIT_FUNCTION_IDS.restoreFromJson}_${jitHash}`,
+    stringifyJson: `${JIT_FUNCTION_IDS.stringifyJson}_${jitHash}`,
+    toBinary: `${JIT_FUNCTION_IDS.toBinary}_${jitHash}`,
+    fromBinary: `${JIT_FUNCTION_IDS.fromBinary}_${jitHash}`
+  };
+}
+function getJitFunctionsFromHash(jitHash) {
+  if (jitHash === EMPTY_HASH) return noopJitFns;
+  const cached = jitFunctionsCache.get(jitHash);
+  if (cached) return cached;
+  const hashes = getJitFnHashes(jitHash);
+  const jUtils = getJitUtils();
+  const jitFns = {
+    isType: jUtils.getJIT(hashes.isType),
+    typeErrors: jUtils.getJIT(hashes.typeErrors),
+    prepareForJson: jUtils.getJIT(hashes.prepareForJson),
+    restoreFromJson: jUtils.getJIT(hashes.restoreFromJson),
+    stringifyJson: jUtils.getJIT(hashes.stringifyJson),
+    toBinary: jUtils.getJIT(hashes.toBinary),
+    fromBinary: jUtils.getJIT(hashes.fromBinary)
+  };
+  for (const key in jitFns) {
+    if (!jitFns[key]) throw new Error(`Jit function ${key} not found for jitHash ${jitHash}`);
+  }
+  jitFunctionsCache.set(jitHash, jitFns);
+  return jitFns;
+}
+function getHeaderJitFunctionsFromHash(jitHash) {
+  const cached = headerJitFunctionsCache.get(jitHash);
+  if (cached) return cached;
+  const hashes = getJitFnHashes(jitHash);
+  const jUtils = getJitUtils();
+  const jitFns = {
+    isType: jUtils.getJIT(hashes.isType),
+    typeErrors: jUtils.getJIT(hashes.typeErrors)
+  };
+  headerJitFunctionsCache.set(jitHash, jitFns);
+  return jitFns;
+}
+function getRouterItemId(itemPointer) {
+  return itemPointer.join(ROUTER_ITEM_SEPARATOR_CHAR);
+}
+function getRoutePath(pathPointer, routerOptions) {
+  const pathId = getRouterItemId(pathPointer);
+  const basePath = routerOptions.basePath.startsWith(ROUTE_PATH_ROOT) ? routerOptions.basePath : `${ROUTE_PATH_ROOT}${routerOptions.basePath}`;
+  const routePath = basePath.endsWith(PATH_SEPARATOR) ? `${basePath}${pathId}` : `${basePath}${PATH_SEPARATOR}${pathId}`;
+  return routerOptions.suffix ? routePath + routerOptions.suffix : routePath;
+}
+function resetRoutesCache() {
+  for (const k in methodsCache) delete methodsCache[k];
+}
+function resetJitFunctionsCache() {
+  jitFunctionsCache.clear();
+  headerJitFunctionsCache.clear();
+}
+const noopJitFns = {
+  isType: fakeJitFn(JIT_FUNCTION_IDS.isType),
+  typeErrors: fakeJitFn(JIT_FUNCTION_IDS.typeErrors),
+  prepareForJson: fakeJitFn(JIT_FUNCTION_IDS.prepareForJson),
+  restoreFromJson: fakeJitFn(JIT_FUNCTION_IDS.restoreFromJson),
+  stringifyJson: fakeJitFn(JIT_FUNCTION_IDS.stringifyJson),
+  toBinary: fakeJitFn(JIT_FUNCTION_IDS.toBinary),
+  fromBinary: fakeJitFn(JIT_FUNCTION_IDS.fromBinary)
+};
+function fakeJitFn(fnID) {
+  return {
+    typeName: "mionNoopJit",
+    fnID,
+    jitFnHash: EMPTY_HASH,
+    args: { vλl: "v" },
+    defaultParamValues: { vλl: "v" },
+    isNoop: true,
+    code: "",
+    jitDependencies: [],
+    pureFnDependencies: [],
+    createJitFn: () => {
+      throw new Error("isNoop JIT functions should not be called, this is a function when jit is never used");
+    },
+    fn: () => {
+      throw new Error("isNoop JIT functions should not be called, this is a function when jit is never used");
+    }
+  };
+}
+function getNoopJitFns() {
+  return noopJitFns;
+}
+export {
+  addRoutesToCache,
+  getHeaderJitFunctionsFromHash,
+  getJitFnHashes,
+  getJitFunctionsFromHash,
+  getNoopJitFns,
+  getRoutePath,
+  getRouterItemId,
+  methodOptsCache,
+  resetJitFunctionsCache,
+  resetRoutesCache,
+  routesCache
+};
+//# sourceMappingURL=routerUtils.js.map

package/.dist/esm/src/routerUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"routerUtils.js","sources":["../../../src/routerUtils.ts"],"sourcesContent":["/* ########\n * 2023 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {JIT_FUNCTION_IDS, PATH_SEPARATOR, ROUTER_ITEM_SEPARATOR_CHAR, ROUTE_PATH_ROOT, EMPTY_HASH} from './constants.ts';\nimport type {RemoteMethodOpts, MethodWithOptions, MethodsCache, MethodWithOptsAndJitFns} from './types/method.types.ts';\nimport type {CoreRouterOptions, JitCompiledFn, JitCompiledFunctions, JitFunctionsHashes} from './types/general.types.ts';\nimport {getJitUtils} from './jit/jitUtils.ts';\n\nconst methodsCache: MethodsCache = {};\nconst methodsOptionsCache: Record<string, RemoteMethodOpts> = {};\n\n// Cache for JitCompiledFunctions objects keyed by jitHash\nconst jitFunctionsCache = new Map<string, JitCompiledFunctions>();\nconst headerJitFunctionsCache = new Map<string, Pick<JitCompiledFunctions, 'isType' | 'typeErrors'>>();\n\n/**\n * Utilities for accessing and modifying the router cache.\n * The router cache stores method metadata for routes registered via addRoutesToCache() or virtual modules.\n */\nexport const routesCache = {\n    /**\n     * Get method metadata from the router cache by id.\n     * @param id - The method id\n     * @returns The method metadata or undefined if not found\n     */\n    getMetadata(id: string): MethodWithOptions | undefined {\n        return methodsCache[id] as MethodWithOptions | undefined;\n    },\n\n    /**\n     * Set method metadata in the router cache\n     * @param id - The method id\n     * @param methodData - The method metadata\n     */\n    setMetadata(id: string, methodData: MethodWithOptions): void {\n        methodsCache[id] = methodData as any;\n    },\n\n    /**\n     * Check if the router cache contains a method by id.\n     * @param id - The method id\n     * @returns True if the method exists in the cache\n     */\n    hasMetadata(id: string): boolean {\n        return id in methodsCache;\n    },\n\n    /**\n     * Get the raw router cache object.\n     * Use with caution - prefer using get/set/has methods.\n     * @returns The router cache object\n     */\n    getCache(): MethodsCache {\n        return methodsCache;\n    },\n\n    /**\n     * Get method metadata with JIT functions restored from the router cache by id.\n     * This augments the MethodWithOptions with paramsJitFns and returnJitFns.\n     * JIT functions are cached in the entry after first access for performance.\n     * @param id - The method id\n     * @returns The method metadata with JIT functions or undefined if not found\n     */\n    getMethodJitFns(id: string): MethodWithOptsAndJitFns | undefined {\n        if (id in methodsCache) {\n            const cached = methodsCache[id] as any;\n            if (cached.paramsJitFns && cached.returnJitFns) {\n                return cached as MethodWithOptsAndJitFns;\n            }\n        }\n\n        const metadata = this.getMetadata(id);\n        if (!metadata) return undefined;\n\n        const paramsJitFns = getJitFunctionsFromHash(metadata.paramsJitHash);\n        const returnJitFns = getJitFunctionsFromHash(metadata.returnJitHash);\n        const headersParam = metadata.headersParam\n            ? {...metadata.headersParam, jitFns: getHeaderJitFunctionsFromHash(metadata.headersParam.jitHash)}\n            : undefined;\n        const headersReturn = metadata.headersReturn\n            ? {...metadata.headersReturn, jitFns: getHeaderJitFunctionsFromHash(metadata.headersReturn.jitHash)}\n            : undefined;\n\n        const result: MethodWithOptsAndJitFns = {\n            ...metadata,\n            paramsJitFns,\n            returnJitFns,\n            headersParam,\n            headersReturn,\n        };\n\n        methodsCache[id] = result;\n        return result as MethodWithOptsAndJitFns;\n    },\n\n    /**\n     * Get method metadata with JIT functions restored from the router cache by id.\n     * @param id\n     * @returns\n     */\n    useMethodJitFns(id: string): MethodWithOptsAndJitFns {\n        const MethodWithOptsAndJitFns = this.getMethodJitFns(id);\n        if (!MethodWithOptsAndJitFns) throw new Error(`Metadata for remote method ${id} not found`);\n        return MethodWithOptsAndJitFns;\n    },\n\n    /**\n     * Set method metadata with JIT functions in the router cache.\n     * This stores the complete MethodWithOptsAndJitFns object directly.\n     * @param id - The method id\n     * @param MethodWithOptsAndJitFns - The method metadata with JIT functions\n     */\n    setMethodJitFns(id: string, MethodWithOptsAndJitFns: MethodWithOptsAndJitFns): void {\n        methodsCache[id] = MethodWithOptsAndJitFns as any;\n    },\n};\n\nexport const methodOptsCache = {\n    getMethodOptions(id: string): RemoteMethodOpts | undefined {\n        return methodsOptionsCache[id];\n    },\n    setMethodOptions(id: string, options: RemoteMethodOpts): void {\n        methodsOptionsCache[id] = options;\n    },\n};\n\n/**\n * Adds new routes to the router cache.\n * This is the public API for registering routes - called by virtual modules or directly.\n * @param newCache\n */\nexport function addRoutesToCache(newCache: MethodsCache) {\n    for (const key in newCache) {\n        if (!(key in methodsCache)) {\n            // Clone the cache entry to avoid mutating the original\n            methodsCache[key] = {...newCache[key]} as MethodWithOptions;\n        }\n    }\n}\n\nexport function getJitFnHashes(jitHash: string): JitFunctionsHashes {\n    return {\n        isType: `${JIT_FUNCTION_IDS.isType}_${jitHash}`,\n        typeErrors: `${JIT_FUNCTION_IDS.typeErrors}_${jitHash}`,\n        prepareForJson: `${JIT_FUNCTION_IDS.prepareForJson}_${jitHash}`,\n        restoreFromJson: `${JIT_FUNCTION_IDS.restoreFromJson}_${jitHash}`,\n        stringifyJson: `${JIT_FUNCTION_IDS.stringifyJson}_${jitHash}`,\n        toBinary: `${JIT_FUNCTION_IDS.toBinary}_${jitHash}`,\n        fromBinary: `${JIT_FUNCTION_IDS.fromBinary}_${jitHash}`,\n    };\n}\n\n/**\n * Helper function to get JIT functions from a JIT hash\n * Returns nullJitFns for empty hash (handlers with no params or void return)\n * Results are cached to avoid creating duplicate objects.\n */\nexport function getJitFunctionsFromHash(jitHash: string): JitCompiledFunctions {\n    // Empty hash means no JIT functions were generated (optimization for no params or void return)\n    if (jitHash === EMPTY_HASH) return noopJitFns;\n\n    // Check cache first\n    const cached = jitFunctionsCache.get(jitHash);\n    if (cached) return cached;\n\n    const hashes = getJitFnHashes(jitHash);\n    const jUtils = getJitUtils();\n    const jitFns = {\n        isType: jUtils.getJIT(hashes.isType),\n        typeErrors: jUtils.getJIT(hashes.typeErrors),\n        prepareForJson: jUtils.getJIT(hashes.prepareForJson),\n        restoreFromJson: jUtils.getJIT(hashes.restoreFromJson),\n        stringifyJson: jUtils.getJIT(hashes.stringifyJson),\n        toBinary: jUtils.getJIT(hashes.toBinary),\n        fromBinary: jUtils.getJIT(hashes.fromBinary),\n    } as JitCompiledFunctions;\n    for (const key in jitFns) {\n        if (!jitFns[key]) throw new Error(`Jit function ${key} not found for jitHash ${jitHash}`);\n    }\n\n    // Cache for future calls\n    jitFunctionsCache.set(jitHash, jitFns);\n    return jitFns;\n}\n\n/**\n * Helper function to get header JIT functions from a JIT hash\n * Results are cached to avoid creating duplicate objects.\n */\nexport function getHeaderJitFunctionsFromHash(jitHash: string): Pick<JitCompiledFunctions, 'isType' | 'typeErrors'> {\n    // Check cache first\n    const cached = headerJitFunctionsCache.get(jitHash);\n    if (cached) return cached;\n\n    const hashes = getJitFnHashes(jitHash);\n    const jUtils = getJitUtils();\n    const jitFns = {\n        isType: jUtils.getJIT(hashes.isType),\n        typeErrors: jUtils.getJIT(hashes.typeErrors),\n    } as Pick<JitCompiledFunctions, 'isType' | 'typeErrors'>;\n\n    // Cache for future calls\n    headerJitFunctionsCache.set(jitHash, jitFns);\n    return jitFns;\n}\n\n/**\n * Get the router id for Routes or MiddleFns\n * @param itemPointer - The pointer to the item within the Routes object\n * i.e:\n * const routes = {\n *   auth: () => {},\n *   users: {\n *    getUser: () => {}\n *   }\n *   login: () => {}\n * }\n *\n * then the pointer for getUser is => ['users', 'getUser']\n */\nexport function getRouterItemId(itemPointer: string[]) {\n    return itemPointer.join(ROUTER_ITEM_SEPARATOR_CHAR);\n}\n\n/** Gets a route path from a route pointer */\nexport function getRoutePath(pathPointer: string[], routerOptions: CoreRouterOptions) {\n    const pathId = getRouterItemId(pathPointer);\n    const basePath = routerOptions.basePath.startsWith(ROUTE_PATH_ROOT)\n        ? routerOptions.basePath\n        : `${ROUTE_PATH_ROOT}${routerOptions.basePath}`;\n    const routePath = basePath.endsWith(PATH_SEPARATOR) ? `${basePath}${pathId}` : `${basePath}${PATH_SEPARATOR}${pathId}`;\n    return routerOptions.suffix ? routePath + routerOptions.suffix : routePath;\n}\n\nexport function resetRoutesCache() {\n    for (const k in methodsCache) delete methodsCache[k];\n}\n\n/** Resets the JIT functions cache. Useful for testing purposes only. */\nexport function resetJitFunctionsCache(): void {\n    jitFunctionsCache.clear();\n    headerJitFunctionsCache.clear();\n}\n\n// Noop JIT functions used for handlers with no params or void return\n// prettier-ignore\nconst noopJitFns: JitCompiledFunctions = {\n    isType: fakeJitFn(JIT_FUNCTION_IDS.isType),\n    typeErrors: fakeJitFn(JIT_FUNCTION_IDS.typeErrors),\n    prepareForJson: fakeJitFn(JIT_FUNCTION_IDS.prepareForJson),\n    restoreFromJson: fakeJitFn(JIT_FUNCTION_IDS.restoreFromJson),\n    stringifyJson: fakeJitFn(JIT_FUNCTION_IDS.stringifyJson),\n    toBinary: fakeJitFn(JIT_FUNCTION_IDS.toBinary),\n    fromBinary: fakeJitFn(JIT_FUNCTION_IDS.fromBinary),\n} as any;\n\n/** Creates a fake JIT function with isNoop=true for handlers with no params or void return */\nfunction fakeJitFn(fnID: string): JitCompiledFn<any> {\n    return {\n        typeName: 'mionNoopJit',\n        fnID,\n        jitFnHash: EMPTY_HASH,\n        args: {vλl: 'v'},\n        defaultParamValues: {vλl: 'v'},\n        isNoop: true,\n        code: '',\n        jitDependencies: [],\n        pureFnDependencies: [],\n        createJitFn: () => {\n            throw new Error('isNoop JIT functions should not be called, this is a function when jit is never used');\n        },\n        fn: () => {\n            throw new Error('isNoop JIT functions should not be called, this is a function when jit is never used');\n        },\n    };\n}\n\nexport function getNoopJitFns(): JitCompiledFunctions {\n    return noopJitFns;\n}\n"],"names":[],"mappings":";;AAYA,MAAM,eAA6B,CAAA;AACnC,MAAM,sBAAwD,CAAA;AAG9D,MAAM,wCAAwB,IAAA;AAC9B,MAAM,8CAA8B,IAAA;AAM7B,MAAM,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMvB,YAAY,IAA2C;AACnD,WAAO,aAAa,EAAE;AAAA,EAC1B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,YAAY,IAAY,YAAqC;AACzD,iBAAa,EAAE,IAAI;AAAA,EACvB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,YAAY,IAAqB;AAC7B,WAAO,MAAM;AAAA,EACjB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,WAAyB;AACrB,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,gBAAgB,IAAiD;AAC7D,QAAI,MAAM,cAAc;AACpB,YAAM,SAAS,aAAa,EAAE;AAC9B,UAAI,OAAO,gBAAgB,OAAO,cAAc;AAC5C,eAAO;AAAA,MACX;AAAA,IACJ;AAEA,UAAM,WAAW,KAAK,YAAY,EAAE;AACpC,QAAI,CAAC,SAAU,QAAO;AAEtB,UAAM,eAAe,wBAAwB,SAAS,aAAa;AACnE,UAAM,eAAe,wBAAwB,SAAS,aAAa;AACnE,UAAM,eAAe,SAAS,eACxB,EAAC,GAAG,SAAS,cAAc,QAAQ,8BAA8B,SAAS,aAAa,OAAO,MAC9F;AACN,UAAM,gBAAgB,SAAS,gBACzB,EAAC,GAAG,SAAS,eAAe,QAAQ,8BAA8B,SAAS,cAAc,OAAO,MAChG;AAEN,UAAM,SAAkC;AAAA,MACpC,GAAG;AAAA,MACH;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IAAA;AAGJ,iBAAa,EAAE,IAAI;AACnB,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,gBAAgB,IAAqC;AACjD,UAAM,0BAA0B,KAAK,gBAAgB,EAAE;AACvD,QAAI,CAAC,wBAAyB,OAAM,IAAI,MAAM,8BAA8B,EAAE,YAAY;AAC1F,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,gBAAgB,IAAY,yBAAwD;AAChF,iBAAa,EAAE,IAAI;AAAA,EACvB;AACJ;AAEO,MAAM,kBAAkB;AAAA,EAC3B,iBAAiB,IAA0C;AACvD,WAAO,oBAAoB,EAAE;AAAA,EACjC;AAAA,EACA,iBAAiB,IAAY,SAAiC;AAC1D,wBAAoB,EAAE,IAAI;AAAA,EAC9B;AACJ;AAOO,SAAS,iBAAiB,UAAwB;AACrD,aAAW,OAAO,UAAU;AACxB,QAAI,EAAE,OAAO,eAAe;AAExB,mBAAa,GAAG,IAAI,EAAC,GAAG,SAAS,GAAG,EAAA;AAAA,IACxC;AAAA,EACJ;AACJ;AAEO,SAAS,eAAe,SAAqC;AAChE,SAAO;AAAA,IACH,QAAQ,GAAG,iBAAiB,MAAM,IAAI,OAAO;AAAA,IAC7C,YAAY,GAAG,iBAAiB,UAAU,IAAI,OAAO;AAAA,IACrD,gBAAgB,GAAG,iBAAiB,cAAc,IAAI,OAAO;AAAA,IAC7D,iBAAiB,GAAG,iBAAiB,eAAe,IAAI,OAAO;AAAA,IAC/D,eAAe,GAAG,iBAAiB,aAAa,IAAI,OAAO;AAAA,IAC3D,UAAU,GAAG,iBAAiB,QAAQ,IAAI,OAAO;AAAA,IACjD,YAAY,GAAG,iBAAiB,UAAU,IAAI,OAAO;AAAA,EAAA;AAE7D;AAOO,SAAS,wBAAwB,SAAuC;AAE3E,MAAI,YAAY,WAAY,QAAO;AAGnC,QAAM,SAAS,kBAAkB,IAAI,OAAO;AAC5C,MAAI,OAAQ,QAAO;AAEnB,QAAM,SAAS,eAAe,OAAO;AACrC,QAAM,SAAS,YAAA;AACf,QAAM,SAAS;AAAA,IACX,QAAQ,OAAO,OAAO,OAAO,MAAM;AAAA,IACnC,YAAY,OAAO,OAAO,OAAO,UAAU;AAAA,IAC3C,gBAAgB,OAAO,OAAO,OAAO,cAAc;AAAA,IACnD,iBAAiB,OAAO,OAAO,OAAO,eAAe;AAAA,IACrD,eAAe,OAAO,OAAO,OAAO,aAAa;AAAA,IACjD,UAAU,OAAO,OAAO,OAAO,QAAQ;AAAA,IACvC,YAAY,OAAO,OAAO,OAAO,UAAU;AAAA,EAAA;AAE/C,aAAW,OAAO,QAAQ;AACtB,QAAI,CAAC,OAAO,GAAG,EAAG,OAAM,IAAI,MAAM,gBAAgB,GAAG,0BAA0B,OAAO,EAAE;AAAA,EAC5F;AAGA,oBAAkB,IAAI,SAAS,MAAM;AACrC,SAAO;AACX;AAMO,SAAS,8BAA8B,SAAsE;AAEhH,QAAM,SAAS,wBAAwB,IAAI,OAAO;AAClD,MAAI,OAAQ,QAAO;AAEnB,QAAM,SAAS,eAAe,OAAO;AACrC,QAAM,SAAS,YAAA;AACf,QAAM,SAAS;AAAA,IACX,QAAQ,OAAO,OAAO,OAAO,MAAM;AAAA,IACnC,YAAY,OAAO,OAAO,OAAO,UAAU;AAAA,EAAA;AAI/C,0BAAwB,IAAI,SAAS,MAAM;AAC3C,SAAO;AACX;AAgBO,SAAS,gBAAgB,aAAuB;AACnD,SAAO,YAAY,KAAK,0BAA0B;AACtD;AAGO,SAAS,aAAa,aAAuB,eAAkC;AAClF,QAAM,SAAS,gBAAgB,WAAW;AAC1C,QAAM,WAAW,cAAc,SAAS,WAAW,eAAe,IAC5D,cAAc,WACd,GAAG,eAAe,GAAG,cAAc,QAAQ;AACjD,QAAM,YAAY,SAAS,SAAS,cAAc,IAAI,GAAG,QAAQ,GAAG,MAAM,KAAK,GAAG,QAAQ,GAAG,cAAc,GAAG,MAAM;AACpH,SAAO,cAAc,SAAS,YAAY,cAAc,SAAS;AACrE;AAEO,SAAS,mBAAmB;AAC/B,aAAW,KAAK,aAAc,QAAO,aAAa,CAAC;AACvD;AAGO,SAAS,yBAA+B;AAC3C,oBAAkB,MAAA;AAClB,0BAAwB,MAAA;AAC5B;AAIA,MAAM,aAAmC;AAAA,EACrC,QAAQ,UAAU,iBAAiB,MAAM;AAAA,EACzC,YAAY,UAAU,iBAAiB,UAAU;AAAA,EACjD,gBAAgB,UAAU,iBAAiB,cAAc;AAAA,EACzD,iBAAiB,UAAU,iBAAiB,eAAe;AAAA,EAC3D,eAAe,UAAU,iBAAiB,aAAa;AAAA,EACvD,UAAU,UAAU,iBAAiB,QAAQ;AAAA,EAC7C,YAAY,UAAU,iBAAiB,UAAU;AACrD;AAGA,SAAS,UAAU,MAAkC;AACjD,SAAO;AAAA,IACH,UAAU;AAAA,IACV;AAAA,IACA,WAAW;AAAA,IACX,MAAM,EAAC,KAAK,IAAA;AAAA,IACZ,oBAAoB,EAAC,KAAK,IAAA;AAAA,IAC1B,QAAQ;AAAA,IACR,MAAM;AAAA,IACN,iBAAiB,CAAA;AAAA,IACjB,oBAAoB,CAAA;AAAA,IACpB,aAAa,MAAM;AACf,YAAM,IAAI,MAAM,sFAAsF;AAAA,IAC1G;AAAA,IACA,IAAI,MAAM;AACN,YAAM,IAAI,MAAM,sFAAsF;AAAA,IAC1G;AAAA,EAAA;AAER;AAEO,SAAS,gBAAsC;AAClD,SAAO;AACX;"}

package/.dist/esm/src/types/formats/formatBrands.types.d.ts

@@ -0,0 +1,45 @@
+import { TypeFormatPrimitives } from './formats.types.ts';
+export type Brand<BaseType extends TypeFormatPrimitives, Name extends string> = BaseType & {
+    brand: Name;
+};
+export type BrandEmail = Brand<string, 'email'>;
+export type BrandUUID = Brand<string, 'uuid'>;
+export type BrandUrl = Brand<string, 'url'>;
+export type BrandDomain = Brand<string, 'domain'>;
+export type BrandIP = Brand<string, 'ip'>;
+export type BrandDate = Brand<string, 'date'>;
+export type BrandTime = Brand<string, 'time'>;
+export type BrandDateTime = Brand<string, 'dateTime'>;
+export type BrandInteger = Brand<number, 'integer'>;
+export type BrandFloat = Brand<number, 'float'>;
+export type BrandPositive = Brand<number, 'positive'>;
+export type BrandNegative = Brand<number, 'negative'>;
+export type BrandPositiveInt = Brand<number, 'positiveInt'>;
+export type BrandNegativeInt = Brand<number, 'negativeInt'>;
+export type BrandInt8 = Brand<number, 'int8'>;
+export type BrandInt16 = Brand<number, 'int16'>;
+export type BrandInt32 = Brand<number, 'int32'>;
+export type BrandUInt8 = Brand<number, 'uint8'>;
+export type BrandUInt16 = Brand<number, 'uint16'>;
+export type BrandUInt32 = Brand<number, 'uint32'>;
+export declare type __ΩBrand = any[];
+export declare type __ΩBrandEmail = any[];
+export declare type __ΩBrandUUID = any[];
+export declare type __ΩBrandUrl = any[];
+export declare type __ΩBrandDomain = any[];
+export declare type __ΩBrandIP = any[];
+export declare type __ΩBrandDate = any[];
+export declare type __ΩBrandTime = any[];
+export declare type __ΩBrandDateTime = any[];
+export declare type __ΩBrandInteger = any[];
+export declare type __ΩBrandFloat = any[];
+export declare type __ΩBrandPositive = any[];
+export declare type __ΩBrandNegative = any[];
+export declare type __ΩBrandPositiveInt = any[];
+export declare type __ΩBrandNegativeInt = any[];
+export declare type __ΩBrandInt8 = any[];
+export declare type __ΩBrandInt16 = any[];
+export declare type __ΩBrandInt32 = any[];
+export declare type __ΩBrandUInt8 = any[];
+export declare type __ΩBrandUInt16 = any[];
+export declare type __ΩBrandUInt32 = any[];

package/.dist/esm/src/types/formats/formatBrands.types.js

@@ -0,0 +1,45 @@
+const __ΩBrand = ["BaseType", "Name", "brand", "Brand", 'b!b"Pe"!Pe#"4#MKw$y'];
+const __ΩBrandEmail = [() => __ΩBrand, "email", "BrandEmail", '&."o!#w#y'];
+const __ΩBrandUUID = [() => __ΩBrand, "uuid", "BrandUUID", '&."o!#w#y'];
+const __ΩBrandUrl = [() => __ΩBrand, "url", "BrandUrl", '&."o!#w#y'];
+const __ΩBrandDomain = [() => __ΩBrand, "domain", "BrandDomain", '&."o!#w#y'];
+const __ΩBrandIP = [() => __ΩBrand, "ip", "BrandIP", '&."o!#w#y'];
+const __ΩBrandDate = [() => __ΩBrand, "date", "BrandDate", '&."o!#w#y'];
+const __ΩBrandTime = [() => __ΩBrand, "time", "BrandTime", '&."o!#w#y'];
+const __ΩBrandDateTime = [() => __ΩBrand, "dateTime", "BrandDateTime", '&."o!#w#y'];
+const __ΩBrandInteger = [() => __ΩBrand, "integer", "BrandInteger", `'."o!#w#y`];
+const __ΩBrandFloat = [() => __ΩBrand, "float", "BrandFloat", `'."o!#w#y`];
+const __ΩBrandPositive = [() => __ΩBrand, "positive", "BrandPositive", `'."o!#w#y`];
+const __ΩBrandNegative = [() => __ΩBrand, "negative", "BrandNegative", `'."o!#w#y`];
+const __ΩBrandPositiveInt = [() => __ΩBrand, "positiveInt", "BrandPositiveInt", `'."o!#w#y`];
+const __ΩBrandNegativeInt = [() => __ΩBrand, "negativeInt", "BrandNegativeInt", `'."o!#w#y`];
+const __ΩBrandInt8 = [() => __ΩBrand, "int8", "BrandInt8", `'."o!#w#y`];
+const __ΩBrandInt16 = [() => __ΩBrand, "int16", "BrandInt16", `'."o!#w#y`];
+const __ΩBrandInt32 = [() => __ΩBrand, "int32", "BrandInt32", `'."o!#w#y`];
+const __ΩBrandUInt8 = [() => __ΩBrand, "uint8", "BrandUInt8", `'."o!#w#y`];
+const __ΩBrandUInt16 = [() => __ΩBrand, "uint16", "BrandUInt16", `'."o!#w#y`];
+const __ΩBrandUInt32 = [() => __ΩBrand, "uint32", "BrandUInt32", `'."o!#w#y`];
+export {
+  __ΩBrand,
+  __ΩBrandDate,
+  __ΩBrandDateTime,
+  __ΩBrandDomain,
+  __ΩBrandEmail,
+  __ΩBrandFloat,
+  __ΩBrandIP,
+  __ΩBrandInt16,
+  __ΩBrandInt32,
+  __ΩBrandInt8,
+  __ΩBrandInteger,
+  __ΩBrandNegative,
+  __ΩBrandNegativeInt,
+  __ΩBrandPositive,
+  __ΩBrandPositiveInt,
+  __ΩBrandTime,
+  __ΩBrandUInt16,
+  __ΩBrandUInt32,
+  __ΩBrandUInt8,
+  __ΩBrandUUID,
+  __ΩBrandUrl
+};
+//# sourceMappingURL=formatBrands.types.js.map

package/.dist/esm/src/types/formats/formatBrands.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatBrands.types.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;"}

package/.dist/esm/src/types/formats/formats.types.d.ts

@@ -0,0 +1,37 @@
+type StrNumber = string | number;
+export type TypeFormatPrimitives = string | number | bigint | Date;
+export type FormatParamLiteral = string | number | boolean | RegExp | bigint;
+export type TypeFormatValue = FormatParamLiteral | readonly TypeFormatValue[] | {
+    [key: string]: TypeFormatValue | undefined | never;
+};
+export type FormatParamMeta<L extends TypeFormatValue = TypeFormatValue> = {
+    val: L;
+    errorMessage: string;
+    desc?: string;
+};
+export type FormatParam<L extends TypeFormatValue> = L | FormatParamMeta<L>;
+export type TypeFormatParams = Record<string, TypeFormatValue | undefined | never>;
+export type TypeFormatParsedParams = {
+    __jitId: string;
+    [key: string]: TypeFormatValue;
+};
+export type AliasTypeAnnotation<Name extends string, Options = never> = unknown;
+export type AliasTypeFormat<BaseType extends string | number | bigint, Name extends string, P extends TypeFormatParams> = BaseType & AliasTypeAnnotation<Name, P>;
+export type ExtractFormatParams<T> = T extends AliasTypeFormat<infer Base, infer Name, infer P> ? P : undefined;
+export type TypeFormatError = {
+    name: string;
+    val: StrNumber | boolean | bigint | (StrNumber | boolean | bigint)[];
+    formatPath: StrNumber[];
+};
+export {};
+export declare type __ΩTypeFormatPrimitives = any[];
+export declare type __ΩFormatParamLiteral = any[];
+export declare type __ΩTypeFormatValue = any[];
+export declare type __ΩFormatParamMeta = any[];
+export declare type __ΩFormatParam = any[];
+export declare type __ΩTypeFormatParams = any[];
+export declare type __ΩTypeFormatParsedParams = any[];
+export declare type __ΩAliasTypeAnnotation = any[];
+export declare type __ΩAliasTypeFormat = any[];
+export declare type __ΩExtractFormatParams = any[];
+export declare type __ΩTypeFormatError = any[];

package/.dist/esm/src/types/formats/formats.types.js

@@ -0,0 +1,27 @@
+const __ΩRecord = ["K", "T", "Record", `l'e#"Rb!b"Pde"!N#!w#y`];
+const __ΩStrNumber = ["StrNumber", "P&'Jw!y"];
+const __ΩTypeFormatPrimitives = ["TypeFormatPrimitives", "P&'*TJw!y"];
+const __ΩFormatParamLiteral = ["FormatParamLiteral", "P&')A*Jw!y"];
+const __ΩTypeFormatValue = [() => __ΩFormatParamLiteral, 0, 0, "TypeFormatValue", 'Pn!n"F9P&Pn#-!JLMJw$y'];
+const __ΩFormatParamMeta = [() => __ΩTypeFormatValue, "L", "val", "errorMessage", "desc", "FormatParamMeta", 'n!c"Pe"!4#&4$&4%8Mw&y'];
+const __ΩFormatParam = ["L", () => __ΩFormatParamMeta, "FormatParam", 'b!Pe"!e"!o""Jw#y'];
+const __ΩTypeFormatParams = [() => __ΩRecord, () => __ΩTypeFormatValue, "TypeFormatParams", '&Pn"-!Jo!#w#y'];
+const __ΩTypeFormatParsedParams = ["__jitId", () => __ΩTypeFormatValue, "TypeFormatParsedParams", 'P&4!&n"LMw#y'];
+const __ΩAliasTypeAnnotation = ["Name", "Options", "AliasTypeAnnotation", 'b!!c"#w#y'];
+const __ΩAliasTypeFormat = ["BaseType", "Name", "P", () => __ΩAliasTypeAnnotation, "AliasTypeFormat", 'b!b"b#Pe"!e""e"#o$#Kw%y'];
+const __ΩExtractFormatParams = ["T", () => __ΩAliasTypeFormat, "ExtractFormatParams", `lBe"#R-RPddde#!h!!h!"h!#o"$qk#'QRb!Pde"!p)w#y`];
+const __ΩTypeFormatError = ["name", () => __ΩStrNumber, () => __ΩStrNumber, "val", () => __ΩStrNumber, "formatPath", "TypeFormatError", `P&4!Pn")*Pn#)*JFJ4$n%F4&Mw'y`];
+export {
+  __ΩAliasTypeAnnotation,
+  __ΩAliasTypeFormat,
+  __ΩExtractFormatParams,
+  __ΩFormatParam,
+  __ΩFormatParamLiteral,
+  __ΩFormatParamMeta,
+  __ΩTypeFormatError,
+  __ΩTypeFormatParams,
+  __ΩTypeFormatParsedParams,
+  __ΩTypeFormatPrimitives,
+  __ΩTypeFormatValue
+};
+//# sourceMappingURL=formats.types.js.map

package/.dist/esm/src/types/formats/formats.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"formats.types.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;"}

package/.dist/esm/src/types/formats/formatsParams.types.d.ts

@@ -0,0 +1,234 @@
+import { FormatParam } from './formats.types.ts';
+export type Samples = string | readonly string[];
+export type StringValidators = {
+    maxLength?: number | {
+        val: number;
+        errorMessage: string;
+        desc?: string;
+    };
+    minLength?: number | {
+        val: number;
+        errorMessage: string;
+        desc?: string;
+    };
+    length?: number | {
+        val: number;
+        errorMessage: string;
+        desc?: string;
+    };
+    disallowedChars?: {
+        val: string;
+        errorMessage: string;
+        desc?: string;
+        ignoreCase?: boolean;
+        mockSamples: string;
+    };
+    disallowedValues?: {
+        val: readonly string[];
+        errorMessage: string;
+        desc?: string;
+        ignoreCase?: boolean;
+        mockSamples: Samples;
+    };
+    pattern?: {
+        val: RegExp;
+        errorMessage: string;
+        desc?: string;
+        ignoreCase?: boolean;
+        mockSamples: Samples;
+    };
+    allowedChars?: {
+        val: string;
+        errorMessage: string;
+        desc?: string;
+        ignoreCase?: boolean;
+        mockSamples?: Samples;
+    };
+    allowedValues?: {
+        val: readonly string[];
+        errorMessage: string;
+        desc?: string;
+        ignoreCase?: boolean;
+        mockSamples?: Samples;
+    };
+};
+export type StringTransformers = {
+    lowercase?: boolean;
+    uppercase?: boolean;
+    capitalize?: boolean;
+    trim?: boolean;
+    replace?: {
+        searchValue: string;
+        replaceValue: string;
+    };
+    replaceAll?: {
+        searchValue: string;
+        replaceValue: string;
+    };
+};
+export type StringParams = StringValidators & StringTransformers;
+export type DateFmt = 'ISO' | 'YYYY-MM-DD' | 'DD-MM-YYYY' | 'MM-DD-YYYY' | 'MM-DD' | 'DD-MM' | 'YYYY-MM';
+export type FormatParams_Date = {
+    format: FormatParam<DateFmt>;
+};
+export type TimeFmt = 'ISO' | 'HH:mm:ss[.mmm]TZ' | 'HH:mm:ss[.mmm]' | 'HH:mm:ss' | 'HH:mm' | 'mm:ss' | 'HH' | 'mm' | 'ss';
+export type FormatParams_Time = {
+    format: FormatParam<TimeFmt>;
+};
+export type FormatParams_DateTime = {
+    date: FormatParams_Date;
+    time: FormatParams_Time;
+    splitChar: FormatParam<string>;
+};
+export type FormatParams_EmailPattern = Omit<StringValidators, 'length' | 'allowedChars' | 'disallowedChars' | 'allowedValues'>;
+export type FormatParams_Email = FormatParams_EmailPattern & {
+    localPart?: StringValidators;
+    domain?: FormatParams_Domain;
+};
+export type FormatParams_UrlPattern = Omit<StringParams, 'allowedChars' | 'disallowedChars' | 'allowedValues' | 'disallowedValues'>;
+export type FormatParams_Url = FormatParams_UrlPattern & {
+    ip?: FormatParams_IP;
+    domain?: FormatParams_Domain;
+};
+export type FormatParams_DomainName = Omit<StringValidators, 'length' | 'allowedChars' | 'disallowedChars'>;
+export type FormatParams_Tld = Omit<StringValidators, 'length' | 'allowedChars' | 'disallowedChars'>;
+export type FormatParam_Pattern = StringValidators['pattern'];
+export type FormatParams_DomainCore = {
+    names?: never;
+    tld?: never;
+    pattern: FormatParam_Pattern;
+} | {
+    names: FormatParams_DomainName;
+    tld: FormatParams_Tld;
+    pattern?: never;
+};
+export type FormatParams_Domain = {
+    maxLength?: FormatParam<number>;
+    minLength?: FormatParam<number>;
+    maxParts?: FormatParam<number>;
+    minParts?: FormatParam<number>;
+} & FormatParams_DomainCore;
+export type FormatParams_IP = {
+    version: FormatParam<4 | 6 | 'any'>;
+    allowLocalHost?: FormatParam<boolean>;
+    allowPort?: FormatParam<boolean>;
+};
+export type FormatParams_UUID = {
+    version: FormatParam<'4' | '7'>;
+};
+type NumberMax = {
+    max?: number | {
+        val: number;
+        errorMessage: string;
+        desc?: string;
+    };
+    gt?: never;
+} | {
+    max?: never;
+    gt?: number | {
+        val: number;
+        errorMessage: string;
+        desc?: string;
+    };
+};
+type NumberMin = {
+    min?: number | {
+        val: number;
+        errorMessage: string;
+        desc?: string;
+    };
+    lt?: never;
+} | {
+    min?: never;
+    lt?: number | {
+        val: number;
+        errorMessage: string;
+        desc?: string;
+    };
+};
+type NumberType = {
+    integer?: boolean | {
+        val: boolean;
+        errorMessage: string;
+        desc?: string;
+    };
+    float?: never;
+} | {
+    integer?: never;
+    float?: boolean | {
+        val: boolean;
+        errorMessage: string;
+        desc?: string;
+    };
+};
+export type FormatParams_Number = NumberMax & NumberMin & NumberType & {
+    multipleOf?: number | {
+        val: number;
+        errorMessage: string;
+        desc?: string;
+    };
+};
+type BigIntMax = {
+    max?: bigint | {
+        val: bigint;
+        errorMessage: string;
+        desc?: string;
+    };
+    gt?: never;
+} | {
+    max?: never;
+    gt?: bigint | {
+        val: bigint;
+        errorMessage: string;
+        desc?: string;
+    };
+};
+type BigIntMin = {
+    min?: bigint | {
+        val: bigint;
+        errorMessage: string;
+        desc?: string;
+    };
+    lt?: never;
+} | {
+    min?: never;
+    lt?: bigint | {
+        val: bigint;
+        errorMessage: string;
+        desc?: string;
+    };
+};
+export type FormatParams_BigInt = BigIntMax & BigIntMin & {
+    multipleOf?: bigint | {
+        val: bigint;
+        errorMessage: string;
+        desc?: string;
+    };
+};
+export type AnyStringFormatParam = StringParams | FormatParams_Email | FormatParams_Url | FormatParams_Domain | FormatParams_IP | FormatParams_UUID | FormatParams_DateTime | FormatParams_Date | FormatParams_Time;
+export type AnyFormatParams = AnyStringFormatParam | FormatParams_Number | FormatParams_BigInt;
+export {};
+export declare type __ΩSamples = any[];
+export declare type __ΩStringValidators = any[];
+export declare type __ΩStringTransformers = any[];
+export declare type __ΩStringParams = any[];
+export declare type __ΩDateFmt = any[];
+export declare type __ΩFormatParams_Date = any[];
+export declare type __ΩTimeFmt = any[];
+export declare type __ΩFormatParams_Time = any[];
+export declare type __ΩFormatParams_DateTime = any[];
+export declare type __ΩFormatParams_EmailPattern = any[];
+export declare type __ΩFormatParams_Email = any[];
+export declare type __ΩFormatParams_UrlPattern = any[];
+export declare type __ΩFormatParams_Url = any[];
+export declare type __ΩFormatParams_DomainName = any[];
+export declare type __ΩFormatParams_Tld = any[];
+export declare type __ΩFormatParam_Pattern = any[];
+export declare type __ΩFormatParams_DomainCore = any[];
+export declare type __ΩFormatParams_Domain = any[];
+export declare type __ΩFormatParams_IP = any[];
+export declare type __ΩFormatParams_UUID = any[];
+export declare type __ΩFormatParams_Number = any[];
+export declare type __ΩFormatParams_BigInt = any[];
+export declare type __ΩAnyStringFormatParam = any[];
+export declare type __ΩAnyFormatParams = any[];