@cargo-ai/utils 1.0.4

package/build/src/storage.js

@@ -0,0 +1,169 @@
+import { del as removeIndexedDB, get as getIndexedDB, set as setIndexedDB, } from "idb-keyval";
+let cachedIsLocalStorageSupported = undefined;
+let cachedIsIndexedDBSupportedPromise = undefined;
+// https://github.com/Modernizr/Modernizr/blob/master/feature-detects/storage/localstorage.js
+export const matchIsLocalStorageSupported = () => {
+    if (cachedIsLocalStorageSupported !== undefined) {
+        return cachedIsLocalStorageSupported;
+    }
+    const mod = "modernizr";
+    try {
+        window.localStorage.setItem(mod, mod);
+        window.localStorage.removeItem(mod);
+        cachedIsLocalStorageSupported = true;
+        return true;
+    }
+    catch {
+        cachedIsLocalStorageSupported = false;
+        return false;
+    }
+};
+// https://github.com/Modernizr/Modernizr/blob/master/feature-detects/storage/indexeddb.js
+export const matchIsIndexedDBSupported = async () => {
+    if (cachedIsIndexedDBSupportedPromise !== undefined) {
+        return cachedIsIndexedDBSupportedPromise;
+    }
+    const matchIsCreateDatabaseSupported = async (indexeddb, testDBName) => {
+        try {
+            const isSupported = await new Promise((resolve) => {
+                const req = indexeddb.open(testDBName);
+                req.onsuccess = () => {
+                    resolve(true);
+                };
+                req.onerror = (event) => {
+                    if (req.error &&
+                        (req.error.name === "InvalidStateError" ||
+                            req.error.name === "UnknownError")) {
+                        event.preventDefault();
+                        resolve(false);
+                        return;
+                    }
+                    resolve(true);
+                };
+            });
+            return isSupported;
+        }
+        catch {
+            return false;
+        }
+    };
+    const matchIsDeleteDatabaseSupported = async (indexeddb, testDBName) => {
+        try {
+            const isSupported = await new Promise((resolve) => {
+                const deleteReq = indexeddb.deleteDatabase(testDBName);
+                deleteReq.onsuccess = () => {
+                    resolve(true);
+                };
+                deleteReq.onerror = () => {
+                    resolve(false);
+                };
+            });
+            return isSupported;
+        }
+        catch {
+            return false;
+        }
+    };
+    let indexeddb = null;
+    try {
+        // Firefox throws a Security Error when cookies are disabled
+        indexeddb = window.indexedDB;
+    }
+    catch {
+        cachedIsIndexedDBSupportedPromise = false;
+        return false;
+    }
+    if (indexeddb === null) {
+        cachedIsIndexedDBSupportedPromise = false;
+        return false;
+    }
+    try {
+        const testDBName = `modernizr-${Math.random()}`;
+        const isSupportedPromise = matchIsCreateDatabaseSupported(indexeddb, testDBName).then((isCreateDatabaseSupported) => {
+            if (isCreateDatabaseSupported === false) {
+                return false;
+            }
+            return matchIsDeleteDatabaseSupported(indexeddb, testDBName);
+        });
+        cachedIsIndexedDBSupportedPromise = isSupportedPromise;
+        const isSupported = await isSupportedPromise;
+        cachedIsIndexedDBSupportedPromise = isSupported;
+        return isSupported;
+    }
+    catch {
+        cachedIsIndexedDBSupportedPromise = false;
+        return false;
+    }
+};
+export const getItemFromStorage = async (key, options = {}) => {
+    const { storage = "localStorage" } = options;
+    const getOnLocalStorage = () => {
+        const stringifiedValue = window.localStorage.getItem(key);
+        if (stringifiedValue === null) {
+            return undefined;
+        }
+        const parsedValue = JSON.parse(stringifiedValue);
+        if (parsedValue === null) {
+            return undefined;
+        }
+        return parsedValue;
+    };
+    const getOnIndexedDB = () => {
+        return getIndexedDB(key);
+    };
+    if (storage === "indexedDB") {
+        const isIndexedDBSupported = await matchIsIndexedDBSupported();
+        if (isIndexedDBSupported === true) {
+            return getOnIndexedDB();
+        }
+    }
+    const isLocalStorageSupported = matchIsLocalStorageSupported();
+    if (isLocalStorageSupported === false) {
+        return undefined;
+    }
+    return getOnLocalStorage();
+};
+export const setItemInStorage = async (key, value, options = {}) => {
+    const { storage = "localStorage" } = options;
+    const setOnLocalStorage = () => {
+        const stringifiedValue = JSON.stringify(value === undefined ? null : value);
+        window.localStorage.setItem(key, stringifiedValue);
+        return value;
+    };
+    const setOnIndexedDB = async () => {
+        await setIndexedDB(key, value);
+        return value;
+    };
+    if (storage === "indexedDB") {
+        const isIndexedDBSupported = await matchIsIndexedDBSupported();
+        if (isIndexedDBSupported === true) {
+            return setOnIndexedDB();
+        }
+    }
+    const isLocalStorageSupported = matchIsLocalStorageSupported();
+    if (isLocalStorageSupported === false) {
+        return value;
+    }
+    return setOnLocalStorage();
+};
+export const removeItemFromStorage = async (key, options = {}) => {
+    const { storage = "localStorage" } = options;
+    const removeOnLocalStorage = () => {
+        window.localStorage.removeItem(key);
+    };
+    const removeOnIndexedDB = async () => {
+        await removeIndexedDB(key);
+    };
+    if (storage === "indexedDB") {
+        const isIndexedDBSupported = await matchIsIndexedDBSupported();
+        if (isIndexedDBSupported === true) {
+            await removeOnIndexedDB();
+            return;
+        }
+    }
+    const isLocalStorageSupported = matchIsLocalStorageSupported();
+    if (isLocalStorageSupported === false) {
+        return;
+    }
+    removeOnLocalStorage();
+};

package/build/src/string/capitalizeFirstLetter.d.ts

@@ -0,0 +1,2 @@
+export declare const capitalizeFirstLetter: (string: string) => string;
+//# sourceMappingURL=capitalizeFirstLetter.d.ts.map

package/build/src/string/capitalizeFirstLetter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capitalizeFirstLetter.d.ts","sourceRoot":"","sources":["../../../src/string/capitalizeFirstLetter.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB,WAAY,MAAM,KAAG,MAEtD,CAAC"}

package/build/src/string/capitalizeFirstLetter.js

@@ -0,0 +1,3 @@
+export const capitalizeFirstLetter = (string) => {
+    return `${string.charAt(0).toUpperCase()}${string.slice(1)}`;
+};

package/build/src/string/findAllIndexOf.d.ts

@@ -0,0 +1,2 @@
+export declare const findAllIndexOf: (value: string, search: string) => number[];
+//# sourceMappingURL=findAllIndexOf.d.ts.map

package/build/src/string/findAllIndexOf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findAllIndexOf.d.ts","sourceRoot":"","sources":["../../../src/string/findAllIndexOf.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,UAAW,MAAM,UAAU,MAAM,KAAG,MAAM,EAkBpE,CAAC"}

package/build/src/string/findAllIndexOf.js

@@ -0,0 +1,13 @@
+export const findAllIndexOf = (value, search) => {
+    const indices = [];
+    let startIndex = 0;
+    while (startIndex < value.length) {
+        const index = value.indexOf(search, startIndex);
+        if (index === -1) {
+            break;
+        }
+        indices.push(index);
+        startIndex = index + search.length;
+    }
+    return indices;
+};

package/build/src/string/getHash.d.ts

@@ -0,0 +1,2 @@
+export declare const getHash: (str: string) => number;
+//# sourceMappingURL=getHash.d.ts.map

package/build/src/string/getHash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getHash.d.ts","sourceRoot":"","sources":["../../../src/string/getHash.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,QAAS,MAAM,KAAG,MAUrC,CAAC"}

package/build/src/string/getHash.js

@@ -0,0 +1,9 @@
+export const getHash = (str) => {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash |= 0; // Convert to 32bit integer
+    }
+    return hash;
+};

package/build/src/string/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./capitalizeFirstLetter.js";
+export * from "./findAllIndexOf.js";
+export * from "./getHash.js";
+export * from "./sentenceCase.js";
+//# sourceMappingURL=index.d.ts.map

package/build/src/string/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/string/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,qBAAqB,CAAC;AACpC,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC"}

package/build/src/string/index.js

@@ -0,0 +1,4 @@
+export * from "./capitalizeFirstLetter.js";
+export * from "./findAllIndexOf.js";
+export * from "./getHash.js";
+export * from "./sentenceCase.js";

package/build/src/string/sentenceCase.d.ts

@@ -0,0 +1,2 @@
+export declare function sentenceCase(input: string): string;
+//# sourceMappingURL=sentenceCase.d.ts.map

package/build/src/string/sentenceCase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sentenceCase.d.ts","sourceRoot":"","sources":["../../../src/string/sentenceCase.ts"],"names":[],"mappings":"AAsCA,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAWlD"}

package/build/src/string/sentenceCase.js

@@ -0,0 +1,38 @@
+const SPLIT_LOWER_UPPER_RE = /([\p{Ll}\d])(\p{Lu})/gu;
+const SPLIT_UPPER_UPPER_RE = /(\p{Lu})([\p{Lu}][\p{Ll}])/gu;
+const DEFAULT_STRIP_REGEXP = /[^\p{L}\d]+/giu;
+const SPLIT_REPLACE_VALUE = "$1\0$2";
+const TRIM_NON_ALPHA_RE = /^[^\p{L}]+/u;
+const lowerFactory = (input) => input.toLowerCase();
+const upperFactory = (input) => input.toUpperCase();
+const capitalCaseTransformFactory = (lower, upper) => {
+    return (word) => {
+        const firstCharacter = word[0];
+        if (word.length <= 1 || firstCharacter === undefined) {
+            return word;
+        }
+        return `${upper(firstCharacter)}${lower(word.slice(1))}`;
+    };
+};
+const split = (input) => {
+    let result = input.trim();
+    result = result.replace(TRIM_NON_ALPHA_RE, "");
+    result = result
+        .replace(SPLIT_LOWER_UPPER_RE, SPLIT_REPLACE_VALUE)
+        .replace(SPLIT_UPPER_UPPER_RE, SPLIT_REPLACE_VALUE);
+    result = result.replace(DEFAULT_STRIP_REGEXP, "\0");
+    return result.split(/\0/g);
+};
+export function sentenceCase(input) {
+    if (input.length === 0)
+        return input;
+    const transform = capitalCaseTransformFactory(lowerFactory, upperFactory);
+    const result = split(input)
+        .map((word, index) => {
+        if (index === 0)
+            return transform(word);
+        return lowerFactory(word);
+    })
+        .join(" ");
+    return result;
+}

package/build/src/string.d.ts

@@ -0,0 +1,2 @@
+export declare const safeSlice: (text: string, limit: number) => string;
+//# sourceMappingURL=string.d.ts.map

package/build/src/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../src/string.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS,SAAU,MAAM,SAAS,MAAM,KAAG,MAEvD,CAAC"}

package/build/src/string.js

@@ -0,0 +1,3 @@
+export const safeSlice = (text, limit) => {
+    return [...text].slice(0, limit).join("");
+};

package/build/src/type.d.ts

@@ -0,0 +1,10 @@
+export type RecursivePartial<T> = {
+    [P in keyof T]?: RecursivePartial<T[P]>;
+};
+export type NonNull<T> = T extends null ? never : T;
+export type RecursiveNonNull<T> = T extends null ? T extends Date | RegExp ? NonNull<T> | undefined : T extends object ? {
+    [K in keyof T]: RecursiveNonNull<T[K]>;
+} | undefined : NonNull<T> | undefined : T extends Date | RegExp ? NonNull<T> : T extends object ? {
+    [K in keyof T]: RecursiveNonNull<T[K]>;
+} : NonNull<T>;
+export type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;

package/build/src/type.js

@@ -0,0 +1 @@
+export {};

package/build/src/types.d.ts

@@ -0,0 +1,22 @@
+import type { JsonSchema } from "./jsonSchema/index.js";
+export type RecursivePartial<Type> = {
+    [Prop in keyof Type]?: Type[Prop] extends (infer U)[] ? RecursivePartial<U>[] : Type[Prop] extends object | undefined ? RecursivePartial<Type[Prop]> : Type[Prop];
+};
+export type NonNull<T> = T extends null ? never : T;
+export type RecursiveNonNull<T> = T extends null ? T extends Date | RegExp ? NonNull<T> | undefined : T extends object ? {
+    [K in keyof T]: RecursiveNonNull<T[K]>;
+} | undefined : NonNull<T> | undefined : T extends Date | RegExp ? NonNull<T> : T extends object ? {
+    [K in keyof T]: RecursiveNonNull<T[K]>;
+} : NonNull<T>;
+export type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
+export type EitherOr<T, U> = (T & {
+    [K in keyof U]?: never;
+}) | (U & {
+    [K in keyof T]?: never;
+});
+export type RecursiveSchemaToJsonSchema<T> = T extends {
+    _zod: unknown;
+} ? JsonSchema : T extends Date | RegExp ? T : T extends Array<infer U> ? Array<RecursiveSchemaToJsonSchema<U>> : T extends object ? {
+    [K in keyof T]: RecursiveSchemaToJsonSchema<T[K]>;
+} : T;
+//# sourceMappingURL=types.d.ts.map

package/build/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAExD,MAAM,MAAM,gBAAgB,CAAC,IAAI,IAAI;KAClC,IAAI,IAAI,MAAM,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,GACjD,gBAAgB,CAAC,CAAC,CAAC,EAAE,GACrB,IAAI,CAAC,IAAI,CAAC,SAAS,MAAM,GAAG,SAAS,GACnC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAC5B,IAAI,CAAC,IAAI,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,SAAS,IAAI,GAAG,KAAK,GAAG,CAAC,CAAC;AAEpD,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,CAAC,SAAS,IAAI,GAC5C,CAAC,SAAS,IAAI,GAAG,MAAM,GACrB,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,GACtB,CAAC,SAAS,MAAM,GAEV;KACG,CAAC,IAAI,MAAM,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACvC,GACD,SAAS,GACb,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,GAC1B,CAAC,SAAS,IAAI,GAAG,MAAM,GACrB,OAAO,CAAC,CAAC,CAAC,GACV,CAAC,SAAS,MAAM,GACd;KACG,CAAC,IAAI,MAAM,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACvC,GACD,OAAO,CAAC,CAAC,CAAC,CAAC;AAInB,MAAM,MAAM,gBAAgB,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,GAAG,IAAI,CAAC,SAAS,GAAG,GAChE,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GACV,KAAK,CAAC;AAGV,MAAM,MAAM,QAAQ,CAAC,CAAC,EAAE,CAAC,IACrB,CAAC,CAAC,GAAG;KAAG,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK;CAAE,CAAC,GAChC,CAAC,CAAC,GAAG;KAAG,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK;CAAE,CAAC,CAAC;AAGrC,MAAM,MAAM,2BAA2B,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACpE,UAAU,GACV,CAAC,SAAS,IAAI,GAAG,MAAM,GACrB,CAAC,GACD,CAAC,SAAS,KAAK,CAAC,MAAM,CAAC,CAAC,GACtB,KAAK,CAAC,2BAA2B,CAAC,CAAC,CAAC,CAAC,GACrC,CAAC,SAAS,MAAM,GACd;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,2BAA2B,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,GACrD,CAAC,CAAC"}

package/build/src/types.js

@@ -0,0 +1 @@
+export {};

package/build/src/user.d.ts

@@ -0,0 +1,3 @@
+export declare const getUserInitials: (firstName?: string, lastName?: string) => string;
+export declare const getUserName: (email: string, firstName?: string, lastName?: string) => string;
+//# sourceMappingURL=user.d.ts.map

package/build/src/user.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../src/user.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe,eACd,MAAM,aACP,MAAM,KAChB,MACmE,CAAC;AAEvE,eAAO,MAAM,WAAW,UACf,MAAM,cACD,MAAM,aACP,MAAM,KAChB,MAMF,CAAC"}

package/build/src/user.js

@@ -0,0 +1,7 @@
+export const getUserInitials = (firstName, lastName) => `${firstName?.[0] ?? ""}${lastName?.[0] ?? ""}`.toUpperCase() || "?";
+export const getUserName = (email, firstName, lastName) => {
+    if (!firstName || !lastName) {
+        return email;
+    }
+    return `${firstName} ${lastName}`;
+};

package/build/src/validation/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./matchIsObjectLike.js";
+//# sourceMappingURL=index.d.ts.map

package/build/src/validation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/validation/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC"}

package/build/src/validation/index.js

@@ -0,0 +1 @@
+export * from "./matchIsObjectLike.js";

package/build/src/validation/matchIsObjectLike.d.ts

@@ -0,0 +1,2 @@
+export declare function matchIsObjectLike(value: unknown): value is Record<string, unknown>;
+//# sourceMappingURL=matchIsObjectLike.d.ts.map

package/build/src/validation/matchIsObjectLike.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchIsObjectLike.d.ts","sourceRoot":"","sources":["../../../src/validation/matchIsObjectLike.ts"],"names":[],"mappings":"AAAA,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAGlC"}

package/build/src/validation/matchIsObjectLike.js

@@ -0,0 +1,4 @@
+export function matchIsObjectLike(value) {
+    // eslint-disable-next-line eqeqeq
+    return value != null && typeof value == "object";
+}

package/build/src/vm.d.ts

@@ -0,0 +1 @@
+export declare const runInVm: (script: string, context: Record<string, unknown>) => Promise<unknown>;

package/build/src/vm.js

@@ -0,0 +1,32 @@
+import { createRequire } from "node:module";
+import vm from "node:vm";
+const VM_ALLOWED_MODULES = [
+    "axios",
+    "cheerio",
+    "crypto-js",
+    "date-fns",
+    "jsonschema",
+    "knex",
+    "lodash",
+    "uuid",
+    "zod",
+];
+export const runInVm = async (script, context) => {
+    const require = createRequire(import.meta.url);
+    const vmContext = vm.createContext({
+        require: (moduleName) => {
+            if (VM_ALLOWED_MODULES.includes(moduleName) === false) {
+                throw new Error(`Module ${moduleName} is not allowed`);
+            }
+            return require(moduleName);
+        },
+        ...context,
+    });
+    const vmScript = new vm.Script(`
+      (async () => {${script}})();
+    `);
+    const result = await vmScript.runInContext(vmContext, {
+        timeout: 30000, // 30s
+    });
+    return result;
+};

package/build/src/zod/index.d.ts

@@ -0,0 +1,14 @@
+import type Zod from "zod/v4";
+import { z } from "zod/v4";
+export declare const zodEnum: <T extends string>(values: T[]) => Zod.ZodEnum<{ [k_1 in T]: k_1; } extends infer T_1 ? { [k in keyof T_1]: { [k_1 in T]: k_1; }[k]; } : never>;
+export declare const unwrapZod: (schema: z.ZodType) => z.ZodType;
+export declare const getZodType: (schema: z.ZodType) => string;
+export declare const getZodObjectShape: (schema: z.ZodType) => Record<string, z.ZodType>;
+export declare const getZodUnionOptions: (schema: z.ZodType) => z.ZodType[];
+export declare const getZodFromPath: (schema: z.ZodType, path: string[]) => z.ZodType | undefined;
+export declare const derivePartialZod: (schema: z.ZodType, paths: string[][]) => z.ZodType;
+export declare const setZodMetaFromPath: (schema: z.ZodType, path: string[], meta: {
+    title?: string;
+    description?: string;
+}) => z.ZodType;
+//# sourceMappingURL=index.d.ts.map

package/build/src/zod/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/zod/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAI3B,eAAO,MAAM,OAAO,iJAEnB,CAAC;AAEF,eAAO,MAAM,SAAS,WAAY,EAAE,OAAO,KAAG,EAAE,OAe/C,CAAC;AAEF,eAAO,MAAM,UAAU,WAAY,EAAE,OAAO,KAAG,MAE9C,CAAC;AAMF,eAAO,MAAM,iBAAiB,WACpB,EAAE,OAAO,KAChB,OAAO,MAAM,EAAE,EAAE,OAAO,CAE1B,CAAC;AAMF,eAAO,MAAM,kBAAkB,WAAY,EAAE,OAAO,KAAG,EAAE,OAAO,EAE/D,CAAC;AAEF,eAAO,MAAM,cAAc,WACjB,EAAE,OAAO,QACX,MAAM,EAAE,KACb,EAAE,OAAO,GAAG,SAsCd,CAAC;AAEF,eAAO,MAAM,gBAAgB,WACnB,EAAE,OAAO,SACV,MAAM,EAAE,EAAE,KAChB,EAAE,OAyGJ,CAAC;AA8CF,eAAO,MAAM,kBAAkB,WACrB,EAAE,OAAO,QACX,MAAM,EAAE,QACR;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,KAC7C,EAAE,OA+FJ,CAAC"}

package/build/src/zod/index.js

@@ -0,0 +1,210 @@
+import { z } from "zod/v4";
+import { getEntries, getKeys } from "../collection.js";
+export const zodEnum = (values) => {
+    return z.enum(values);
+};
+export const unwrapZod = (schema) => {
+    const typeName = schema.def.type;
+    if (typeName === "optional" ||
+        typeName === "nullable" ||
+        typeName === "default") {
+        const innerSchema = schema.def
+            .innerType;
+        return unwrapZod(innerSchema);
+    }
+    return schema;
+};
+export const getZodType = (schema) => {
+    return schema.def.type;
+};
+const getZodArrayElement = (schema) => {
+    return schema.def.element;
+};
+export const getZodObjectShape = (schema) => {
+    return schema.def.shape;
+};
+const getZodTupleElements = (schema) => {
+    return schema.def.items;
+};
+export const getZodUnionOptions = (schema) => {
+    return schema.def.options;
+};
+export const getZodFromPath = (schema, path) => {
+    const [head, ...nested] = path;
+    if (head === undefined) {
+        return schema;
+    }
+    const unwrappedSchema = unwrapZod(schema);
+    const typeName = getZodType(unwrappedSchema);
+    if (typeName === "tuple") {
+        const index = Number(head);
+        const elements = getZodTupleElements(unwrappedSchema);
+        const element = elements[index];
+        if (element === undefined) {
+            return undefined;
+        }
+        return getZodFromPath(element, nested);
+    }
+    if (typeName === "array") {
+        return getZodFromPath(getZodArrayElement(unwrappedSchema), nested);
+    }
+    if (typeName === "object") {
+        const shape = getZodObjectShape(unwrappedSchema)[head];
+        if (shape === undefined) {
+            return undefined;
+        }
+        return getZodFromPath(shape, nested);
+    }
+    return undefined;
+};
+export const derivePartialZod = (schema, paths) => {
+    if (paths.length === 0) {
+        return z.object({});
+    }
+    const unwrappedSchema = unwrapZod(schema);
+    const typeName = getZodType(unwrappedSchema);
+    const groupedPaths = paths.reduce((acc, [head, ...nested]) => {
+        if (head === undefined) {
+            return acc;
+        }
+        const currentPaths = acc[head];
+        if (currentPaths === undefined) {
+            return { ...acc, [head]: [nested] };
+        }
+        return {
+            ...acc,
+            [head]: [...currentPaths, nested],
+        };
+    }, {});
+    if (typeName === "object") {
+        const shape = getZodObjectShape(unwrappedSchema);
+        const newShape = getEntries(groupedPaths).reduce((acc, [head, nestedPaths]) => {
+            const subSchema = shape[head];
+            if (subSchema === undefined) {
+                return acc;
+            }
+            const hasEmptyPath = nestedPaths.some((path) => path.length === 0);
+            if (hasEmptyPath === true) {
+                return { ...acc, [head]: subSchema };
+            }
+            return { ...acc, [head]: derivePartialZod(subSchema, nestedPaths) };
+        }, {});
+        return z.object(newShape);
+    }
+    if (typeName === "array" || typeName === "tuple") {
+        const elements = typeName === "array"
+            ? [getZodArrayElement(unwrappedSchema)]
+            : getZodTupleElements(unwrappedSchema);
+        const defaultElement = elements.at(-1);
+        if (defaultElement === undefined) {
+            return z.array(z.never());
+        }
+        const indices = getKeys(groupedPaths).map(Number);
+        const elementsLength = Math.max(...indices.map((index) => index + 1), elements.length);
+        const tupleElements = Array.from({ length: elementsLength }, (_, i) => {
+            if (indices.includes(i) === false) {
+                return z.never();
+            }
+            const element = elements[i] !== undefined ? elements[i] : defaultElement;
+            if (element === undefined) {
+                return z.never();
+            }
+            const nestedPaths = groupedPaths[i];
+            if (nestedPaths === undefined) {
+                return z.never();
+            }
+            const hasEmptyPath = nestedPaths.some((path) => path.length === 0);
+            if (hasEmptyPath === true) {
+                return element;
+            }
+            return derivePartialZod(element, nestedPaths);
+        });
+        if (tupleElements.length === 0) {
+            return z.tuple([]);
+        }
+        // Zod tuple requires at least [head, ...tail]
+        return z.tuple(tupleElements);
+    }
+    return unwrappedSchema;
+};
+const wrapZodWithModifiers = (schema, originalSchema) => {
+    const typeName = originalSchema.def.type;
+    if (typeName === "optional") {
+        const innerType = originalSchema.def.innerType;
+        return z.optional(wrapZodWithModifiers(schema, innerType));
+    }
+    if (typeName === "nullable") {
+        const innerType = originalSchema.def.innerType;
+        return z.nullable(wrapZodWithModifiers(schema, innerType));
+    }
+    if (typeName === "default") {
+        const innerType = originalSchema.def.innerType;
+        const defaultValue = originalSchema.def.defaultValue;
+        return wrapZodWithModifiers(schema, innerType).default(defaultValue);
+    }
+    return schema;
+};
+export const setZodMetaFromPath = (schema, path, meta) => {
+    const [head, ...nested] = path;
+    if (head === undefined) {
+        // Empty path means we're setting meta on the root schema
+        return schema.meta(meta);
+    }
+    const unwrappedSchema = unwrapZod(schema);
+    const typeName = getZodType(unwrappedSchema);
+    if (typeName === "tuple") {
+        const index = Number(head);
+        const elements = getZodTupleElements(unwrappedSchema);
+        const defaultElement = elements.at(-1);
+        if (defaultElement === undefined) {
+            return schema;
+        }
+        const elementsLength = Math.max(index + 1, elements.length);
+        const tupleElements = Array.from({ length: elementsLength }, (_, i) => {
+            const element = elements[i] !== undefined ? elements[i] : defaultElement;
+            if (element === undefined) {
+                return z.never();
+            }
+            if (i === index) {
+                return setZodMetaFromPath(element, nested, meta);
+            }
+            return element;
+        });
+        if (tupleElements.length === 0) {
+            return wrapZodWithModifiers(z.tuple([]), schema);
+        }
+        return wrapZodWithModifiers(z.tuple(tupleElements), schema);
+    }
+    if (typeName === "array") {
+        const index = Number(head);
+        const element = getZodArrayElement(unwrappedSchema);
+        if (index === 0) {
+            return wrapZodWithModifiers(z.array(setZodMetaFromPath(element, nested, meta)), schema);
+        }
+        const tupleElements = Array.from({ length: index + 1 }, (_, i) => {
+            if (i === index) {
+                return setZodMetaFromPath(element, nested, meta);
+            }
+            return element;
+        });
+        if (tupleElements.length === 0) {
+            return wrapZodWithModifiers(z.tuple([]), schema);
+        }
+        return wrapZodWithModifiers(z.tuple(tupleElements), schema);
+    }
+    if (typeName === "object") {
+        const shape = getZodObjectShape(unwrappedSchema);
+        const subSchema = shape[head];
+        if (subSchema === undefined) {
+            return schema;
+        }
+        const updatedSubSchema = setZodMetaFromPath(subSchema, nested, meta);
+        const newShape = {
+            ...shape,
+            [head]: updatedSubSchema,
+        };
+        const updatedObject = z.object(newShape);
+        return wrapZodWithModifiers(updatedObject, schema);
+    }
+    return schema;
+};