@highstate/designer 0.1.0 → 0.2.1

package/.output/server/node_modules/zod-to-json-schema/dist/esm/parsers/string.js

@@ -1,324 +0,0 @@
-import { setResponseValueAndErrors } from "../errorMessages.js";
-let emojiRegex;
-/**
- * Generated from the regular expressions found here as of 2024-05-22:
- * https://github.com/colinhacks/zod/blob/master/src/types.ts.
- *
- * Expressions with /i flag have been changed accordingly.
- */
-export const zodPatterns = {
-    /**
-     * `c` was changed to `[cC]` to replicate /i flag
-     */
-    cuid: /^[cC][^\s-]{8,}$/,
-    cuid2: /^[0-9a-z]+$/,
-    ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
-    /**
-     * `a-z` was added to replicate /i flag
-     */
-    email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
-    /**
-     * Constructed a valid Unicode RegExp
-     *
-     * Lazily instantiate since this type of regex isn't supported
-     * in all envs (e.g. React Native).
-     *
-     * See:
-     * https://github.com/colinhacks/zod/issues/2433
-     * Fix in Zod:
-     * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
-     */
-    emoji: () => {
-        if (emojiRegex === undefined) {
-            emojiRegex = RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u");
-        }
-        return emojiRegex;
-    },
-    /**
-     * Unused
-     */
-    uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
-    /**
-     * Unused
-     */
-    ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
-    /**
-     * Unused
-     */
-    ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
-    base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
-    nanoid: /^[a-zA-Z0-9_-]{21}$/,
-};
-export function parseStringDef(def, refs) {
-    const res = {
-        type: "string",
-    };
-    function processPattern(value) {
-        return refs.patternStrategy === "escape"
-            ? escapeNonAlphaNumeric(value)
-            : value;
-    }
-    if (def.checks) {
-        for (const check of def.checks) {
-            switch (check.kind) {
-                case "min":
-                    setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number"
-                        ? Math.max(res.minLength, check.value)
-                        : check.value, check.message, refs);
-                    break;
-                case "max":
-                    setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number"
-                        ? Math.min(res.maxLength, check.value)
-                        : check.value, check.message, refs);
-                    break;
-                case "email":
-                    switch (refs.emailStrategy) {
-                        case "format:email":
-                            addFormat(res, "email", check.message, refs);
-                            break;
-                        case "format:idn-email":
-                            addFormat(res, "idn-email", check.message, refs);
-                            break;
-                        case "pattern:zod":
-                            addPattern(res, zodPatterns.email, check.message, refs);
-                            break;
-                    }
-                    break;
-                case "url":
-                    addFormat(res, "uri", check.message, refs);
-                    break;
-                case "uuid":
-                    addFormat(res, "uuid", check.message, refs);
-                    break;
-                case "regex":
-                    addPattern(res, check.regex, check.message, refs);
-                    break;
-                case "cuid":
-                    addPattern(res, zodPatterns.cuid, check.message, refs);
-                    break;
-                case "cuid2":
-                    addPattern(res, zodPatterns.cuid2, check.message, refs);
-                    break;
-                case "startsWith":
-                    addPattern(res, RegExp(`^${processPattern(check.value)}`), check.message, refs);
-                    break;
-                case "endsWith":
-                    addPattern(res, RegExp(`${processPattern(check.value)}$`), check.message, refs);
-                    break;
-                case "datetime":
-                    addFormat(res, "date-time", check.message, refs);
-                    break;
-                case "date":
-                    addFormat(res, "date", check.message, refs);
-                    break;
-                case "time":
-                    addFormat(res, "time", check.message, refs);
-                    break;
-                case "duration":
-                    addFormat(res, "duration", check.message, refs);
-                    break;
-                case "length":
-                    setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number"
-                        ? Math.max(res.minLength, check.value)
-                        : check.value, check.message, refs);
-                    setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number"
-                        ? Math.min(res.maxLength, check.value)
-                        : check.value, check.message, refs);
-                    break;
-                case "includes": {
-                    addPattern(res, RegExp(processPattern(check.value)), check.message, refs);
-                    break;
-                }
-                case "ip": {
-                    if (check.version !== "v6") {
-                        addFormat(res, "ipv4", check.message, refs);
-                    }
-                    if (check.version !== "v4") {
-                        addFormat(res, "ipv6", check.message, refs);
-                    }
-                    break;
-                }
-                case "emoji":
-                    addPattern(res, zodPatterns.emoji, check.message, refs);
-                    break;
-                case "ulid": {
-                    addPattern(res, zodPatterns.ulid, check.message, refs);
-                    break;
-                }
-                case "base64": {
-                    switch (refs.base64Strategy) {
-                        case "format:binary": {
-                            addFormat(res, "binary", check.message, refs);
-                            break;
-                        }
-                        case "contentEncoding:base64": {
-                            setResponseValueAndErrors(res, "contentEncoding", "base64", check.message, refs);
-                            break;
-                        }
-                        case "pattern:zod": {
-                            addPattern(res, zodPatterns.base64, check.message, refs);
-                            break;
-                        }
-                    }
-                    break;
-                }
-                case "nanoid": {
-                    addPattern(res, zodPatterns.nanoid, check.message, refs);
-                }
-                case "toLowerCase":
-                case "toUpperCase":
-                case "trim":
-                    break;
-                default:
-                    /* c8 ignore next */
-                    ((_) => { })(check);
-            }
-        }
-    }
-    return res;
-}
-const escapeNonAlphaNumeric = (value) => Array.from(value)
-    .map((c) => (/[a-zA-Z0-9]/.test(c) ? c : `\\${c}`))
-    .join("");
-const addFormat = (schema, value, message, refs) => {
-    if (schema.format || schema.anyOf?.some((x) => x.format)) {
-        if (!schema.anyOf) {
-            schema.anyOf = [];
-        }
-        if (schema.format) {
-            schema.anyOf.push({
-                format: schema.format,
-                ...(schema.errorMessage &&
-                    refs.errorMessages && {
-                    errorMessage: { format: schema.errorMessage.format },
-                }),
-            });
-            delete schema.format;
-            if (schema.errorMessage) {
-                delete schema.errorMessage.format;
-                if (Object.keys(schema.errorMessage).length === 0) {
-                    delete schema.errorMessage;
-                }
-            }
-        }
-        schema.anyOf.push({
-            format: value,
-            ...(message &&
-                refs.errorMessages && { errorMessage: { format: message } }),
-        });
-    }
-    else {
-        setResponseValueAndErrors(schema, "format", value, message, refs);
-    }
-};
-const addPattern = (schema, regex, message, refs) => {
-    if (schema.pattern || schema.allOf?.some((x) => x.pattern)) {
-        if (!schema.allOf) {
-            schema.allOf = [];
-        }
-        if (schema.pattern) {
-            schema.allOf.push({
-                pattern: schema.pattern,
-                ...(schema.errorMessage &&
-                    refs.errorMessages && {
-                    errorMessage: { pattern: schema.errorMessage.pattern },
-                }),
-            });
-            delete schema.pattern;
-            if (schema.errorMessage) {
-                delete schema.errorMessage.pattern;
-                if (Object.keys(schema.errorMessage).length === 0) {
-                    delete schema.errorMessage;
-                }
-            }
-        }
-        schema.allOf.push({
-            pattern: processRegExp(regex, refs),
-            ...(message &&
-                refs.errorMessages && { errorMessage: { pattern: message } }),
-        });
-    }
-    else {
-        setResponseValueAndErrors(schema, "pattern", processRegExp(regex, refs), message, refs);
-    }
-};
-// Mutate z.string.regex() in a best attempt to accommodate for regex flags when applyRegexFlags is true
-const processRegExp = (regexOrFunction, refs) => {
-    const regex = typeof regexOrFunction === "function" ? regexOrFunction() : regexOrFunction;
-    if (!refs.applyRegexFlags || !regex.flags)
-        return regex.source;
-    // Currently handled flags
-    const flags = {
-        i: regex.flags.includes("i"),
-        m: regex.flags.includes("m"),
-        s: regex.flags.includes("s"), // `.` matches newlines
-    };
-    // The general principle here is to step through each character, one at a time, applying mutations as flags require. We keep track when the current character is escaped, and when it's inside a group /like [this]/ or (also) a range like /[a-z]/. The following is fairly brittle imperative code; edit at your peril!
-    const source = flags.i ? regex.source.toLowerCase() : regex.source;
-    let pattern = "";
-    let isEscaped = false;
-    let inCharGroup = false;
-    let inCharRange = false;
-    for (let i = 0; i < source.length; i++) {
-        if (isEscaped) {
-            pattern += source[i];
-            isEscaped = false;
-            continue;
-        }
-        if (flags.i) {
-            if (inCharGroup) {
-                if (source[i].match(/[a-z]/)) {
-                    if (inCharRange) {
-                        pattern += source[i];
-                        pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
-                        inCharRange = false;
-                    }
-                    else if (source[i + 1] === "-" && source[i + 2]?.match(/[a-z]/)) {
-                        pattern += source[i];
-                        inCharRange = true;
-                    }
-                    else {
-                        pattern += `${source[i]}${source[i].toUpperCase()}`;
-                    }
-                    continue;
-                }
-            }
-            else if (source[i].match(/[a-z]/)) {
-                pattern += `[${source[i]}${source[i].toUpperCase()}]`;
-                continue;
-            }
-        }
-        if (flags.m) {
-            if (source[i] === "^") {
-                pattern += `(^|(?<=[\r\n]))`;
-                continue;
-            }
-            else if (source[i] === "$") {
-                pattern += `($|(?=[\r\n]))`;
-                continue;
-            }
-        }
-        if (flags.s && source[i] === ".") {
-            pattern += inCharGroup ? `${source[i]}\r\n` : `[${source[i]}\r\n]`;
-            continue;
-        }
-        pattern += source[i];
-        if (source[i] === "\\") {
-            isEscaped = true;
-        }
-        else if (inCharGroup && source[i] === "]") {
-            inCharGroup = false;
-        }
-        else if (!inCharGroup && source[i] === "[") {
-            inCharGroup = true;
-        }
-    }
-    try {
-        const regexTest = new RegExp(pattern);
-    }
-    catch {
-        console.warn(`Could not convert regex pattern at ${refs.currentPath.join("/")} to a flag-independent form! Falling back to the flag-ignorant source`);
-        return regex.source;
-    }
-    return pattern;
-};

package/.output/server/node_modules/zod-to-json-schema/dist/esm/parsers/tuple.js

@@ -1,32 +0,0 @@
-import { parseDef } from "../parseDef.js";
-export function parseTupleDef(def, refs) {
-    if (def.rest) {
-        return {
-            type: "array",
-            minItems: def.items.length,
-            items: def.items
-                .map((x, i) => parseDef(x._def, {
-                ...refs,
-                currentPath: [...refs.currentPath, "items", `${i}`],
-            }))
-                .reduce((acc, x) => (x === undefined ? acc : [...acc, x]), []),
-            additionalItems: parseDef(def.rest._def, {
-                ...refs,
-                currentPath: [...refs.currentPath, "additionalItems"],
-            }),
-        };
-    }
-    else {
-        return {
-            type: "array",
-            minItems: def.items.length,
-            maxItems: def.items.length,
-            items: def.items
-                .map((x, i) => parseDef(x._def, {
-                ...refs,
-                currentPath: [...refs.currentPath, "items", `${i}`],
-            }))
-                .reduce((acc, x) => (x === undefined ? acc : [...acc, x]), []),
-        };
-    }
-}

package/.output/server/node_modules/zod-to-json-schema/dist/esm/parsers/undefined.js

@@ -1,5 +0,0 @@
-export function parseUndefinedDef() {
-    return {
-        not: {},
-    };
-}

package/.output/server/node_modules/zod-to-json-schema/dist/esm/parsers/union.js

@@ -1,80 +0,0 @@
-import { parseDef } from "../parseDef.js";
-export const primitiveMappings = {
-    ZodString: "string",
-    ZodNumber: "number",
-    ZodBigInt: "integer",
-    ZodBoolean: "boolean",
-    ZodNull: "null",
-};
-export function parseUnionDef(def, refs) {
-    if (refs.target === "openApi3")
-        return asAnyOf(def, refs);
-    const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
-    // This blocks tries to look ahead a bit to produce nicer looking schemas with type array instead of anyOf.
-    if (options.every((x) => x._def.typeName in primitiveMappings &&
-        (!x._def.checks || !x._def.checks.length))) {
-        // all types in union are primitive and lack checks, so might as well squash into {type: [...]}
-        const types = options.reduce((types, x) => {
-            const type = primitiveMappings[x._def.typeName]; //Can be safely casted due to row 43
-            return type && !types.includes(type) ? [...types, type] : types;
-        }, []);
-        return {
-            type: types.length > 1 ? types : types[0],
-        };
-    }
-    else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
-        // all options literals
-        const types = options.reduce((acc, x) => {
-            const type = typeof x._def.value;
-            switch (type) {
-                case "string":
-                case "number":
-                case "boolean":
-                    return [...acc, type];
-                case "bigint":
-                    return [...acc, "integer"];
-                case "object":
-                    if (x._def.value === null)
-                        return [...acc, "null"];
-                case "symbol":
-                case "undefined":
-                case "function":
-                default:
-                    return acc;
-            }
-        }, []);
-        if (types.length === options.length) {
-            // all the literals are primitive, as far as null can be considered primitive
-            const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
-            return {
-                type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
-                enum: options.reduce((acc, x) => {
-                    return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
-                }, []),
-            };
-        }
-    }
-    else if (options.every((x) => x._def.typeName === "ZodEnum")) {
-        return {
-            type: "string",
-            enum: options.reduce((acc, x) => [
-                ...acc,
-                ...x._def.values.filter((x) => !acc.includes(x)),
-            ], []),
-        };
-    }
-    return asAnyOf(def, refs);
-}
-const asAnyOf = (def, refs) => {
-    const anyOf = (def.options instanceof Map
-        ? Array.from(def.options.values())
-        : def.options)
-        .map((x, i) => parseDef(x._def, {
-        ...refs,
-        currentPath: [...refs.currentPath, "anyOf", `${i}`],
-    }))
-        .filter((x) => !!x &&
-        (!refs.strictUnions ||
-            (typeof x === "object" && Object.keys(x).length > 0)));
-    return anyOf.length ? { anyOf } : undefined;
-};

package/.output/server/node_modules/zod-to-json-schema/dist/esm/parsers/unknown.js

@@ -1,3 +0,0 @@
-export function parseUnknownDef() {
-    return {};
-}

package/.output/server/node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js

@@ -1,59 +0,0 @@
-import { parseDef } from "./parseDef.js";
-import { getRefs } from "./Refs.js";
-const zodToJsonSchema = (schema, options) => {
-    const refs = getRefs(options);
-    const definitions = typeof options === "object" && options.definitions
-        ? Object.entries(options.definitions).reduce((acc, [name, schema]) => ({
-            ...acc,
-            [name]: parseDef(schema._def, {
-                ...refs,
-                currentPath: [...refs.basePath, refs.definitionPath, name],
-            }, true) ?? {},
-        }), {})
-        : undefined;
-    const name = typeof options === "string"
-        ? options
-        : options?.nameStrategy === "title"
-            ? undefined
-            : options?.name;
-    const main = parseDef(schema._def, name === undefined
-        ? refs
-        : {
-            ...refs,
-            currentPath: [...refs.basePath, refs.definitionPath, name],
-        }, false) ?? {};
-    const title = typeof options === "object" &&
-        options.name !== undefined &&
-        options.nameStrategy === "title"
-        ? options.name
-        : undefined;
-    if (title !== undefined) {
-        main.title = title;
-    }
-    const combined = name === undefined
-        ? definitions
-            ? {
-                ...main,
-                [refs.definitionPath]: definitions,
-            }
-            : main
-        : {
-            $ref: [
-                ...(refs.$refStrategy === "relative" ? [] : refs.basePath),
-                refs.definitionPath,
-                name,
-            ].join("/"),
-            [refs.definitionPath]: {
-                ...definitions,
-                [name]: main,
-            },
-        };
-    if (refs.target === "jsonSchema7") {
-        combined.$schema = "http://json-schema.org/draft-07/schema#";
-    }
-    else if (refs.target === "jsonSchema2019-09") {
-        combined.$schema = "https://json-schema.org/draft/2019-09/schema#";
-    }
-    return combined;
-};
-export { zodToJsonSchema };

package/.output/server/node_modules/zod-to-json-schema/package.json

@@ -1,89 +0,0 @@
-{
-  "name": "zod-to-json-schema",
-  "version": "3.23.5",
-  "description": "Converts Zod schemas to Json Schemas",
-  "types": "./dist/types/index.d.ts",
-  "main": "./dist/cjs/index.js",
-  "module": "./dist/esm/index.js",
-  "exports": {
-    "import": {
-      "types": "./dist/types/index.d.ts",
-      "default": "./dist/esm/index.js"
-    },
-    "require": {
-      "types": "./dist/types/index.d.ts",
-      "default": "./dist/cjs/index.js"
-    }
-  },
-  "scripts": {
-    "build:types": "tsc -p tsconfig.types.json",
-    "build:cjs": "tsc -p tsconfig.cjs.json && tsx postcjs.ts",
-    "build:esm": "tsc -p tsconfig.esm.json && tsx postesm.ts",
-    "build": "npm i && npm run gen && npm test && rimraf ./dist && npm run build:types && npm run build:cjs && npm run build:esm",
-    "dry": "npm run build && npm pub --dry-run",
-    "test:watch": "tsx watch test/index.ts",
-    "test:gen": "tsx test/createIndex.ts",
-    "test": "c8 --all tsx test/index.ts",
-    "gen": "tsx createIndex.ts"
-  },
-  "c8": {
-    "exclude": [
-      "createIndex.ts",
-      "postcjs.ts",
-      "postesm.ts",
-      "test"
-    ]
-  },
-  "keywords": [
-    "zod",
-    "json",
-    "schema",
-    "open",
-    "api",
-    "conversion"
-  ],
-  "author": "Stefan Terdell",
-  "contributors": [
-    "Hammad Asif (https://github.com/mrhammadasif)",
-    "Noah Rosenzweig (https://github.com/Noah2610)",
-    "John Wright (https://github.com/johngeorgewright)",
-    "Krzysztof Ciombor (https://github.com/krzysztofciombor)",
-    "Yuta Mombetsu (https://github.com/mokocm)",
-    "Tom Arad (https://github.com/tomarad)",
-    "Isaac Way (https://github.com/iway1)",
-    "Andreas Berger (https://github.com/Andy2003)",
-    "Jan Potoms (https://github.com/Janpot)",
-    "Santiago Cammi (https://github.com/scammi)",
-    "Philipp Burckhardt (https://github.com/Planeshifter)",
-    "Bram del Canho (https://github.com/Bram-dc)",
-    "Gilad Hecht (https://github.com/gthecht)",
-    "Colin McDonnell (https://github.com/colinhacks)",
-    "Spappz (https://github.com/Spappz)",
-    "Jacob Lee (https://github.com/jacoblee93)",
-    "Brett Zamir (https://github.com/brettz9)",
-    "Isaiah Marc Sanchez (https://github.com/imsanchez)",
-    "Mitchell Merry (https://github.com/mitchell-merry)",
-    "Enzo Monjardín (https://github.com/enzomonjardin)"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/StefanTerdell/zod-to-json-schema"
-  },
-  "license": "ISC",
-  "peerDependencies": {
-    "zod": "^3.23.3"
-  },
-  "devDependencies": {
-    "@types/json-schema": "^7.0.9",
-    "@types/node": "^20.9.0",
-    "ajv": "^8.6.3",
-    "ajv-formats": "^2.1.1",
-    "c8": "^10.1.2",
-    "fast-diff": "^1.3.0",
-    "local-ref-resolver": "^0.2.0",
-    "rimraf": "^3.0.2",
-    "tsx": "^4.19.0",
-    "typescript": "^5.1.3",
-    "zod": "^3.23.3"
-  }
-}