@oh-my-pi/omptype 17.2.6 → 17.2.7

package/dist/js/json-schema.js

@@ -0,0 +1,273 @@
+/** Emit the requested JSON Schema dialect represented by an IR tree. */
+export function irToJsonSchema(ir, options) {
+    let schema = emit(ir, options);
+    if (options?.target === "draft-07")
+        schema = toDraft7(schema);
+    const dialect = options?.dialect ?? dialectFor(options?.target);
+    if (dialect !== undefined)
+        schema.$schema = dialect;
+    if (options?.description !== undefined)
+        schema.description = options.description;
+    return schema;
+}
+function dialectFor(target) {
+    if (target === "draft-2020-12")
+        return "https://json-schema.org/draft/2020-12/schema";
+    if (target === "draft-07")
+        return "http://json-schema.org/draft-07/schema#";
+    return target?.startsWith("http://") || target?.startsWith("https://") ? target : undefined;
+}
+function fallback(schema, options) {
+    const replacement = options?.fallback?.({ base: schema });
+    if (replacement === true)
+        return {};
+    if (replacement === false)
+        return { not: {} };
+    return typeof replacement === "object" && replacement !== null ? replacement : schema;
+}
+function toDraft7(schema) {
+    const converted = {};
+    for (const key in schema) {
+        const value = schema[key];
+        if (key === "prefixItems" && Array.isArray(value)) {
+            converted.items = value.map(item => typeof item === "object" && item !== null ? toDraft7(item) : item);
+        }
+        else if (key === "items" && "prefixItems" in schema) {
+            converted.additionalItems =
+                typeof value === "object" && value !== null ? toDraft7(value) : value;
+        }
+        else if (Array.isArray(value)) {
+            converted[key] = value.map(item => typeof item === "object" && item !== null ? toDraft7(item) : item);
+        }
+        else if (typeof value === "object" && value !== null) {
+            converted[key] = toDraft7(value);
+        }
+        else {
+            converted[key] = value;
+        }
+    }
+    return converted;
+}
+function emit(ir, options) {
+    let schema;
+    switch (ir.k) {
+        case "unknown":
+            schema = {};
+            break;
+        case "undefined":
+            schema = fallback({}, options);
+            break;
+        case "null":
+            schema = { type: "null" };
+            break;
+        case "boolean":
+            schema = { type: "boolean" };
+            break;
+        case "bigint":
+            schema = { type: "integer" };
+            break;
+        case "symbol":
+            schema = fallback({}, options);
+            break;
+        case "never":
+            schema = { not: {} };
+            break;
+        case "anyobject":
+            schema = { type: "object" };
+            break;
+        case "string":
+            schema = emitString(ir);
+            break;
+        case "number":
+            schema = emitNumber(ir);
+            break;
+        case "lit":
+            schema = emitLiteral(ir.v);
+            break;
+        case "union":
+            schema = emitUnion(ir.members, options);
+            break;
+        case "intersection":
+            schema = { allOf: ir.members.map(member => emit(member, options)) };
+            break;
+        case "array":
+            schema = { type: "array", items: emit(ir.el, options) };
+            if (ir.min !== undefined)
+                schema.minItems = ir.min;
+            if (ir.max !== undefined)
+                schema.maxItems = ir.max;
+            break;
+        case "tuple": {
+            const prefixItems = ir.prefix.map(item => {
+                const itemSchema = emit(item.val, options);
+                if (item.hasDefault) {
+                    itemSchema.default = item.defFactory && typeof item.def === "function" ? item.def() : item.def;
+                }
+                return itemSchema;
+            });
+            const required = ir.prefix.reduce((count, item) => count + (item.opt || item.hasDefault ? 0 : 1), ir.postfix.length);
+            schema = { type: "array", prefixItems, minItems: required };
+            if (ir.variadic === undefined) {
+                schema.maxItems = ir.prefix.length + ir.postfix.length;
+                schema.items = false;
+            }
+            else {
+                schema.items = emit(ir.variadic, options);
+            }
+            break;
+        }
+        case "object":
+            schema = emitObject(ir.props, ir.index, ir.extras, options);
+            break;
+        case "instance":
+            schema = ir.ctor === Date ? { type: "string", format: "date-time" } : fallback({ type: "object" }, options);
+            break;
+        case "refine":
+            schema = emit(ir.base, options);
+            if (ir.json !== undefined)
+                Object.assign(schema, ir.json);
+            break;
+        case "morph":
+            schema = fallback(emit(ir.out ?? ir.input, options), options);
+            break;
+        case "alias":
+            schema = emit(ir.resolve(), options);
+            break;
+        case "sub":
+            schema = ir.schema.hasSteps ? fallback(emit(ir.schema.ir, options), options) : emit(ir.schema.ir, options);
+            if (ir.schema.description !== undefined)
+                schema.description = ir.schema.description;
+            break;
+    }
+    if (ir.desc !== undefined)
+        schema.description = ir.desc;
+    return schema;
+}
+function emitString(ir) {
+    const schema = { type: "string" };
+    if (ir.min !== undefined)
+        schema.minLength = ir.min;
+    if (ir.max !== undefined)
+        schema.maxLength = ir.max;
+    if (ir.url)
+        schema.format = "uri";
+    return schema;
+}
+function emitNumber(ir) {
+    const schema = { type: ir.int ? "integer" : "number" };
+    if (ir.min !== undefined)
+        schema[ir.xmin ? "exclusiveMinimum" : "minimum"] = ir.min;
+    if (ir.max !== undefined)
+        schema[ir.xmax ? "exclusiveMaximum" : "maximum"] = ir.max;
+    if (ir.divisor !== undefined)
+        schema.multipleOf = ir.divisor;
+    return schema;
+}
+function emitLiteral(value) {
+    if (value instanceof Date)
+        return { type: "string", format: "date-time", const: value.toISOString() };
+    if (isJsonValue(value))
+        return { const: value };
+    switch (typeof value) {
+        case "string":
+            return { type: "string" };
+        case "number":
+            return { type: "number" };
+        case "boolean":
+            return { type: "boolean" };
+        case "bigint":
+            return { type: "integer" };
+        case "object":
+            return { type: "object" };
+        default:
+            return {};
+    }
+}
+function emitUnion(members, options) {
+    const defined = members.filter(member => member.k !== "undefined");
+    if (defined.length === 0)
+        return {};
+    if (defined.length === 1)
+        return emit(defined[0], options);
+    if (defined.every(member => member.k === "lit" && isJsonValue(member.v))) {
+        const values = defined.map(member => member.v);
+        const schema = { enum: values };
+        const scalarType = homogeneousScalarType(values);
+        if (scalarType !== undefined)
+            schema.type = scalarType;
+        return schema;
+    }
+    return { anyOf: defined.map(member => emit(member, options)) };
+}
+function homogeneousScalarType(values) {
+    const first = jsonScalarType(values[0]);
+    if (first === undefined)
+        return undefined;
+    for (let i = 1; i < values.length; i++) {
+        if (jsonScalarType(values[i]) !== first)
+            return undefined;
+    }
+    return first;
+}
+function jsonScalarType(value) {
+    if (value === null)
+        return "null";
+    switch (typeof value) {
+        case "string":
+        case "number":
+        case "boolean":
+            return typeof value;
+        default:
+            return undefined;
+    }
+}
+function emitObject(props, index, extras, options) {
+    const properties = {};
+    const required = [];
+    // ArkType emits required properties first (each group in declaration
+    // order); downstream wire consumers rely on that stable ordering.
+    const ordered = [...props.filter(p => !p.opt && !p.hasDefault), ...props.filter(p => p.opt || p.hasDefault)];
+    for (const prop of ordered) {
+        const propertySchema = emit(prop.val, options);
+        if (prop.hasDefault) {
+            propertySchema.default = prop.defFactory ? prop.def() : prop.def;
+        }
+        properties[prop.key] = propertySchema;
+        if (!prop.opt && !prop.hasDefault)
+            required.push(prop.key);
+    }
+    const schema = { type: "object", properties };
+    if (required.length > 0)
+        schema.required = required;
+    if (index !== undefined)
+        schema.additionalProperties = emit(index, options);
+    else if (extras === "reject")
+        schema.additionalProperties = false;
+    return schema;
+}
+function isJsonValue(value, seen = new Set()) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return true;
+    if (typeof value === "number")
+        return Number.isFinite(value);
+    if (typeof value !== "object" || seen.has(value))
+        return false;
+    seen.add(value);
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            if (!isJsonValue(item, seen))
+                return false;
+        }
+        seen.delete(value);
+        return true;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+        return false;
+    for (const key in value) {
+        if (Object.hasOwn(value, key) && !isJsonValue(value[key], seen))
+            return false;
+    }
+    seen.delete(value);
+    return true;
+}

package/dist/js/keywords.js

@@ -0,0 +1,233 @@
+const NUMERIC = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/;
+const INTEGER = /^[+-]?(?:0|[1-9]\d*)$/;
+const EMAIL = /^[\w%+.-]+@[\d.A-Za-z-]+\.[A-Za-z]{2,}$/;
+const SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[A-Za-z-][\dA-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][\dA-Za-z-]*))*))?(?:\+([\dA-Za-z-]+(?:\.[\dA-Za-z-]+)*))?$/;
+const UUID = /^[\da-f]{8}-[\da-f]{4}-[1-8][\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}$/i;
+const IPV4_SEGMENT = "(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])";
+const IPV4_ADDRESS = `(?:${IPV4_SEGMENT}[.]){3}${IPV4_SEGMENT}`;
+const IPV4 = new RegExp(`^${IPV4_ADDRESS}$`);
+const IPV6_SEGMENT = "(?:[0-9a-fA-F]{1,4})";
+const IPV6 = new RegExp("^(" +
+    `(?:${IPV6_SEGMENT}:){7}(?:${IPV6_SEGMENT}|:)|` +
+    `(?:${IPV6_SEGMENT}:){6}(?:${IPV4_ADDRESS}|:${IPV6_SEGMENT}|:)|` +
+    `(?:${IPV6_SEGMENT}:){5}(?::${IPV4_ADDRESS}|(:${IPV6_SEGMENT}){1,2}|:)|` +
+    `(?:${IPV6_SEGMENT}:){4}(?:(:${IPV6_SEGMENT}){0,1}:${IPV4_ADDRESS}|(:${IPV6_SEGMENT}){1,3}|:)|` +
+    `(?:${IPV6_SEGMENT}:){3}(?:(:${IPV6_SEGMENT}){0,2}:${IPV4_ADDRESS}|(:${IPV6_SEGMENT}){1,4}|:)|` +
+    `(?:${IPV6_SEGMENT}:){2}(?:(:${IPV6_SEGMENT}){0,3}:${IPV4_ADDRESS}|(:${IPV6_SEGMENT}){1,5}|:)|` +
+    `(?:${IPV6_SEGMENT}:){1}(?:(:${IPV6_SEGMENT}){0,4}:${IPV4_ADDRESS}|(:${IPV6_SEGMENT}){1,6}|:)|` +
+    `(?::((?::${IPV6_SEGMENT}){0,5}:${IPV4_ADDRESS}|(?::${IPV6_SEGMENT}){1,7}|:))` +
+    ")(?:%[\\d.A-Za-z]{1,})?$");
+const ISO_DATE = /^([+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-3])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))(T((([01]\d|2[0-3])((:?)[0-5]\d)?|24:?00)([,.]\d+(?!:))?)?(\17[0-5]\d([,.]\d+)?)?([Zz]|([+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)?$/;
+function pattern(regex, expected, format) {
+    return {
+        k: "refine",
+        base: { k: "string" },
+        pred: value => {
+            regex.lastIndex = 0;
+            return regex.test(value);
+        },
+        expected,
+        json: format === undefined ? { pattern: regex.source } : { pattern: regex.source, format },
+    };
+}
+function morph(input, fn, out) {
+    return { k: "morph", input, fn: (value, context) => fn(value, context), out };
+}
+function parsableJson() {
+    return {
+        k: "refine",
+        base: { k: "string" },
+        pred: value => {
+            try {
+                JSON.parse(value);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        expected: "a JSON string",
+        json: { contentMediaType: "application/json" },
+    };
+}
+function parsableDate(expected = "a parsable date") {
+    return {
+        k: "refine",
+        base: { k: "string" },
+        pred: value => !Number.isNaN(new Date(value).valueOf()),
+        expected,
+        json: { format: "date-time" },
+    };
+}
+function normalize(form) {
+    return morph({ k: "string" }, value => value.normalize(form), patternForNormalized(form));
+}
+function patternForNormalized(form) {
+    return {
+        k: "refine",
+        base: { k: "string" },
+        pred: value => value.normalize(form) === value,
+        expected: `${form}-normalized unicode`,
+    };
+}
+function uuidVersion(version) {
+    return pattern(new RegExp(`^[\\da-f]{8}-[\\da-f]{4}-${version}[\\da-f]{3}-[89ab][\\da-f]{3}-[\\da-f]{12}$`, "i"), `a UUIDv${version}`, "uuid");
+}
+function isLuhnValid(input) {
+    const value = input.replace(/[ -]+/g, "");
+    let sum = 0;
+    let double = false;
+    for (let index = value.length - 1; index >= 0; index--) {
+        let digit = Number(value[index]);
+        if (double) {
+            digit *= 2;
+            if (digit > 9)
+                digit -= 9;
+        }
+        sum += digit;
+        double = !double;
+    }
+    return value.length > 0 && sum % 10 === 0;
+}
+const keywordFactories = {
+    string: () => ({ k: "string" }),
+    "string.alpha": () => pattern(/^[A-Za-z]*$/, "only letters"),
+    "string.alphanumeric": () => pattern(/^[\dA-Za-z]*$/, "only letters and digits 0-9"),
+    "string.hex": () => pattern(/^[\dA-Fa-f]+$/, "hex characters only"),
+    "string.base64": () => pattern(/^(?:[\d+/A-Za-z]{4})*(?:[\d+/A-Za-z]{2}==|[\d+/A-Za-z]{3}=)?$/, "base64-encoded"),
+    "string.base64.url": () => pattern(/^(?:[\w-]{4})*(?:[\w-]{2}(?:==|%3D%3D)?|[\w-]{3}(?:=|%3D)?)?$/, "base64url-encoded"),
+    "string.capitalize": () => morph({ k: "string" }, value => value.charAt(0).toUpperCase() + value.slice(1)),
+    "string.capitalize.preformatted": () => pattern(/^[A-Z].*$/, "capitalized"),
+    "string.creditCard": () => ({
+        k: "refine",
+        base: pattern(/^(?:4\d{12}(?:\d{3,6})?|5[1-5]\d{14}|3[47]\d{13}|6(?:011|5\d\d)\d{12,15})$/, "a credit card number"),
+        pred: value => isLuhnValid(value),
+        expected: "a credit card number",
+    }),
+    "string.date": () => parsableDate(),
+    "string.date.parse": () => morph(parsableDate(), value => new Date(value), { k: "instance", ctor: Date, expected: "a Date" }),
+    "string.date.iso": () => pattern(ISO_DATE, "an ISO 8601 date", "date-time"),
+    "string.date.iso.parse": () => morph(pattern(ISO_DATE, "an ISO 8601 date", "date-time"), value => new Date(value), {
+        k: "instance",
+        ctor: Date,
+        expected: "a Date",
+    }),
+    "string.date.epoch": () => pattern(INTEGER, "an integer string representing a Unix timestamp"),
+    "string.date.epoch.parse": () => morph(pattern(INTEGER, "an integer string representing a Unix timestamp"), value => new Date(Number(value)), {
+        k: "instance",
+        ctor: Date,
+        expected: "a Date",
+    }),
+    "string.digits": () => pattern(/^\d*$/, "only digits 0-9"),
+    "string.email": () => pattern(EMAIL, "an email address", "email"),
+    "string.integer": () => pattern(INTEGER, "a well-formed integer string"),
+    "string.integer.parse": () => morph(pattern(INTEGER, "a well-formed integer string"), (value, context) => {
+        const parsed = Number.parseInt(value, 10);
+        return Number.isSafeInteger(parsed) ? parsed : context.error("a safe integer string");
+    }, { k: "number", int: true }),
+    "string.ip": () => ({
+        k: "union",
+        members: [pattern(IPV4, "an IPv4 address", "ipv4"), pattern(IPV6, "an IPv6 address", "ipv6")],
+    }),
+    "string.ip.v4": () => pattern(IPV4, "an IPv4 address", "ipv4"),
+    "string.ip.v6": () => pattern(IPV6, "an IPv6 address", "ipv6"),
+    "string.json": () => parsableJson(),
+    "string.json.parse": () => morph(parsableJson(), (value, context) => {
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return context.error("a JSON string");
+        }
+    }),
+    "string.lower": () => morph({ k: "string" }, value => value.toLowerCase()),
+    "string.lower.preformatted": () => pattern(/^[a-z]*$/, "only lowercase letters"),
+    "string.normalize": () => normalize("NFC"),
+    "string.normalize.NFC": () => normalize("NFC"),
+    "string.normalize.NFC.preformatted": () => patternForNormalized("NFC"),
+    "string.normalize.NFD": () => normalize("NFD"),
+    "string.normalize.NFD.preformatted": () => patternForNormalized("NFD"),
+    "string.normalize.NFKC": () => normalize("NFKC"),
+    "string.normalize.NFKC.preformatted": () => patternForNormalized("NFKC"),
+    "string.normalize.NFKD": () => normalize("NFKD"),
+    "string.normalize.NFKD.preformatted": () => patternForNormalized("NFKD"),
+    "string.numeric": () => pattern(NUMERIC, "a well-formed numeric string"),
+    "string.numeric.parse": () => morph(pattern(NUMERIC, "a well-formed numeric string"), value => Number.parseFloat(value), { k: "number" }),
+    "string.regex": () => ({
+        k: "refine",
+        base: { k: "string" },
+        pred: value => {
+            try {
+                new RegExp(value);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        expected: "a regex pattern",
+        json: { format: "regex" },
+    }),
+    "string.semver": () => pattern(SEMVER, "a semantic version"),
+    "string.trim": () => morph({ k: "string" }, value => value.trim()),
+    "string.trim.preformatted": () => pattern(/^\S.*\S$|^\S?$/, "trimmed"),
+    "string.upper": () => morph({ k: "string" }, value => value.toUpperCase()),
+    "string.upper.preformatted": () => pattern(/^[A-Z]*$/, "only uppercase letters"),
+    "string.url": () => ({ k: "string", url: true }),
+    "string.url.parse": () => morph({ k: "string", url: true }, value => new URL(value), { k: "instance", ctor: URL, expected: "a URL" }),
+    "string.uuid": () => pattern(UUID, "a UUID", "uuid"),
+    "string.uuid.v1": () => uuidVersion("1"),
+    "string.uuid.v2": () => uuidVersion("2"),
+    "string.uuid.v3": () => uuidVersion("3"),
+    "string.uuid.v4": () => uuidVersion("4"),
+    "string.uuid.v5": () => uuidVersion("5"),
+    "string.uuid.v6": () => uuidVersion("6"),
+    "string.uuid.v7": () => uuidVersion("7"),
+    "string.uuid.v8": () => uuidVersion("8"),
+    "parse.number": () => morph(pattern(NUMERIC, "a well-formed numeric string"), value => Number.parseFloat(value), { k: "number" }),
+    "parse.integer": () => morph(pattern(INTEGER, "a well-formed integer string"), value => Number.parseInt(value, 10), {
+        k: "number",
+        int: true,
+    }),
+    "parse.json": () => keywordFactories["string.json.parse"](),
+    "parse.date": () => keywordFactories["string.date.parse"](),
+    "parse.url": () => keywordFactories["string.url.parse"](),
+    "parse.boolean": () => morph(pattern(/^(?:true|false)$/, "a boolean string"), value => value === "true", { k: "boolean" }),
+    "parse.bigint": () => morph(pattern(INTEGER, "an integer string"), value => BigInt(value), { k: "bigint" }),
+};
+/** Lower a built-in keyword into fresh validation IR. */
+export function keywordIR(name) {
+    return keywordFactories[name]?.();
+}
+/** Lower a regular expression into a string refinement. */
+export function patternIR(regex) {
+    return pattern(regex, `a string matching ${regex}`);
+}
+/** Lower an ArkType-style template literal into a string pattern. */
+export function templateIR(source) {
+    let patternSource = "^";
+    let index = 0;
+    const placeholder = /\$\{(string|number|bigint|boolean)\}/g;
+    for (let match = placeholder.exec(source); match; match = placeholder.exec(source)) {
+        patternSource += escapeRegex(source.slice(index, match.index));
+        switch (match[1]) {
+            case "number":
+                patternSource += "[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)";
+                break;
+            case "bigint":
+                patternSource += "[+-]?\\d+";
+                break;
+            case "boolean":
+                patternSource += "(?:true|false)";
+                break;
+            default:
+                patternSource += ".*";
+        }
+        index = match.index + match[0].length;
+    }
+    patternSource += `${escapeRegex(source.slice(index))}$`;
+    return pattern(new RegExp(patternSource), `a string matching \`${source}\``);
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}