@jigx/core-sdk 1.0.0

package/dist/abstract/sdk.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk.types.d.ts","sourceRoot":"","sources":["../../src/abstract/sdk.types.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,cAAc,CAAC,CAAC;IAI/B,IAAI,IAAI,CAAC,CAAA;CACV;AAKD,eAAO,MAAM,KAAK,EAAE,OAAO,MAAwB,CAAA;AAEnD,MAAM,MAAM,WAAW,CAAC,CAAC,GAAG,OAAO,IAAI,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAA;AAoChE,wBAAgB,oBAAoB,CAAC,MAAM,SAAS,WAAW,EAC7D,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,GAAG,EAAE,MAAM,oEAOZ;AAaD,wBAAgB,iBAAiB,CAAC,SAAS,EACzC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,GAAG,EAAE,MAAM,GACV,MAAM,SAAS,GAAG,SAAS,CAI7B;AAoCD,wBAAgB,kBAAkB,CAAC,MAAM,SAAS,WAAW,EAC3D,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,GAAG,EAAE,MAAM,oEAaZ;AAED,wBAAgB,oBAAoB,CAAC,MAAM,SAAS,WAAW,EAC7D,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,CAAC,QAAQ,EAAE,YAAY,CAAC,MAAM,CAAC,KAAK,IAAI,oEAOnD;AAuCD,wBAAgB,2BAA2B,CAAC,MAAM,SAAS,WAAW,EACpE,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,oEAgBjC;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI;IAAE,KAAK,EAAE,MAAM,OAAO,CAAA;CAAE,CAI3E;AAID,wBAAgB,SAAS,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,CAyBrE;AAaD,wBAAgB,aAAa,CAAC,CAAC,EAC7B,SAAS,EAAE,MAAM,CAAC,OAAO,EACzB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB,CAAC,CASH","sourcesContent":["import get from 'lodash/get.js'\nimport set from 'lodash/set.js'\nimport { isObject } from '../utils/index.js'\n\n/**\n * Returns fluent builder to sender type.\n */\nexport interface ReturnToSender<S> {\n  /**\n   * Completes builder and returns to sender.\n   */\n  done(): S\n}\n\n/**\n * Build symbol for internal builder operations.\n */\nexport const BUILD: unique symbol = Symbol('BUILD')\n\nexport type Constructor<T = unknown> = new (...args: any[]) => T\n\n/**\n * Creates a factory method that instantiates a builder and assigns it to a specific path in a config object.\n *\n * This helper eliminates boilerplate code for creating builder instances and storing them at specific paths.\n * It supports nested paths using dot notation (e.g., 'top.title' or 'markers.item').\n *\n * @param Class - The builder class constructor to instantiate\n * @param options - The config object where the instance will be stored\n * @param key - The path where to store the instance (supports dot notation for nested paths)\n * @returns A factory function that creates the builder instance and assigns it to the specified path\n *\n * @example\n * ```typescript\n * // Simple property assignment\n * title = assignBuilderFactory(TextValueBuilder, this.config, 'title')\n * // Calling widget.title('Hello') creates a TextValueBuilder and stores at config.title\n *\n * // Nested property assignment\n * markersItem = assignBuilderFactory(JcMarkerItemBuilder, this.config, 'markers.item')\n * // Calling widget.markersItem() creates builder and stores at config.markers.item\n *\n * // In factory object pattern\n * top = {\n *   titles: assignBuilderFactory(JcTitlesBuilder, this.config, 'top'),\n *   trend: assignBuilderFactory(JcTrendBuilder, this.config, 'top')\n * }\n * // Both factories will assign to the same 'top' path (last one wins)\n * ```\n *\n * @remarks\n * - Uses lodash's `set` function for safe nested path assignment\n * - The stored builder will be automatically built by `buildTree()` in the base class\n * - Replaces any existing value at the specified path\n */\nexport function assignBuilderFactory<TClass extends Constructor>(\n  Class: TClass,\n  options: Record<string, unknown>,\n  key: string,\n) {\n  return (...args: ConstructorParameters<TClass>): InstanceType<TClass> => {\n    const instance = new Class(...args) as InstanceType<TClass>\n    set(options, key, instance)\n    return instance\n  }\n}\n\n/**\n * Returns the existing builder at the given config key, or undefined if not yet initialized.\n *\n * Companion to `assignBuilderFactory` — use when you need to read the current builder\n * instance without replacing it.\n *\n * @param options - The config object where the builder is stored\n * @param key - The property path where the builder is stored\n * @returns A function that returns the existing builder instance or undefined\n */\n// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters\nexport function getBuilderFactory<TInstance>(\n  options: Record<string, unknown>,\n  key: string,\n): () => TInstance | undefined {\n  return (): TInstance | undefined => {\n    return get(options, key) as TInstance | undefined\n  }\n}\n\n/**\n * Creates a factory method that instantiates a builder and pushes it to an array in a config object.\n *\n * This helper is designed for properties that hold collections of builders, where each call adds\n * a new item rather than replacing the existing value. It automatically initializes the array\n * if it doesn't exist.\n *\n * @param Class - The builder class constructor to instantiate\n * @param options - The config object containing the array\n * @param key - The property name where the array is stored\n * @returns A factory function that creates builder instances and adds them to the array\n *\n * @example\n * ```typescript\n * // For action collections\n * actions = pushBuilderFactory(ActionBuilder, this.config, 'actions')\n *\n * // Each call adds a new action to the array\n * widget.actions('save')   // Creates ActionBuilder at config.actions[0]\n * widget.actions('cancel') // Creates ActionBuilder at config.actions[1]\n * widget.actions('delete') // Creates ActionBuilder at config.actions[2]\n *\n * // For child widgets in a group\n * child = pushBuilderFactory(WidgetBuilder, this.config, 'children')\n * group.child('widget1')  // Adds to config.children[0]\n * group.child('widget2')  // Adds to config.children[1]\n * ```\n *\n * @remarks\n * - Automatically initializes the array at `options[key]` if it doesn't exist\n * - Each call appends to the array rather than replacing\n * - All builders in the array will be automatically built by `buildTree()`\n * - Useful for any property that can have multiple values (actions, children, etc.)\n */\nexport function pushBuilderFactory<TClass extends Constructor>(\n  Class: TClass,\n  options: Record<string, unknown>,\n  key: string,\n) {\n  return (...args: ConstructorParameters<TClass>): InstanceType<TClass> => {\n    const instance = new Class(...args) as InstanceType<TClass>\n    if (!Array.isArray(options[key])) {\n      options[key] = []\n    }\n\n    const array = options[key] as unknown[]\n    array.push(instance)\n\n    return instance\n  }\n}\n\nexport function createBuilderFactory<TClass extends Constructor>(\n  Class: TClass,\n  onCreate: (instance: InstanceType<TClass>) => void,\n) {\n  return (...args: ConstructorParameters<TClass>): InstanceType<TClass> => {\n    const instance = new Class(...args) as InstanceType<TClass>\n    onCreate(instance)\n    return instance\n  }\n}\n\n/**\n * Creates a factory method that instantiates a builder and assigns it to a dynamically determined key.\n *\n * This helper is designed for keyed collections where the storage key comes from the user's input.\n * It expects the first argument to be an object containing the key to use for storage.\n * This pattern changes the API from accepting a simple value to accepting an object.\n *\n * @param Class - The builder class constructor to instantiate\n * @param inputKeyName - The property name in the input object that contains the storage key\n * @param options - The config object where instances will be stored as a keyed collection\n * @returns A factory function that creates builders and stores them using a key from the input\n *\n * @example\n * ```typescript\n * // In screen.abstract.ts for widget factories\n * avatar: assignBuilderByInputFactory(AvatarWidgetBuilder, 'name', this._widgets)\n *\n * // Changes the API to require an object with the key\n * screen.addWidget.avatar({ name: 'user-avatar' })  // Stores at _widgets['user-avatar']\n * screen.addWidget.avatar({ name: 'profile' })      // Stores at _widgets['profile']\n *\n * // The input object must contain the specified key\n * items: assignBuilderByInputFactory(ItemBuilder, 'itemId', this._items)\n * list.items({ itemId: 'item-1', value: 100 })  // Stores at _items['item-1']\n * list.items({ itemId: 'item-2', value: 200 })  // Stores at _items['item-2']\n * ```\n *\n * @remarks\n * - IMPORTANT: This changes the API from `method(value)` to `method({ key: value })`\n * - The first argument MUST be an object containing the specified key property\n * - Throws an error if the key is missing from the input object\n * - Useful for widgets, datasources, or any keyed collection\n * - The key extracted from input is used as the storage key in the options object\n * - Each call replaces any existing value at that key\n *\n * @throws Error if the input doesn't contain the required key\n */\nexport function assignBuilderByInputFactory<TClass extends Constructor>(\n  Class: TClass,\n  inputKeyName: string,\n  options: Record<string, unknown>,\n) {\n  return (...args: ConstructorParameters<TClass>): InstanceType<TClass> => {\n    const instance = new Class(...args) as InstanceType<TClass>\n    const firstArg = args[0] as unknown\n    if (!isObject(firstArg) || !(inputKeyName in firstArg)) {\n      throw new Error(`Missing required key \"${inputKeyName}\" in builder input`)\n    }\n    const key = `${firstArg[inputKeyName]}`\n    if (key in options) {\n      throw new Error(`Duplicate ${inputKeyName} \"${key}\". Each ${inputKeyName} must be unique.`)\n    }\n    set(options, key, instance)\n\n    return instance\n  }\n}\n\nexport function isBuilder(value: unknown): value is { build: () => unknown } {\n  return (\n    isObject(value) && 'build' in value && typeof (value as { build: unknown }).build === 'function'\n  )\n}\n\n// XXX: Recursively build any nested builders in the config object, if we need to optimize this, then we can create a whitelist of known fields that can contain builders.\n// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters\nexport function buildTree<T = Record<string, unknown>>(obj: object): T {\n  const result: Record<string, unknown> = {}\n  for (const [key, value] of Object.entries(obj)) {\n    if (isBuilder(value)) {\n      result[key] = value.build()\n    } else if (Array.isArray(value)) {\n      // Handle arrays - build any builders inside them\n      result[key] = value.map((item: unknown) => {\n        if (isBuilder(item)) {\n          return item.build()\n        }\n\n        if (isObject(item)) {\n          return buildTree(item)\n        }\n\n        return item\n      })\n    } else if (isObject(value)) {\n      result[key] = buildTree(value)\n    } else {\n      result[key] = value\n    }\n  }\n  return result as T\n}\n\n// Type-safe builder cache at module level\nconst builderCache = new Map<string, any>()\n\n/**\n * Type-safe lazy loader with caching.\n * Loads builder modules only on first access and caches for subsequent calls.\n * @param requireFn - The require function from the calling module for proper path resolution\n * @param modulePath - Relative path to the module\n * @param exportName - Name of the exported builder class\n * @returns The cached or newly loaded builder class\n */\nexport function cachedRequire<T>(\n  requireFn: NodeJS.Require,\n  modulePath: string,\n  exportName: string,\n): T {\n  const cacheKey = `${modulePath}:${exportName}`\n\n  if (!builderCache.has(cacheKey)) {\n    const module = requireFn(modulePath) as { [exportName]: T }\n    builderCache.set(cacheKey, module[exportName])\n  }\n\n  return builderCache.get(cacheKey) as T\n}\n"]}

package/dist/abstract/sdk.types.js

@@ -0,0 +1,88 @@
+import get from 'lodash/get.js';
+import set from 'lodash/set.js';
+import { isObject } from '../utils/index.js';
+export const BUILD = Symbol('BUILD');
+export function assignBuilderFactory(Class, options, key) {
+    return (...args) => {
+        const instance = new Class(...args);
+        set(options, key, instance);
+        return instance;
+    };
+}
+export function getBuilderFactory(options, key) {
+    return () => {
+        return get(options, key);
+    };
+}
+export function pushBuilderFactory(Class, options, key) {
+    return (...args) => {
+        const instance = new Class(...args);
+        if (!Array.isArray(options[key])) {
+            options[key] = [];
+        }
+        const array = options[key];
+        array.push(instance);
+        return instance;
+    };
+}
+export function createBuilderFactory(Class, onCreate) {
+    return (...args) => {
+        const instance = new Class(...args);
+        onCreate(instance);
+        return instance;
+    };
+}
+export function assignBuilderByInputFactory(Class, inputKeyName, options) {
+    return (...args) => {
+        const instance = new Class(...args);
+        const firstArg = args[0];
+        if (!isObject(firstArg) || !(inputKeyName in firstArg)) {
+            throw new Error(`Missing required key "${inputKeyName}" in builder input`);
+        }
+        const key = `${firstArg[inputKeyName]}`;
+        if (key in options) {
+            throw new Error(`Duplicate ${inputKeyName} "${key}". Each ${inputKeyName} must be unique.`);
+        }
+        set(options, key, instance);
+        return instance;
+    };
+}
+export function isBuilder(value) {
+    return (isObject(value) && 'build' in value && typeof value.build === 'function');
+}
+export function buildTree(obj) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (isBuilder(value)) {
+            result[key] = value.build();
+        }
+        else if (Array.isArray(value)) {
+            result[key] = value.map((item) => {
+                if (isBuilder(item)) {
+                    return item.build();
+                }
+                if (isObject(item)) {
+                    return buildTree(item);
+                }
+                return item;
+            });
+        }
+        else if (isObject(value)) {
+            result[key] = buildTree(value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+const builderCache = new Map();
+export function cachedRequire(requireFn, modulePath, exportName) {
+    const cacheKey = `${modulePath}:${exportName}`;
+    if (!builderCache.has(cacheKey)) {
+        const module = requireFn(modulePath);
+        builderCache.set(cacheKey, module[exportName]);
+    }
+    return builderCache.get(cacheKey);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sdk.types.js","sourceRoot":"","sources":["../../src/abstract/sdk.types.ts"],"names":[],"mappings":"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","sourcesContent":["import get from 'lodash/get.js'\nimport set from 'lodash/set.js'\nimport { isObject } from '../utils/index.js'\n\n/**\n * Returns fluent builder to sender type.\n */\nexport interface ReturnToSender<S> {\n  /**\n   * Completes builder and returns to sender.\n   */\n  done(): S\n}\n\n/**\n * Build symbol for internal builder operations.\n */\nexport const BUILD: unique symbol = Symbol('BUILD')\n\nexport type Constructor<T = unknown> = new (...args: any[]) => T\n\n/**\n * Creates a factory method that instantiates a builder and assigns it to a specific path in a config object.\n *\n * This helper eliminates boilerplate code for creating builder instances and storing them at specific paths.\n * It supports nested paths using dot notation (e.g., 'top.title' or 'markers.item').\n *\n * @param Class - The builder class constructor to instantiate\n * @param options - The config object where the instance will be stored\n * @param key - The path where to store the instance (supports dot notation for nested paths)\n * @returns A factory function that creates the builder instance and assigns it to the specified path\n *\n * @example\n * ```typescript\n * // Simple property assignment\n * title = assignBuilderFactory(TextValueBuilder, this.config, 'title')\n * // Calling widget.title('Hello') creates a TextValueBuilder and stores at config.title\n *\n * // Nested property assignment\n * markersItem = assignBuilderFactory(JcMarkerItemBuilder, this.config, 'markers.item')\n * // Calling widget.markersItem() creates builder and stores at config.markers.item\n *\n * // In factory object pattern\n * top = {\n *   titles: assignBuilderFactory(JcTitlesBuilder, this.config, 'top'),\n *   trend: assignBuilderFactory(JcTrendBuilder, this.config, 'top')\n * }\n * // Both factories will assign to the same 'top' path (last one wins)\n * ```\n *\n * @remarks\n * - Uses lodash's `set` function for safe nested path assignment\n * - The stored builder will be automatically built by `buildTree()` in the base class\n * - Replaces any existing value at the specified path\n */\nexport function assignBuilderFactory<TClass extends Constructor>(\n  Class: TClass,\n  options: Record<string, unknown>,\n  key: string,\n) {\n  return (...args: ConstructorParameters<TClass>): InstanceType<TClass> => {\n    const instance = new Class(...args) as InstanceType<TClass>\n    set(options, key, instance)\n    return instance\n  }\n}\n\n/**\n * Returns the existing builder at the given config key, or undefined if not yet initialized.\n *\n * Companion to `assignBuilderFactory` — use when you need to read the current builder\n * instance without replacing it.\n *\n * @param options - The config object where the builder is stored\n * @param key - The property path where the builder is stored\n * @returns A function that returns the existing builder instance or undefined\n */\n// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters\nexport function getBuilderFactory<TInstance>(\n  options: Record<string, unknown>,\n  key: string,\n): () => TInstance | undefined {\n  return (): TInstance | undefined => {\n    return get(options, key) as TInstance | undefined\n  }\n}\n\n/**\n * Creates a factory method that instantiates a builder and pushes it to an array in a config object.\n *\n * This helper is designed for properties that hold collections of builders, where each call adds\n * a new item rather than replacing the existing value. It automatically initializes the array\n * if it doesn't exist.\n *\n * @param Class - The builder class constructor to instantiate\n * @param options - The config object containing the array\n * @param key - The property name where the array is stored\n * @returns A factory function that creates builder instances and adds them to the array\n *\n * @example\n * ```typescript\n * // For action collections\n * actions = pushBuilderFactory(ActionBuilder, this.config, 'actions')\n *\n * // Each call adds a new action to the array\n * widget.actions('save')   // Creates ActionBuilder at config.actions[0]\n * widget.actions('cancel') // Creates ActionBuilder at config.actions[1]\n * widget.actions('delete') // Creates ActionBuilder at config.actions[2]\n *\n * // For child widgets in a group\n * child = pushBuilderFactory(WidgetBuilder, this.config, 'children')\n * group.child('widget1')  // Adds to config.children[0]\n * group.child('widget2')  // Adds to config.children[1]\n * ```\n *\n * @remarks\n * - Automatically initializes the array at `options[key]` if it doesn't exist\n * - Each call appends to the array rather than replacing\n * - All builders in the array will be automatically built by `buildTree()`\n * - Useful for any property that can have multiple values (actions, children, etc.)\n */\nexport function pushBuilderFactory<TClass extends Constructor>(\n  Class: TClass,\n  options: Record<string, unknown>,\n  key: string,\n) {\n  return (...args: ConstructorParameters<TClass>): InstanceType<TClass> => {\n    const instance = new Class(...args) as InstanceType<TClass>\n    if (!Array.isArray(options[key])) {\n      options[key] = []\n    }\n\n    const array = options[key] as unknown[]\n    array.push(instance)\n\n    return instance\n  }\n}\n\nexport function createBuilderFactory<TClass extends Constructor>(\n  Class: TClass,\n  onCreate: (instance: InstanceType<TClass>) => void,\n) {\n  return (...args: ConstructorParameters<TClass>): InstanceType<TClass> => {\n    const instance = new Class(...args) as InstanceType<TClass>\n    onCreate(instance)\n    return instance\n  }\n}\n\n/**\n * Creates a factory method that instantiates a builder and assigns it to a dynamically determined key.\n *\n * This helper is designed for keyed collections where the storage key comes from the user's input.\n * It expects the first argument to be an object containing the key to use for storage.\n * This pattern changes the API from accepting a simple value to accepting an object.\n *\n * @param Class - The builder class constructor to instantiate\n * @param inputKeyName - The property name in the input object that contains the storage key\n * @param options - The config object where instances will be stored as a keyed collection\n * @returns A factory function that creates builders and stores them using a key from the input\n *\n * @example\n * ```typescript\n * // In screen.abstract.ts for widget factories\n * avatar: assignBuilderByInputFactory(AvatarWidgetBuilder, 'name', this._widgets)\n *\n * // Changes the API to require an object with the key\n * screen.addWidget.avatar({ name: 'user-avatar' })  // Stores at _widgets['user-avatar']\n * screen.addWidget.avatar({ name: 'profile' })      // Stores at _widgets['profile']\n *\n * // The input object must contain the specified key\n * items: assignBuilderByInputFactory(ItemBuilder, 'itemId', this._items)\n * list.items({ itemId: 'item-1', value: 100 })  // Stores at _items['item-1']\n * list.items({ itemId: 'item-2', value: 200 })  // Stores at _items['item-2']\n * ```\n *\n * @remarks\n * - IMPORTANT: This changes the API from `method(value)` to `method({ key: value })`\n * - The first argument MUST be an object containing the specified key property\n * - Throws an error if the key is missing from the input object\n * - Useful for widgets, datasources, or any keyed collection\n * - The key extracted from input is used as the storage key in the options object\n * - Each call replaces any existing value at that key\n *\n * @throws Error if the input doesn't contain the required key\n */\nexport function assignBuilderByInputFactory<TClass extends Constructor>(\n  Class: TClass,\n  inputKeyName: string,\n  options: Record<string, unknown>,\n) {\n  return (...args: ConstructorParameters<TClass>): InstanceType<TClass> => {\n    const instance = new Class(...args) as InstanceType<TClass>\n    const firstArg = args[0] as unknown\n    if (!isObject(firstArg) || !(inputKeyName in firstArg)) {\n      throw new Error(`Missing required key \"${inputKeyName}\" in builder input`)\n    }\n    const key = `${firstArg[inputKeyName]}`\n    if (key in options) {\n      throw new Error(`Duplicate ${inputKeyName} \"${key}\". Each ${inputKeyName} must be unique.`)\n    }\n    set(options, key, instance)\n\n    return instance\n  }\n}\n\nexport function isBuilder(value: unknown): value is { build: () => unknown } {\n  return (\n    isObject(value) && 'build' in value && typeof (value as { build: unknown }).build === 'function'\n  )\n}\n\n// XXX: Recursively build any nested builders in the config object, if we need to optimize this, then we can create a whitelist of known fields that can contain builders.\n// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters\nexport function buildTree<T = Record<string, unknown>>(obj: object): T {\n  const result: Record<string, unknown> = {}\n  for (const [key, value] of Object.entries(obj)) {\n    if (isBuilder(value)) {\n      result[key] = value.build()\n    } else if (Array.isArray(value)) {\n      // Handle arrays - build any builders inside them\n      result[key] = value.map((item: unknown) => {\n        if (isBuilder(item)) {\n          return item.build()\n        }\n\n        if (isObject(item)) {\n          return buildTree(item)\n        }\n\n        return item\n      })\n    } else if (isObject(value)) {\n      result[key] = buildTree(value)\n    } else {\n      result[key] = value\n    }\n  }\n  return result as T\n}\n\n// Type-safe builder cache at module level\nconst builderCache = new Map<string, any>()\n\n/**\n * Type-safe lazy loader with caching.\n * Loads builder modules only on first access and caches for subsequent calls.\n * @param requireFn - The require function from the calling module for proper path resolution\n * @param modulePath - Relative path to the module\n * @param exportName - Name of the exported builder class\n * @returns The cached or newly loaded builder class\n */\nexport function cachedRequire<T>(\n  requireFn: NodeJS.Require,\n  modulePath: string,\n  exportName: string,\n): T {\n  const cacheKey = `${modulePath}:${exportName}`\n\n  if (!builderCache.has(cacheKey)) {\n    const module = requireFn(modulePath) as { [exportName]: T }\n    builderCache.set(cacheKey, module[exportName])\n  }\n\n  return builderCache.get(cacheKey) as T\n}\n"]}

package/dist/abstract/zod.strata.d.ts

@@ -0,0 +1,17 @@
+import * as z from 'zod/v4';
+export declare const UserRoleSchema: z.ZodEnum<{
+    ADMIN: "ADMIN";
+    DENY: "DENY";
+    MAKER: "MAKER";
+    OWNER: "OWNER";
+    USER: "USER";
+}>;
+export declare const ContinuationTokenSchema: z.ZodString;
+export declare const RegionSchema: z.ZodEnum<{
+    "ap-southeast-2": "ap-southeast-2";
+    "eu-central-1": "eu-central-1";
+    "us-east-1": "us-east-1";
+    "us-west-1": "us-west-1";
+    "us-west-2": "us-west-2";
+}>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiem9kLnN0cmF0YS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2Fic3RyYWN0L3pvZC5zdHJhdGEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLENBQUMsTUFBTSxRQUFRLENBQUE7QUFFM0IsZUFBTyxNQUFNLGNBQWM7Ozs7OztFQUFzRCxDQUFBO0FBRWpGLGVBQU8sTUFBTSx1QkFBdUIsYUFBaUMsQ0FBQTtBQUVyRSxlQUFPLE1BQU0sWUFBWTs7Ozs7O0VBTXZCLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyB6IGZyb20gJ3pvZC92NCdcblxuZXhwb3J0IGNvbnN0IFVzZXJSb2xlU2NoZW1hID0gei5lbnVtKFsnT1dORVInLCAnQURNSU4nLCAnTUFLRVInLCAnVVNFUicsICdERU5ZJ10pXG5cbmV4cG9ydCBjb25zdCBDb250aW51YXRpb25Ub2tlblNjaGVtYSA9IHouc3RyaW5nKCkucmVnZXgoL15bYS16XXszfS0vKVxuXG5leHBvcnQgY29uc3QgUmVnaW9uU2NoZW1hID0gei5lbnVtKFtcbiAgJ3VzLXdlc3QtMicsXG4gICd1cy13ZXN0LTEnLFxuICAndXMtZWFzdC0xJyxcbiAgJ2V1LWNlbnRyYWwtMScsXG4gICdhcC1zb3V0aGVhc3QtMicsXG5dKVxuIl19

package/dist/abstract/zod.strata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod.strata.d.ts","sourceRoot":"","sources":["../../src/abstract/zod.strata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAA;AAE3B,eAAO,MAAM,cAAc;;;;;;EAAsD,CAAA;AAEjF,eAAO,MAAM,uBAAuB,aAAiC,CAAA;AAErE,eAAO,MAAM,YAAY;;;;;;EAMvB,CAAA","sourcesContent":["import * as z from 'zod/v4'\n\nexport const UserRoleSchema = z.enum(['OWNER', 'ADMIN', 'MAKER', 'USER', 'DENY'])\n\nexport const ContinuationTokenSchema = z.string().regex(/^[a-z]{3}-/)\n\nexport const RegionSchema = z.enum([\n  'us-west-2',\n  'us-west-1',\n  'us-east-1',\n  'eu-central-1',\n  'ap-southeast-2',\n])\n"]}

package/dist/abstract/zod.strata.js

@@ -0,0 +1,11 @@
+import * as z from 'zod/v4';
+export const UserRoleSchema = z.enum(['OWNER', 'ADMIN', 'MAKER', 'USER', 'DENY']);
+export const ContinuationTokenSchema = z.string().regex(/^[a-z]{3}-/);
+export const RegionSchema = z.enum([
+    'us-west-2',
+    'us-west-1',
+    'us-east-1',
+    'eu-central-1',
+    'ap-southeast-2',
+]);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiem9kLnN0cmF0YS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hYnN0cmFjdC96b2Quc3RyYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxDQUFDLE1BQU0sUUFBUSxDQUFBO0FBRTNCLE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBRyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsT0FBTyxFQUFFLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sQ0FBQyxDQUFDLENBQUE7QUFFakYsTUFBTSxDQUFDLE1BQU0sdUJBQXVCLEdBQUcsQ0FBQyxDQUFDLE1BQU0sRUFBRSxDQUFDLEtBQUssQ0FBQyxZQUFZLENBQUMsQ0FBQTtBQUVyRSxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsQ0FBQyxDQUFDLElBQUksQ0FBQztJQUNqQyxXQUFXO0lBQ1gsV0FBVztJQUNYLFdBQVc7SUFDWCxjQUFjO0lBQ2QsZ0JBQWdCO0NBQ2pCLENBQUMsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIHogZnJvbSAnem9kL3Y0J1xuXG5leHBvcnQgY29uc3QgVXNlclJvbGVTY2hlbWEgPSB6LmVudW0oWydPV05FUicsICdBRE1JTicsICdNQUtFUicsICdVU0VSJywgJ0RFTlknXSlcblxuZXhwb3J0IGNvbnN0IENvbnRpbnVhdGlvblRva2VuU2NoZW1hID0gei5zdHJpbmcoKS5yZWdleCgvXlthLXpdezN9LS8pXG5cbmV4cG9ydCBjb25zdCBSZWdpb25TY2hlbWEgPSB6LmVudW0oW1xuICAndXMtd2VzdC0yJyxcbiAgJ3VzLXdlc3QtMScsXG4gICd1cy1lYXN0LTEnLFxuICAnZXUtY2VudHJhbC0xJyxcbiAgJ2FwLXNvdXRoZWFzdC0yJyxcbl0pXG4iXX0=