@btc-embedded/cdk-extensions 0.10.1 → 0.10.4

package/node_modules/zod/dist/esm/v4/core/util.js

@@ -0,0 +1,491 @@
+// functions
+export function assertEqual(val) {
+    return val;
+}
+export function assertNotEqual(val) {
+    return val;
+}
+export function assertIs(_arg) { }
+export function assertNever(_x) {
+    throw new Error();
+}
+export function assert(_) { }
+export function getEnumValues(entries) {
+    const numericValues = Object.values(entries).filter((v) => typeof v === "number");
+    const values = Object.entries(entries)
+        .filter(([k, _]) => numericValues.indexOf(+k) === -1)
+        .map(([_, v]) => v);
+    return values;
+}
+export function joinValues(array, separator = "|") {
+    return array.map((val) => stringifyPrimitive(val)).join(separator);
+}
+export function jsonStringifyReplacer(_, value) {
+    if (typeof value === "bigint")
+        return value.toString();
+    return value;
+}
+export function cached(getter) {
+    const set = false;
+    return {
+        get value() {
+            if (!set) {
+                const value = getter();
+                Object.defineProperty(this, "value", { value });
+                return value;
+            }
+            throw new Error("cached value already set");
+        },
+    };
+}
+export function nullish(input) {
+    return input === null || input === undefined;
+}
+export function cleanRegex(source) {
+    const start = source.startsWith("^") ? 1 : 0;
+    const end = source.endsWith("$") ? source.length - 1 : source.length;
+    return source.slice(start, end);
+}
+export function floatSafeRemainder(val, step) {
+    const valDecCount = (val.toString().split(".")[1] || "").length;
+    const stepDecCount = (step.toString().split(".")[1] || "").length;
+    const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
+    const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
+    const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
+    return (valInt % stepInt) / 10 ** decCount;
+}
+export function defineLazy(object, key, getter) {
+    const set = false;
+    Object.defineProperty(object, key, {
+        get() {
+            if (!set) {
+                const value = getter();
+                object[key] = value;
+                return value;
+            }
+            throw new Error("cached value already set");
+        },
+        set(v) {
+            Object.defineProperty(object, key, {
+                value: v,
+                // configurable: true,
+            });
+            // object[key] = v;
+        },
+        configurable: true,
+    });
+}
+export function assignProp(target, prop, value) {
+    Object.defineProperty(target, prop, {
+        value,
+        writable: true,
+        enumerable: true,
+        configurable: true,
+    });
+}
+export function getElementAtPath(obj, path) {
+    if (!path)
+        return obj;
+    return path.reduce((acc, key) => acc?.[key], obj);
+}
+export function promiseAllObject(promisesObj) {
+    const keys = Object.keys(promisesObj);
+    const promises = keys.map((key) => promisesObj[key]);
+    return Promise.all(promises).then((results) => {
+        const resolvedObj = {};
+        for (let i = 0; i < keys.length; i++) {
+            resolvedObj[keys[i]] = results[i];
+        }
+        return resolvedObj;
+    });
+}
+export function randomString(length = 10) {
+    const chars = "abcdefghijklmnopqrstuvwxyz";
+    let str = "";
+    for (let i = 0; i < length; i++) {
+        str += chars[Math.floor(Math.random() * chars.length)];
+    }
+    return str;
+}
+export function esc(str) {
+    return JSON.stringify(str);
+}
+export const captureStackTrace = Error.captureStackTrace
+    ? Error.captureStackTrace
+    : (..._args) => { };
+export function isObject(data) {
+    return typeof data === "object" && data !== null && !Array.isArray(data);
+}
+export const allowsEval = cached(() => {
+    if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
+        return false;
+    }
+    try {
+        const F = Function;
+        new F("");
+        return true;
+    }
+    catch (_) {
+        return false;
+    }
+});
+function _isObject(o) {
+    return Object.prototype.toString.call(o) === "[object Object]";
+}
+export function isPlainObject(o) {
+    if (isObject(o) === false)
+        return false;
+    // modified constructor
+    const ctor = o.constructor;
+    if (ctor === undefined)
+        return true;
+    // modified prototype
+    const prot = ctor.prototype;
+    if (isObject(prot) === false)
+        return false;
+    // ctor doesn't have static `isPrototypeOf`
+    if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
+        return false;
+    }
+    return true;
+}
+export function numKeys(data) {
+    let keyCount = 0;
+    for (const key in data) {
+        if (Object.prototype.hasOwnProperty.call(data, key)) {
+            keyCount++;
+        }
+    }
+    return keyCount;
+}
+export const getParsedType = (data) => {
+    const t = typeof data;
+    switch (t) {
+        case "undefined":
+            return "undefined";
+        case "string":
+            return "string";
+        case "number":
+            return Number.isNaN(data) ? "nan" : "number";
+        case "boolean":
+            return "boolean";
+        case "function":
+            return "function";
+        case "bigint":
+            return "bigint";
+        case "symbol":
+            return "symbol";
+        case "object":
+            if (Array.isArray(data)) {
+                return "array";
+            }
+            if (data === null) {
+                return "null";
+            }
+            if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
+                return "promise";
+            }
+            if (typeof Map !== "undefined" && data instanceof Map) {
+                return "map";
+            }
+            if (typeof Set !== "undefined" && data instanceof Set) {
+                return "set";
+            }
+            if (typeof Date !== "undefined" && data instanceof Date) {
+                return "date";
+            }
+            if (typeof File !== "undefined" && data instanceof File) {
+                return "file";
+            }
+            return "object";
+        default:
+            throw new Error(`Unknown data type: ${t}`);
+    }
+};
+export const propertyKeyTypes = new Set(["string", "number", "symbol"]);
+export const primitiveTypes = new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
+export function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+// zod-specific utils
+export function clone(inst, def, params) {
+    const cl = new inst._zod.constr(def ?? inst._zod.def);
+    if (!def || params?.parent)
+        cl._zod.parent = inst;
+    return cl;
+}
+export function normalizeParams(_params) {
+    const params = _params;
+    if (!params)
+        return {};
+    if (typeof params === "string")
+        return { error: () => params };
+    if (params?.message !== undefined) {
+        if (params?.error !== undefined)
+            throw new Error("Cannot specify both `message` and `error` params");
+        params.error = params.message;
+    }
+    delete params.message;
+    if (typeof params.error === "string")
+        return { ...params, error: () => params.error };
+    return params;
+}
+export function createTransparentProxy(getter) {
+    let target;
+    return new Proxy({}, {
+        get(_, prop, receiver) {
+            target ?? (target = getter());
+            return Reflect.get(target, prop, receiver);
+        },
+        set(_, prop, value, receiver) {
+            target ?? (target = getter());
+            return Reflect.set(target, prop, value, receiver);
+        },
+        has(_, prop) {
+            target ?? (target = getter());
+            return Reflect.has(target, prop);
+        },
+        deleteProperty(_, prop) {
+            target ?? (target = getter());
+            return Reflect.deleteProperty(target, prop);
+        },
+        ownKeys(_) {
+            target ?? (target = getter());
+            return Reflect.ownKeys(target);
+        },
+        getOwnPropertyDescriptor(_, prop) {
+            target ?? (target = getter());
+            return Reflect.getOwnPropertyDescriptor(target, prop);
+        },
+        defineProperty(_, prop, descriptor) {
+            target ?? (target = getter());
+            return Reflect.defineProperty(target, prop, descriptor);
+        },
+    });
+}
+export function stringifyPrimitive(value) {
+    if (typeof value === "bigint")
+        return value.toString() + "n";
+    if (typeof value === "string")
+        return `"${value}"`;
+    return `${value}`;
+}
+export function optionalKeys(shape) {
+    return Object.keys(shape).filter((k) => {
+        return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
+    });
+}
+export const NUMBER_FORMAT_RANGES = {
+    safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
+    int32: [-2147483648, 2147483647],
+    uint32: [0, 4294967295],
+    float32: [-3.4028234663852886e38, 3.4028234663852886e38],
+    float64: [-Number.MAX_VALUE, Number.MAX_VALUE],
+};
+export const BIGINT_FORMAT_RANGES = {
+    int64: [/* @__PURE__*/ BigInt("-9223372036854775808"), /* @__PURE__*/ BigInt("9223372036854775807")],
+    uint64: [/* @__PURE__*/ BigInt(0), /* @__PURE__*/ BigInt("18446744073709551615")],
+};
+export function pick(schema, mask) {
+    const newShape = {};
+    const currDef = schema._zod.def; //.shape;
+    for (const key in mask) {
+        if (!(key in currDef.shape)) {
+            throw new Error(`Unrecognized key: "${key}"`);
+        }
+        if (!mask[key])
+            continue;
+        // pick key
+        newShape[key] = currDef.shape[key];
+    }
+    return clone(schema, {
+        ...schema._zod.def,
+        shape: newShape,
+        checks: [],
+    });
+}
+export function omit(schema, mask) {
+    const newShape = { ...schema._zod.def.shape };
+    const currDef = schema._zod.def; //.shape;
+    for (const key in mask) {
+        if (!(key in currDef.shape)) {
+            throw new Error(`Unrecognized key: "${key}"`);
+        }
+        if (!mask[key])
+            continue;
+        delete newShape[key];
+    }
+    return clone(schema, {
+        ...schema._zod.def,
+        shape: newShape,
+        checks: [],
+    });
+}
+export function extend(schema, shape) {
+    const def = {
+        ...schema._zod.def,
+        get shape() {
+            const _shape = { ...schema._zod.def.shape, ...shape };
+            assignProp(this, "shape", _shape); // self-caching
+            return _shape;
+        },
+        checks: [], // delete existing checks
+    };
+    return clone(schema, def);
+}
+export function merge(a, b) {
+    return clone(a, {
+        ...a._zod.def,
+        get shape() {
+            const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
+            assignProp(this, "shape", _shape); // self-caching
+            return _shape;
+        },
+        catchall: b._zod.def.catchall,
+        checks: [], // delete existing checks
+    });
+}
+export function partial(Class, schema, mask) {
+    const oldShape = schema._zod.def.shape;
+    const shape = { ...oldShape };
+    if (mask) {
+        for (const key in mask) {
+            if (!(key in oldShape)) {
+                throw new Error(`Unrecognized key: "${key}"`);
+            }
+            if (!mask[key])
+                continue;
+            shape[key] = Class
+                ? new Class({
+                    type: "optional",
+                    innerType: oldShape[key],
+                })
+                : oldShape[key];
+        }
+    }
+    else {
+        for (const key in oldShape) {
+            shape[key] = Class
+                ? new Class({
+                    type: "optional",
+                    innerType: oldShape[key],
+                })
+                : oldShape[key];
+        }
+    }
+    return clone(schema, {
+        ...schema._zod.def,
+        shape,
+        checks: [],
+    });
+}
+export function required(Class, schema, mask) {
+    const oldShape = schema._zod.def.shape;
+    const shape = { ...oldShape };
+    if (mask) {
+        for (const key in mask) {
+            if (!(key in shape)) {
+                throw new Error(`Unrecognized key: "${key}"`);
+            }
+            if (!mask[key])
+                continue;
+            // overwrite with non-optional
+            shape[key] = new Class({
+                type: "nonoptional",
+                innerType: oldShape[key],
+            });
+        }
+    }
+    else {
+        for (const key in oldShape) {
+            // overwrite with non-optional
+            shape[key] = new Class({
+                type: "nonoptional",
+                innerType: oldShape[key],
+            });
+        }
+    }
+    return clone(schema, {
+        ...schema._zod.def,
+        shape,
+        // optional: [],
+        checks: [],
+    });
+}
+export function aborted(x, startIndex = 0) {
+    for (let i = startIndex; i < x.issues.length; i++) {
+        if (x.issues[i].continue !== true)
+            return true;
+    }
+    return false;
+}
+export function prefixIssues(path, issues) {
+    return issues.map((iss) => {
+        var _a;
+        (_a = iss).path ?? (_a.path = []);
+        iss.path.unshift(path);
+        return iss;
+    });
+}
+export function unwrapMessage(message) {
+    return typeof message === "string" ? message : message?.message;
+}
+export function finalizeIssue(iss, ctx, config) {
+    const full = { ...iss, path: iss.path ?? [] };
+    // for backwards compatibility
+    if (!iss.message) {
+        const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ??
+            unwrapMessage(ctx?.error?.(iss)) ??
+            unwrapMessage(config.customError?.(iss)) ??
+            unwrapMessage(config.localeError?.(iss)) ??
+            "Invalid input";
+        full.message = message;
+    }
+    // delete (full as any).def;
+    delete full.inst;
+    delete full.continue;
+    if (!ctx?.reportInput) {
+        delete full.input;
+    }
+    return full;
+}
+export function getSizableOrigin(input) {
+    if (input instanceof Set)
+        return "set";
+    if (input instanceof Map)
+        return "map";
+    if (input instanceof File)
+        return "file";
+    return "unknown";
+}
+export function getLengthableOrigin(input) {
+    if (Array.isArray(input))
+        return "array";
+    if (typeof input === "string")
+        return "string";
+    return "unknown";
+}
+export function issue(...args) {
+    const [iss, input, inst] = args;
+    if (typeof iss === "string") {
+        return {
+            message: iss,
+            code: "custom",
+            input,
+            inst,
+        };
+    }
+    return { ...iss };
+}
+export function cleanEnum(obj) {
+    return Object.entries(obj)
+        .filter(([k, _]) => {
+        // return true if NaN, meaning it's not a number, thus a string key
+        return Number.isNaN(Number.parseInt(k, 10));
+    })
+        .map((el) => el[1]);
+}
+// instanceof
+export class Class {
+    constructor(..._args) { }
+}

package/node_modules/zod/dist/esm/v4/core/versions.js

@@ -0,0 +1,5 @@
+export const version = {
+    major: 4,
+    minor: 0,
+    patch: 0,
+};

package/node_modules/zod/dist/esm/v4/core/zsf.js

@@ -0,0 +1,171 @@
+///////////////////////////////////////////////////
+////////////////      TYPES     ///////////////////
+///////////////////////////////////////////////////
+export {};
+/////////////////////////////////////////////////
+////////////////      CHECKS     ////////////////
+/////////////////////////////////////////////////
+// export interface $ZSFCheckRegex {
+//   check: "regex";
+//   pattern: string;
+// }
+// export interface $ZSFCheckEmail {
+//   check: "email";
+// }
+// export interface $ZSFCheckURL {
+//   check: "url";
+// }
+// export interface $ZSFCheckEmoji {
+//   check: "emoji";
+// }
+// export interface $ZSFCheckUUID {
+//   check: "uuid";
+// }
+// export interface $ZSFCheckUUIDv4 {
+//   check: "uuidv4";
+// }
+// export interface $ZSFCheckUUIDv6 {
+//   check: "uuidv6";
+// }
+// export interface $ZSFCheckNanoid {
+//   check: "nanoid";
+// }
+// export interface $ZSFCheckGUID {
+//   check: "guid";
+// }
+// export interface $ZSFCheckCUID {
+//   check: "cuid";
+// }
+// export interface $ZSFCheckCUID2 {
+//   check: "cuid2";
+// }
+// export interface $ZSFCheckULID {
+//   check: "ulid";
+// }
+// export interface $ZSFCheckXID {
+//   check: "xid";
+// }
+// export interface $ZSFCheckKSUID {
+//   check: "ksuid";
+// }
+// export interface $ZSFCheckISODateTime {
+//   check: "datetime";
+//   precision?: number;
+//   local?: boolean;
+// }
+// export interface $ZSFCheckISODate {
+//   check: "date";
+// }
+// export interface $ZSFCheckISOTime {
+//   check: "time";
+//   precision?: number;
+//   local?: boolean;
+// }
+// export interface $ZSFCheckDuration {
+//   check: "duration";
+// }
+// export interface $ZSFCheckIP {
+//   check: "ip";
+// }
+// export interface $ZSFCheckIPv4 {
+//   check: "ipv4";
+// }
+// export interface $ZSFCheckIPv6 {
+//   check: "ipv6";
+// }
+// export interface $ZSFCheckBase64 {
+//   check: "base64";
+// }
+// export interface $ZSFCheckJWT {
+//   check: "jwt";
+// }
+// export interface $ZSFCheckJSONString {
+//   check: "json_string";
+// }
+// export interface $ZSFCheckPrefix {
+//   check: "prefix";
+//   prefix: string;
+// }
+// export interface $ZSFCheckSuffix {
+//   check: "suffix";
+//   suffix: string;
+// }
+// export interface $ZSFCheckIncludes {
+//   check: "includes";
+//   includes: string;
+// }
+// export interface $ZSFCheckMinSize {
+//   check: "min_size";
+//   minimum: number;
+// }
+// export interface $ZSFCheckMaxSize {
+//   check: "max_size";
+//   maximum: number;
+// }
+// export interface $ZSFCheckSizeEquals {
+//   check: "size_equals";
+//   size: number;
+// }
+// export interface $ZSFCheckLessThan {
+//   check: "less_than";
+//   maximum: number | bigint | Date;
+// }
+// export interface $ZSFCheckLessThanOrEqual {
+//   check: "less_than_or_equal";
+//   maximum: number | bigint | Date;
+// }
+// export interface $ZSFCheckGreaterThan {
+//   check: "greater_than";
+//   minimum: number | bigint | Date;
+// }
+// export interface $ZSFCheckGreaterThanOrEqual {
+//   check: "greater_than_or_equal";
+//   minimum: number | bigint | Date;
+// }
+// export interface $ZSFCheckEquals {
+//   check: "equals";
+//   value: number | bigint | Date;
+// }
+// export interface $ZSFCheckMultipleOf {
+//   check: "multiple_of";
+//   multipleOf: number;
+// }
+// export type $ZSFStringFormatChecks =
+//   | $ZSFCheckRegex
+//   | $ZSFCheckEmail
+//   | $ZSFCheckURL
+//   | $ZSFCheckEmoji
+//   | $ZSFCheckUUID
+//   | $ZSFCheckUUIDv4
+//   | $ZSFCheckUUIDv6
+//   | $ZSFCheckNanoid
+//   | $ZSFCheckGUID
+//   | $ZSFCheckCUID
+//   | $ZSFCheckCUID2
+//   | $ZSFCheckULID
+//   | $ZSFCheckXID
+//   | $ZSFCheckKSUID
+//   | $ZSFCheckISODateTime
+//   | $ZSFCheckISODate
+//   | $ZSFCheckISOTime
+//   | $ZSFCheckDuration
+//   | $ZSFCheckIP
+//   | $ZSFCheckIPv4
+//   | $ZSFCheckIPv6
+//   | $ZSFCheckBase64
+//   | $ZSFCheckJWT
+//   | $ZSFCheckJSONString
+//   | $ZSFCheckPrefix
+//   | $ZSFCheckSuffix
+//   | $ZSFCheckIncludes;
+// export type $ZSFCheck =
+//   | $ZSFStringFormatChecks
+//   | $ZSFCheckMinSize
+//   | $ZSFCheckMaxSize
+//   | $ZSFCheckSizeEquals
+//   | $ZSFCheckLessThan
+//   | $ZSFCheckLessThanOrEqual
+//   | $ZSFCheckGreaterThan
+//   | $ZSFCheckGreaterThanOrEqual
+//   | $ZSFCheckEquals
+//   | $ZSFCheckMultipleOf;

package/node_modules/zod/dist/esm/v4/index.js

@@ -0,0 +1,3 @@
+import z4 from "./classic/index.js";
+export * from "./classic/index.js";
+export default z4;