@oh-my-pi/omptype 18.16.0 → 18.18.0

package/dist/js/jsonschema/pattern.js

@@ -0,0 +1,221 @@
+/**
+ * Compiles simple anchored `pattern`s into char-code checks for generated
+ * validators: `^[0-9a-f]{8}-…$`, `^\d{4}-\d{2}-\d{2}$`, `^[A-Za-z0-9._-]+$`.
+ *
+ * Supported: ASCII literals and escaped punctuation, `\d`, `\w`, non-negated
+ * ASCII classes, and quantifiers, with at most one variable-length segment.
+ * Fixed segments then pin every position (from the start before the variable
+ * segment, from the end after it), so the check is exact without
+ * backtracking. ASCII-only classes reject every UTF-16 surrogate, so counting
+ * code units agrees with the `u` flag's code points. Anything else returns
+ * `undefined` and stays a `RegExp`.
+ */
+const DIGIT = [[48, 57]];
+const WORD = [
+    [48, 57],
+    [65, 90],
+    [95, 95],
+    [97, 122],
+];
+function isPunctuation(code) {
+    return code < 128 && !(code >= 48 && code <= 57) && !(code >= 65 && code <= 90) && !(code >= 97 && code <= 122);
+}
+/** Ranges of an escape (`\d`, `\w`, `\.`), or `undefined` when unsupported. */
+function escapeRanges(code) {
+    if (code === undefined)
+        return undefined;
+    if (code === 100)
+        return DIGIT;
+    if (code === 119)
+        return WORD;
+    return isPunctuation(code) ? [[code, code]] : undefined;
+}
+function parseClass(body, start) {
+    const ranges = [];
+    let index = start;
+    if (body.charCodeAt(index) === 94)
+        return undefined; // negated
+    const single = () => {
+        const code = body.charCodeAt(index);
+        if (code === 92) {
+            const escaped = body.charCodeAt(index + 1);
+            if (!isPunctuation(escaped))
+                return undefined;
+            index += 2;
+            return escaped;
+        }
+        if (Number.isNaN(code) || code >= 128 || code === 91 || code === 93)
+            return undefined;
+        index++;
+        return code;
+    };
+    while (index < body.length && body.charCodeAt(index) !== 93) {
+        if (body.charCodeAt(index) === 92) {
+            const named = body.charCodeAt(index + 1);
+            if (named === 100 || named === 119) {
+                ranges.push(...escapeRanges(named));
+                index += 2;
+                continue;
+            }
+        }
+        const low = single();
+        if (low === undefined)
+            return undefined;
+        if (body.charCodeAt(index) === 45 && index + 1 < body.length && body.charCodeAt(index + 1) !== 93) {
+            index++;
+            const high = single();
+            if (high === undefined || high < low)
+                return undefined;
+            ranges.push([low, high]);
+        }
+        else {
+            ranges.push([low, low]);
+        }
+    }
+    if (index >= body.length || ranges.length === 0)
+        return undefined;
+    return { ranges, end: index + 1 };
+}
+function parseQuantifier(body, start) {
+    const code = body.charCodeAt(start);
+    let result;
+    if (code === 43)
+        result = { min: 1, max: Infinity, end: start + 1 };
+    else if (code === 42)
+        result = { min: 0, max: Infinity, end: start + 1 };
+    else if (code === 63)
+        result = { min: 0, max: 1, end: start + 1 };
+    else if (code === 123) {
+        const match = /^\{(\d+)(,(\d*))?\}/.exec(body.slice(start));
+        if (match === null)
+            return undefined;
+        const min = Number(match[1]);
+        const max = match[2] === undefined ? min : match[3] === "" ? Infinity : Number(match[3]);
+        if (max < min)
+            return undefined;
+        result = { min, max, end: start + match[0].length };
+    }
+    else {
+        return { min: 1, max: 1, end: start };
+    }
+    // Lazy and possessive-looking suffixes change nothing here but are rare; keep them as regexes.
+    return body.charCodeAt(result.end) === 63 || body.charCodeAt(result.end) === 43 ? undefined : result;
+}
+function parse(source) {
+    if (source.length < 2 || source.charCodeAt(0) !== 94 || source.charCodeAt(source.length - 1) !== 36) {
+        return undefined;
+    }
+    const body = source.slice(1, -1);
+    // `\$` at the end is a literal dollar followed by no anchor.
+    let slashes = 0;
+    for (let index = body.length - 1; index >= 0 && body.charCodeAt(index) === 92; index--)
+        slashes++;
+    if (slashes % 2 === 1)
+        return undefined;
+    const segments = [];
+    let index = 0;
+    while (index < body.length) {
+        const code = body.charCodeAt(index);
+        let ranges;
+        if (code === 91) {
+            const parsed = parseClass(body, index + 1);
+            if (parsed === undefined)
+                return undefined;
+            ranges = parsed.ranges;
+            index = parsed.end;
+        }
+        else if (code === 92) {
+            ranges = escapeRanges(body.charCodeAt(index + 1));
+            index += 2;
+        }
+        else if (code < 128 && !"()|.*+?{}^$]".includes(body[index])) {
+            ranges = [[code, code]];
+            index++;
+        }
+        if (ranges === undefined)
+            return undefined;
+        const quantifier = parseQuantifier(body, index);
+        if (quantifier === undefined)
+            return undefined;
+        index = quantifier.end;
+        segments.push({ ranges, min: quantifier.min, max: quantifier.max });
+    }
+    let variable = 0;
+    for (const segment of segments)
+        if (segment.min !== segment.max)
+            variable++;
+    return variable <= 1 ? segments : undefined;
+}
+function rangeTest(ranges) {
+    const sorted = [...ranges].sort((a, b) => a[0] - b[0]);
+    const merged = [];
+    for (const [low, high] of sorted) {
+        const last = merged[merged.length - 1];
+        if (last !== undefined && low <= last[1] + 1)
+            last[1] = Math.max(last[1], high);
+        else
+            merged.push([low, high]);
+    }
+    return merged.map(([low, high]) => (low === high ? `c===${low}` : `(c>=${low}&&c<=${high})`)).join("||");
+}
+/** Statements checking positions `[from, to)` (`to` may be an expression) against `ranges`. */
+function positions(ranges, from, to, count) {
+    const test = rangeTest(ranges);
+    if (count !== undefined && count <= 4) {
+        let out = "";
+        for (let offset = 0; offset < count; offset++) {
+            out += `c=s.charCodeAt(${from}+${offset});if(!(${test}))return false;`;
+        }
+        return out;
+    }
+    return `for(let i=${from};i<${to};i++){c=s.charCodeAt(i);if(!(${test}))return false;}`;
+}
+/**
+ * Source of `function name(s)` testing a string against `source` with the
+ * `u` flag's semantics, or `undefined` when the pattern is not simple.
+ */
+export function compileSimplePattern(source, name) {
+    const segments = parse(source);
+    if (segments === undefined)
+        return undefined;
+    let fixed = 0;
+    let variable;
+    for (const segment of segments) {
+        if (segment.min === segment.max)
+            fixed += segment.min;
+        else
+            variable = segment;
+    }
+    let body = "const n=s.length;let c;";
+    if (variable === undefined)
+        body += `if(n!==${fixed})return false;`;
+    else {
+        body += `if(n<${fixed + variable.min})return false;`;
+        if (variable.max !== Infinity)
+            body += `if(n>${fixed + variable.max})return false;`;
+    }
+    // Positions before the variable segment count from 0, after it from the end.
+    let position = 0;
+    let fromEnd = false;
+    let suffix = 0;
+    if (variable !== undefined) {
+        for (let index = segments.length - 1; segments[index] !== variable; index--)
+            suffix += segments[index].min;
+    }
+    for (const segment of segments) {
+        if (segment === variable) {
+            body += positions(segment.ranges, String(position), `n-${suffix}`, undefined);
+            fromEnd = true;
+            continue;
+        }
+        if (segment.min === 0)
+            continue;
+        const start = fromEnd ? `n-${suffix}` : String(position);
+        body += positions(segment.ranges, start, `${start}+${segment.min}`, segment.min);
+        if (fromEnd)
+            suffix -= segment.min;
+        else
+            position += segment.min;
+    }
+    return `function ${name}(s){${body}return true}`;
+}

package/dist/js/jsonschema/plan.js

@@ -0,0 +1,448 @@
+/**
+ * Planner: lowers JSON Schema documents into a draft-independent {@link Plan}
+ * graph that both validator backends consume.
+ *
+ * Planning applies everything that does not depend on the instance: dialect
+ * differences (draft 7 `$ref` overriding its siblings, array-form `items`
+ * with `additionalItems`, `dependencies`), vocabularies, `$ref` resolution,
+ * and `$dynamicRef` resolution. The dynamic scope only matters through the
+ * outermost resource declaring each `$dynamicAnchor` name, so plans are
+ * memoized per (schema, scope) and recursion stays finite.
+ */
+import { OmpTypeError } from "../errors.js";
+import { VOCAB_APPLICATOR, VOCAB_UNEVALUATED, VOCAB_VALIDATION, } from "./resolve.js";
+import { compilePattern, isInheritedName } from "./runtime.js";
+export const T_NULL = 1;
+export const T_BOOLEAN = 2;
+export const T_INTEGER = 4;
+/** Any finite number, integers included. */
+export const T_NUMBER = 8;
+export const T_STRING = 16;
+export const T_ARRAY = 32;
+export const T_OBJECT = 64;
+export const T_ANY = 127;
+/** Every number type: `type: "number"`. */
+export const T_NUMERIC = T_NUMBER | T_INTEGER;
+/** The single JSON kind a passing value of `types` has, as a mask; 0 when several. */
+export function kindOf(types) {
+    if (types === 0)
+        return 0;
+    if ((types & T_NUMERIC) === types)
+        return types;
+    return (types & (types - 1)) === 0 ? types : 0;
+}
+const TYPE_FLAGS = {
+    null: T_NULL,
+    boolean: T_BOOLEAN,
+    integer: T_INTEGER,
+    number: T_NUMERIC,
+    string: T_STRING,
+    array: T_ARRAY,
+    object: T_OBJECT,
+};
+/** The `true` schema. */
+export const TRUE_PLAN = { types: T_ANY, empty: true, flags: 0 };
+/** The `false` schema. */
+export const FALSE_PLAN = { types: 0, empty: false, flags: 0 };
+export const F_CONST = 1;
+export const F_ENUM = 2;
+/** Numeric keywords. */
+export const F_NUMBER = 4;
+/** String keywords. */
+export const F_STRING = 8;
+/** Array keywords. */
+export const F_ARRAY = 16;
+/** `required` and `properties`. */
+export const F_PROPERTIES = 32;
+/** Keywords that visit every key: `patternProperties`, `additionalProperties`, `propertyNames`, property counts. */
+export const F_KEYS = 64;
+/** `dependentRequired`, `dependentSchemas`. */
+export const F_DEPENDENT = 128;
+export const F_REFS = 256;
+/** `allOf`, `anyOf`, `oneOf`, `not`, `if`. */
+export const F_APPLICATORS = 512;
+/** `unevaluatedProperties`, `unevaluatedItems`. */
+export const F_UNEVALUATED = 1024;
+/** Keyword group of each constraining plan field; neutral fields map to 0. */
+const FIELD_FLAGS = {
+    hasConst: F_CONST,
+    enumValues: F_ENUM,
+    multipleOf: F_NUMBER,
+    minimum: F_NUMBER,
+    maximum: F_NUMBER,
+    exclusiveMinimum: F_NUMBER,
+    exclusiveMaximum: F_NUMBER,
+    minLength: F_STRING,
+    maxLength: F_STRING,
+    pattern: F_STRING,
+    format: F_STRING,
+    minItems: F_ARRAY,
+    maxItems: F_ARRAY,
+    uniqueItems: F_ARRAY,
+    prefixItems: F_ARRAY,
+    items: F_ARRAY,
+    contains: F_ARRAY,
+    minContains: F_ARRAY,
+    maxContains: F_ARRAY,
+    required: F_PROPERTIES,
+    properties: F_PROPERTIES,
+    patternProperties: F_KEYS,
+    additionalProperties: F_KEYS,
+    propertyNames: F_KEYS,
+    minProperties: F_KEYS,
+    maxProperties: F_KEYS,
+    dependentRequired: F_DEPENDENT,
+    dependentSchemas: F_DEPENDENT,
+    refs: F_REFS,
+    allOf: F_APPLICATORS,
+    anyOf: F_APPLICATORS,
+    oneOf: F_APPLICATORS,
+    not: F_APPLICATORS,
+    if: F_APPLICATORS,
+    ifThen: F_APPLICATORS,
+    ifElse: F_APPLICATORS,
+    unevaluatedProperties: F_UNEVALUATED,
+    unevaluatedItems: F_UNEVALUATED,
+};
+const EMPTY_SCOPE = { key: "", anchors: new Map() };
+function enter(scope, resource) {
+    if (resource.dynamicAnchors.size === 0)
+        return scope;
+    let anchors;
+    for (const name of resource.dynamicAnchors.keys()) {
+        if (scope.anchors.has(name))
+            continue;
+        anchors ??= new Map(scope.anchors);
+        anchors.set(name, resource);
+    }
+    if (anchors === undefined)
+        return scope;
+    const key = [...anchors]
+        .map(([name, owner]) => `${name}\u0001${owner.uri}`)
+        .sort()
+        .join("\u0002");
+    return { key, anchors };
+}
+function isNode(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringList(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    for (const item of value)
+        if (typeof item !== "string")
+            return undefined;
+    return value;
+}
+/** Lowers one registry's documents into plans. */
+export class Planner {
+    #registry;
+    #formats;
+    /** Plans in the empty dynamic scope (almost all of them), by schema. */
+    #memo = new Map();
+    /** Plans under `$dynamicAnchor` scopes, by scope key then schema. */
+    #scoped = new Map();
+    /** Whether any `properties` subschema declares a `default`. */
+    sawDefaults = false;
+    constructor(registry, formats) {
+        this.#registry = registry;
+        this.#formats = formats;
+    }
+    /** Plan the registry's root document. */
+    root(schema) {
+        const target = this.#registry.addRoot(schema);
+        return this.#build(target.schema, target.location, enter(EMPTY_SCOPE, target.location.resource));
+    }
+    #build(schema, location, scope) {
+        if (schema === true)
+            return TRUE_PLAN;
+        if (schema === false)
+            return FALSE_PLAN;
+        if (!isNode(schema))
+            throw new OmpTypeError("JSON Schema nodes must be booleans or objects");
+        let memo = this.#memo;
+        if (scope.key !== "") {
+            let scoped = this.#scoped.get(scope.key);
+            if (scoped === undefined) {
+                scoped = new Map();
+                this.#scoped.set(scope.key, scoped);
+            }
+            memo = scoped;
+        }
+        const known = memo.get(schema);
+        if (known !== undefined)
+            return known;
+        const plan = { types: T_ANY, empty: false, flags: 0 };
+        memo.set(schema, plan);
+        this.#fill(plan, schema, location, scope);
+        let flags = 0;
+        for (const field in plan)
+            flags |= FIELD_FLAGS[field] ?? 0;
+        if (flags === 0) {
+            // Type-only schemas (`{ "type": "string", "description": … }`) have no subschemas, so
+            // nothing captured `plan` while filling it; every one of them shares a plan per mask.
+            const shared = typePlan(plan.types);
+            memo.set(schema, shared);
+            return shared;
+        }
+        plan.flags = flags;
+        return plan;
+    }
+    /** Plan a subschema reached structurally from `parent`. */
+    #child(schema, parent, scope) {
+        if (!isNode(schema))
+            return this.#build(schema, parent, scope);
+        const location = this.#registry.location(schema) ?? parent;
+        return this.#build(schema, location, location.resource === parent.resource ? scope : enter(scope, location.resource));
+    }
+    #ref(ref, location, scope) {
+        const target = this.#registry.resolve(ref, location.base);
+        return this.#build(target.schema, target.location, enter(scope, target.location.resource));
+    }
+    /**
+     * `$dynamicRef` resolves like `$ref` unless its initial target declares the
+     * fragment as a `$dynamicAnchor`; then the outermost resource in scope
+     * declaring that anchor wins.
+     */
+    #dynamicRef(ref, location, scope) {
+        const target = this.#registry.resolve(ref, location.base);
+        const hash = ref.indexOf("#");
+        const name = hash < 0 ? "" : ref.slice(hash + 1);
+        if (name === "" || name.charCodeAt(0) === 47 || !isNode(target.schema) || target.schema.$dynamicAnchor !== name) {
+            return this.#build(target.schema, target.location, enter(scope, target.location.resource));
+        }
+        const outermost = scope.anchors.get(name);
+        const dynamic = outermost?.dynamicAnchors.get(name);
+        if (outermost === undefined || dynamic === undefined) {
+            return this.#build(target.schema, target.location, enter(scope, target.location.resource));
+        }
+        const dynamicLocation = this.#registry.location(dynamic) ?? { base: outermost.uri, resource: outermost };
+        return this.#build(dynamic, dynamicLocation, enter(scope, outermost));
+    }
+    /** Lower the keywords `node` declares; one pass over its own keys. */
+    #fill(plan, node, location, scope) {
+        const { draft, vocab } = location.resource;
+        if (typeof node.$ref === "string") {
+            plan.refs = [this.#ref(node.$ref, location, scope)];
+            // Draft 7: `$ref` overrides every sibling keyword.
+            if (draft === "7")
+                return;
+        }
+        const validation = (vocab & VOCAB_VALIDATION) !== 0;
+        const applicator = (vocab & VOCAB_APPLICATOR) !== 0;
+        const unevaluated = draft !== "7" && (vocab & VOCAB_UNEVALUATED) !== 0;
+        for (const key in node) {
+            const value = node[key];
+            switch (key) {
+                case "$dynamicRef":
+                    if (draft === "2020-12" && typeof value === "string") {
+                        (plan.refs ??= []).push(this.#dynamicRef(value, location, scope));
+                    }
+                    break;
+                case "type":
+                    if (validation)
+                        plan.types = typeFlags(value);
+                    break;
+                case "const":
+                    if (validation) {
+                        plan.hasConst = true;
+                        plan.constValue = value;
+                    }
+                    break;
+                case "enum":
+                    if (validation && Array.isArray(value))
+                        plan.enumValues = value;
+                    break;
+                case "multipleOf":
+                    if (validation && typeof value === "number" && value > 0)
+                        plan.multipleOf = value;
+                    break;
+                case "minimum":
+                case "maximum":
+                case "exclusiveMinimum":
+                case "exclusiveMaximum":
+                    if (validation && typeof value === "number" && Number.isFinite(value))
+                        plan[key] = value;
+                    break;
+                case "minLength":
+                case "maxLength":
+                case "minItems":
+                case "maxItems":
+                case "minProperties":
+                case "maxProperties":
+                    if (validation && typeof value === "number" && value >= 0)
+                        plan[key] = value;
+                    break;
+                case "minContains":
+                case "maxContains":
+                    if (validation && draft !== "7" && typeof value === "number" && value >= 0)
+                        plan[key] = value;
+                    break;
+                case "pattern":
+                    if (validation && typeof value === "string")
+                        plan.pattern = pattern(value);
+                    break;
+                case "uniqueItems":
+                    if (validation && value === true)
+                        plan.uniqueItems = true;
+                    break;
+                case "required": {
+                    const required = validation ? stringList(value) : undefined;
+                    if (required !== undefined && required.length > 0)
+                        plan.required = required;
+                    break;
+                }
+                case "dependentRequired":
+                case "dependencies":
+                    if (!isNode(value))
+                        break;
+                    for (const property in value) {
+                        const dependency = value[property];
+                        if (Array.isArray(dependency)) {
+                            const required = validation ? stringList(dependency) : undefined;
+                            if (required !== undefined && required.length > 0) {
+                                (plan.dependentRequired ??= []).push({ key: property, required });
+                            }
+                        }
+                        else if (applicator &&
+                            key === "dependencies" &&
+                            (isNode(dependency) || typeof dependency === "boolean")) {
+                            (plan.dependentSchemas ??= []).push({
+                                key: property,
+                                plan: this.#child(dependency, location, scope),
+                                inherited: isInheritedName(property),
+                            });
+                        }
+                    }
+                    break;
+                case "dependentSchemas":
+                    if (!applicator || !isNode(value))
+                        break;
+                    for (const property in value) {
+                        (plan.dependentSchemas ??= []).push({
+                            key: property,
+                            plan: this.#child(value[property], location, scope),
+                            inherited: isInheritedName(property),
+                        });
+                    }
+                    break;
+                case "format": {
+                    const check = typeof value === "string" ? this.#formats?.[value] : undefined;
+                    if (check !== undefined) {
+                        plan.format = check;
+                        plan.formatName = value;
+                    }
+                    break;
+                }
+                case "allOf":
+                case "anyOf":
+                case "oneOf":
+                    if (applicator && Array.isArray(value) && value.length > 0) {
+                        plan[key] = value.map(branch => this.#child(branch, location, scope));
+                    }
+                    break;
+                case "not":
+                    if (applicator)
+                        plan.not = this.#child(value, location, scope);
+                    break;
+                case "if":
+                    if (!applicator)
+                        break;
+                    plan.if = this.#child(value, location, scope);
+                    if (node.then !== undefined)
+                        plan.ifThen = this.#child(node.then, location, scope);
+                    if (node.else !== undefined)
+                        plan.ifElse = this.#child(node.else, location, scope);
+                    break;
+                case "properties":
+                    if (applicator && isNode(value))
+                        this.#properties(plan, value, location, scope);
+                    break;
+                case "patternProperties":
+                    if (!applicator || !isNode(value))
+                        break;
+                    for (const source in value) {
+                        (plan.patternProperties ??= []).push({
+                            pattern: pattern(source),
+                            plan: this.#child(value[source], location, scope),
+                        });
+                    }
+                    break;
+                case "additionalProperties":
+                case "propertyNames":
+                case "contains":
+                    if (applicator)
+                        plan[key] = this.#child(value, location, scope);
+                    break;
+                case "items":
+                    if (!applicator)
+                        break;
+                    if (Array.isArray(value)) {
+                        // Draft 7 tuples (and 2019-09): `additionalItems` covers the rest.
+                        plan.prefixItems = value.map(item => this.#child(item, location, scope));
+                        if (node.additionalItems !== undefined) {
+                            plan.items = this.#child(node.additionalItems, location, scope);
+                        }
+                    }
+                    else {
+                        plan.items = this.#child(value, location, scope);
+                    }
+                    break;
+                case "prefixItems":
+                    if (applicator && draft === "2020-12" && Array.isArray(value) && !Array.isArray(node.items)) {
+                        plan.prefixItems = value.map(item => this.#child(item, location, scope));
+                    }
+                    break;
+                case "unevaluatedProperties":
+                case "unevaluatedItems":
+                    if (unevaluated)
+                        plan[key] = this.#child(value, location, scope);
+                    break;
+            }
+        }
+    }
+    #properties(plan, properties, location, scope) {
+        const entries = [];
+        for (const key in properties) {
+            const value = properties[key];
+            entries.push({ key, plan: this.#child(value, location, scope), inherited: isInheritedName(key) });
+            if (isNode(value) && "default" in value) {
+                (plan.defaults ??= []).push({ key, value: value.default });
+                this.sawDefaults = true;
+            }
+        }
+        if (entries.length > 0)
+            plan.properties = entries;
+    }
+}
+const TYPE_PLANS = new Map([
+    [T_ANY, TRUE_PLAN],
+    [0, FALSE_PLAN],
+]);
+/** The shared plan of a schema constraining nothing but its type. */
+function typePlan(types) {
+    let plan = TYPE_PLANS.get(types);
+    if (plan === undefined) {
+        plan = { types, empty: false, flags: 0 };
+        TYPE_PLANS.set(types, plan);
+    }
+    return plan;
+}
+function typeFlags(value) {
+    if (typeof value === "string")
+        return TYPE_FLAGS[value] ?? T_ANY;
+    if (!Array.isArray(value))
+        return T_ANY;
+    let types = 0;
+    for (const name of value)
+        types |= typeof name === "string" ? (TYPE_FLAGS[name] ?? 0) : 0;
+    return types;
+}
+function pattern(source) {
+    try {
+        return compilePattern(source);
+    }
+    catch {
+        throw new OmpTypeError(`invalid pattern: ${source}`);
+    }
+}