toolcraft 0.0.115 → 0.0.116

package/node_modules/toolcraft-schema/dist/json-schema/evaluate.js

@@ -0,0 +1,442 @@
+import { deepEqual, invalidResult, isMultipleOf, isObject, issue, mergeResults, typeMatches, unicodeLength, validResult } from "./utils.js";
+export function evaluateSchema(graph, value) {
+    return evaluateNode(graph, graph.root, value, {
+        instancePath: [],
+        dynamicScope: [],
+        activePairs: new Map()
+    });
+}
+function evaluateNode(graph, node, value, context) {
+    if (node.schema === true) {
+        return validResult();
+    }
+    if (node.schema === false) {
+        return invalidResult(issue(context.instancePath, "valid schema", value, "must NOT be valid"));
+    }
+    const activeValues = context.activePairs.get(node);
+    if (activeValues?.has(value) === true) {
+        return validResult();
+    }
+    const nextActivePairs = new Map(context.activePairs);
+    const nextActiveValues = new Set(activeValues ?? []);
+    nextActiveValues.add(value);
+    nextActivePairs.set(node, nextActiveValues);
+    const lastScope = context.dynamicScope.at(-1);
+    const dynamicScope = lastScope?.resourceUri === node.resourceRoot.resourceUri
+        ? context.dynamicScope
+        : [...context.dynamicScope, node.resourceRoot];
+    const nextContext = { ...context, dynamicScope, activePairs: nextActivePairs };
+    const schema = node.schema;
+    const referenceResult = evaluateReferences(graph, node, schema, value, nextContext);
+    if (node.dialect === "draft7" && typeof schema.$ref === "string") {
+        return referenceResult ?? validResult();
+    }
+    const results = [];
+    if (referenceResult !== undefined) {
+        results.push(referenceResult);
+    }
+    results.push(...evaluateApplicators(graph, node, schema, value, nextContext));
+    if (node.validationVocabulary) {
+        results.push(...evaluateValidationKeywords(node, schema, value, nextContext.instancePath));
+    }
+    const merged = mergeResults(results);
+    if (isObject(value)) {
+        evaluateUnevaluatedProperties(graph, node, schema, value, nextContext, merged);
+    }
+    if (Array.isArray(value)) {
+        evaluateUnevaluatedItems(graph, node, schema, value, nextContext, merged);
+    }
+    return merged;
+}
+function evaluateReferences(graph, node, schema, value, context) {
+    const results = [];
+    if (typeof schema.$ref === "string") {
+        results.push(evaluateNode(graph, graph.resolve(node, schema.$ref), value, context));
+    }
+    if (typeof schema.$dynamicRef === "string") {
+        const staticTarget = graph.resolve(node, schema.$dynamicRef);
+        const fragment = new URL(schema.$dynamicRef, node.baseUri).hash.slice(1);
+        let target = staticTarget;
+        if (fragment !== "" &&
+            !fragment.startsWith("/") &&
+            isObject(staticTarget.schema) &&
+            staticTarget.schema.$dynamicAnchor === fragment) {
+            for (const scope of context.dynamicScope) {
+                const candidate = graph.dynamicAnchor(scope, fragment);
+                if (candidate !== undefined) {
+                    target = candidate;
+                    break;
+                }
+            }
+        }
+        results.push(evaluateNode(graph, target, value, context));
+    }
+    if (typeof schema.$recursiveRef === "string") {
+        let target = graph.resolve(node, schema.$recursiveRef);
+        if (schema.$recursiveRef === "#") {
+            for (const scope of context.dynamicScope) {
+                if (isObject(scope.schema) && scope.schema.$recursiveAnchor === true) {
+                    target = scope;
+                    break;
+                }
+            }
+        }
+        results.push(evaluateNode(graph, target, value, context));
+    }
+    return results.length === 0 ? undefined : mergeResults(results);
+}
+function evaluateApplicators(graph, node, schema, value, context) {
+    const results = [];
+    for (const keyword of ["allOf", "anyOf", "oneOf"]) {
+        const schemas = schema[keyword];
+        if (!Array.isArray(schemas)) {
+            continue;
+        }
+        const branchResults = schemas.map((_, index) => evaluateChild(graph, node, `${keyword}/${index}`, value, context));
+        if (keyword === "allOf") {
+            results.push(mergeResults(branchResults));
+        }
+        else {
+            const successful = branchResults.filter((result) => result.valid);
+            const valid = keyword === "anyOf" ? successful.length > 0 : successful.length === 1;
+            if (valid) {
+                results.push(mergeResults(successful));
+            }
+            else {
+                results.push(invalidResult(issue(context.instancePath, keyword, value, keyword === "anyOf"
+                    ? "must match a schema in anyOf"
+                    : "must match exactly one schema in oneOf")));
+            }
+        }
+    }
+    if (schema.not !== undefined) {
+        const result = evaluateChild(graph, node, "not", value, context);
+        if (result.valid) {
+            results.push(invalidResult(issue(context.instancePath, "not", value, "must NOT be valid")));
+        }
+    }
+    if (schema.if !== undefined) {
+        const condition = evaluateChild(graph, node, "if", value, context);
+        const selected = condition.valid ? "then" : "else";
+        if (condition.valid) {
+            results.push(condition);
+        }
+        if (schema[selected] !== undefined) {
+            results.push(evaluateChild(graph, node, selected, value, context));
+        }
+    }
+    if (isObject(value)) {
+        results.push(...evaluateObjectApplicators(graph, node, schema, value, context));
+    }
+    if (Array.isArray(value)) {
+        results.push(...evaluateArrayApplicators(graph, node, schema, value, context));
+    }
+    return results;
+}
+function evaluateObjectApplicators(graph, node, schema, value, context) {
+    const results = [];
+    const evaluated = new Set();
+    const properties = isObject(schema.properties) ? schema.properties : {};
+    for (const key of Object.keys(properties)) {
+        if (Object.prototype.hasOwnProperty.call(value, key)) {
+            const result = evaluateChild(graph, node, `properties/${key}`, value[key], childContext(context, key));
+            evaluated.add(key);
+            results.push(markProperty(atChildLocation(result), key));
+        }
+    }
+    const patternProperties = isObject(schema.patternProperties) ? schema.patternProperties : {};
+    for (const [pattern] of Object.entries(patternProperties)) {
+        const expression = new RegExp(pattern, "u");
+        for (const [key, propertyValue] of Object.entries(value)) {
+            if (expression.test(key)) {
+                const result = evaluateChild(graph, node, `patternProperties/${pattern}`, propertyValue, childContext(context, key));
+                evaluated.add(key);
+                results.push(markProperty(atChildLocation(result), key));
+            }
+        }
+    }
+    if (schema.additionalProperties !== undefined) {
+        for (const [key, propertyValue] of Object.entries(value)) {
+            if (!evaluated.has(key)) {
+                const result = evaluateChild(graph, node, "additionalProperties", propertyValue, childContext(context, key));
+                results.push(markProperty(atChildLocation(result), key));
+            }
+        }
+    }
+    if (schema.propertyNames !== undefined) {
+        for (const key of Object.keys(value)) {
+            results.push(atChildLocation(evaluateChild(graph, node, "propertyNames", key, childContext(context, key))));
+        }
+    }
+    const dependentSchemas = isObject(schema.dependentSchemas) ? schema.dependentSchemas : {};
+    for (const key of Object.keys(dependentSchemas)) {
+        if (Object.prototype.hasOwnProperty.call(value, key)) {
+            results.push(evaluateChild(graph, node, `dependentSchemas/${key}`, value, context));
+        }
+    }
+    if (node.dialect === "draft7" && isObject(schema.dependencies)) {
+        for (const [key, dependency] of Object.entries(schema.dependencies)) {
+            if (Object.prototype.hasOwnProperty.call(value, key) && !Array.isArray(dependency)) {
+                results.push(evaluateInline(graph, node, dependency, value, context, `dependencies/${key}`));
+            }
+        }
+    }
+    return results;
+}
+function evaluateArrayApplicators(graph, node, schema, value, context) {
+    const results = [];
+    if (node.dialect === "draft2020-12") {
+        const prefixItems = Array.isArray(schema.prefixItems) ? schema.prefixItems : [];
+        prefixItems.forEach((_, index) => {
+            if (index < value.length) {
+                const result = evaluateChild(graph, node, `prefixItems/${index}`, value[index], childContext(context, String(index)));
+                results.push(markItem(atChildLocation(result), index));
+            }
+        });
+        if (schema.items !== undefined && !Array.isArray(schema.items)) {
+            for (let index = prefixItems.length; index < value.length; index += 1) {
+                const result = evaluateChild(graph, node, "items", value[index], childContext(context, String(index)));
+                results.push(markItem(atChildLocation(result), index));
+            }
+        }
+    }
+    else if (Array.isArray(schema.items)) {
+        schema.items.forEach((_, index) => {
+            if (index < value.length) {
+                const result = evaluateChild(graph, node, `items/${index}`, value[index], childContext(context, String(index)));
+                results.push(markItem(atChildLocation(result), index));
+            }
+        });
+        if (schema.additionalItems !== undefined) {
+            for (let index = schema.items.length; index < value.length; index += 1) {
+                const result = evaluateChild(graph, node, "additionalItems", value[index], childContext(context, String(index)));
+                results.push(markItem(atChildLocation(result), index));
+            }
+        }
+    }
+    else if (schema.items !== undefined) {
+        for (let index = 0; index < value.length; index += 1) {
+            const result = evaluateChild(graph, node, "items", value[index], childContext(context, String(index)));
+            results.push(markItem(atChildLocation(result), index));
+        }
+    }
+    if (schema.contains !== undefined) {
+        const containsResults = value.map((item, index) => evaluateChild(graph, node, "contains", item, childContext(context, String(index))));
+        const matching = containsResults
+            .map((result, index) => ({ result, index }))
+            .filter(({ result }) => result.valid);
+        const minimum = node.dialect === "draft2020-12" && typeof schema.minContains === "number"
+            ? schema.minContains
+            : 1;
+        const maximum = node.dialect === "draft2020-12" && typeof schema.maxContains === "number"
+            ? schema.maxContains
+            : Number.POSITIVE_INFINITY;
+        if (matching.length < minimum || matching.length > maximum) {
+            results.push(invalidResult(issue(context.instancePath, "contains", value, "must contain required matching items")));
+        }
+        else if (node.dialect === "draft2020-12") {
+            const result = validResult();
+            for (const match of matching) {
+                result.evaluatedItems.add(match.index);
+            }
+            results.push(result);
+        }
+    }
+    return results;
+}
+function evaluateValidationKeywords(node, schema, value, path) {
+    const results = [];
+    if (schema.nullable === true && value === null) {
+        return results;
+    }
+    const types = typeof schema.type === "string" ? [schema.type] : Array.isArray(schema.type) ? schema.type : [];
+    if (types.length > 0 &&
+        !types.some((type) => typeof type === "string" && typeMatches(type, value))) {
+        results.push(invalidResult(issue(path, types.join(","), value, `must be ${types.join(",")}`)));
+        return results;
+    }
+    if (schema.const !== undefined && !deepEqual(schema.const, value)) {
+        results.push(invalidResult(issue(path, "const", value, "must be equal to constant")));
+    }
+    if (Array.isArray(schema.enum) && !schema.enum.some((entry) => deepEqual(entry, value))) {
+        results.push(invalidResult(issue(path, "enum", value, "must be equal to one of the allowed values")));
+    }
+    if (typeof value === "number" && Number.isFinite(value)) {
+        evaluateNumberKeywords(schema, value, path, results);
+    }
+    if (typeof value === "string") {
+        evaluateStringKeywords(schema, value, path, results);
+    }
+    if (Array.isArray(value)) {
+        evaluateArrayKeywords(schema, value, path, results);
+    }
+    if (isObject(value)) {
+        evaluateObjectKeywords(node, schema, value, path, results);
+    }
+    return results;
+}
+function evaluateNumberKeywords(schema, value, path, results) {
+    if (typeof schema.multipleOf === "number" && !isMultipleOf(value, schema.multipleOf)) {
+        results.push(invalidResult(issue(path, `multiple of ${schema.multipleOf}`, value, `must be multiple of ${schema.multipleOf}`)));
+    }
+    if (typeof schema.maximum === "number" && value > schema.maximum) {
+        results.push(invalidResult(issue(path, `<= ${schema.maximum}`, value, `must be <= ${schema.maximum}`)));
+    }
+    if (typeof schema.minimum === "number" && value < schema.minimum) {
+        results.push(invalidResult(issue(path, `>= ${schema.minimum}`, value, `must be >= ${schema.minimum}`)));
+    }
+    if (typeof schema.exclusiveMaximum === "number" && value >= schema.exclusiveMaximum) {
+        results.push(invalidResult(issue(path, `< ${schema.exclusiveMaximum}`, value, `must be < ${schema.exclusiveMaximum}`)));
+    }
+    if (typeof schema.exclusiveMinimum === "number" && value <= schema.exclusiveMinimum) {
+        results.push(invalidResult(issue(path, `> ${schema.exclusiveMinimum}`, value, `must be > ${schema.exclusiveMinimum}`)));
+    }
+}
+function evaluateStringKeywords(schema, value, path, results) {
+    const length = unicodeLength(value);
+    if (typeof schema.maxLength === "number" && length > schema.maxLength) {
+        results.push(invalidResult(issue(path, `length <= ${schema.maxLength}`, value, `must NOT have more than ${schema.maxLength} characters`)));
+    }
+    if (typeof schema.minLength === "number" && length < schema.minLength) {
+        results.push(invalidResult(issue(path, `length >= ${schema.minLength}`, value, `must NOT have fewer than ${schema.minLength} characters`)));
+    }
+    if (typeof schema.pattern === "string" && !new RegExp(schema.pattern, "u").test(value)) {
+        results.push(invalidResult(issue(path, `pattern ${schema.pattern}`, value, `must match pattern ${schema.pattern}`)));
+    }
+}
+function evaluateArrayKeywords(schema, value, path, results) {
+    if (typeof schema.maxItems === "number" && value.length > schema.maxItems) {
+        results.push(invalidResult(issue(path, `items <= ${schema.maxItems}`, value, `must NOT have more than ${schema.maxItems} items`)));
+    }
+    if (typeof schema.minItems === "number" && value.length < schema.minItems) {
+        results.push(invalidResult(issue(path, `items >= ${schema.minItems}`, value, `must NOT have fewer than ${schema.minItems} items`)));
+    }
+    if (schema.uniqueItems === true) {
+        for (let left = 0; left < value.length; left += 1) {
+            for (let right = left + 1; right < value.length; right += 1) {
+                if (deepEqual(value[left], value[right])) {
+                    results.push(invalidResult(issue(path, "unique items", value, "must NOT have duplicate items")));
+                    return;
+                }
+            }
+        }
+    }
+}
+function evaluateObjectKeywords(node, schema, value, path, results) {
+    const keys = Object.keys(value);
+    if (typeof schema.maxProperties === "number" && keys.length > schema.maxProperties) {
+        results.push(invalidResult(issue(path, `properties <= ${schema.maxProperties}`, value, `must NOT have more than ${schema.maxProperties} properties`)));
+    }
+    if (typeof schema.minProperties === "number" && keys.length < schema.minProperties) {
+        results.push(invalidResult(issue(path, `properties >= ${schema.minProperties}`, value, `must NOT have fewer than ${schema.minProperties} properties`)));
+    }
+    if (Array.isArray(schema.required)) {
+        for (const key of schema.required) {
+            if (typeof key === "string" && !Object.prototype.hasOwnProperty.call(value, key)) {
+                results.push(invalidResult(issue([...path, key], "required", undefined, `must have required property '${key}'`)));
+            }
+        }
+    }
+    const dependentRequired = isObject(schema.dependentRequired) ? schema.dependentRequired : {};
+    for (const [key, dependencies] of Object.entries(dependentRequired)) {
+        if (Object.prototype.hasOwnProperty.call(value, key) && Array.isArray(dependencies)) {
+            addMissingDependencies(value, dependencies, path, results);
+        }
+    }
+    if (node.dialect === "draft7" && isObject(schema.dependencies)) {
+        for (const [key, dependencies] of Object.entries(schema.dependencies)) {
+            if (Object.prototype.hasOwnProperty.call(value, key) && Array.isArray(dependencies)) {
+                addMissingDependencies(value, dependencies, path, results);
+            }
+        }
+    }
+}
+function addMissingDependencies(value, dependencies, path, results) {
+    for (const dependency of dependencies) {
+        if (typeof dependency === "string" &&
+            !Object.prototype.hasOwnProperty.call(value, dependency)) {
+            results.push(invalidResult(issue([...path, dependency], "dependency", undefined, `must have property '${dependency}'`)));
+        }
+    }
+}
+function evaluateUnevaluatedProperties(graph, node, schema, value, context, result) {
+    if (node.dialect !== "draft2020-12" || schema.unevaluatedProperties === undefined) {
+        return;
+    }
+    for (const [key, propertyValue] of Object.entries(value)) {
+        if (!result.evaluatedProperties.has(key)) {
+            const propertyResult = evaluateChild(graph, node, "unevaluatedProperties", propertyValue, childContext(context, key));
+            propertyResult.evaluatedProperties.add(key);
+            mergeInto(result, propertyResult);
+        }
+    }
+}
+function evaluateUnevaluatedItems(graph, node, schema, value, context, result) {
+    if (node.dialect !== "draft2020-12" || schema.unevaluatedItems === undefined) {
+        return;
+    }
+    for (let index = 0; index < value.length; index += 1) {
+        if (!result.evaluatedItems.has(index)) {
+            const itemResult = evaluateChild(graph, node, "unevaluatedItems", value[index], childContext(context, String(index)));
+            itemResult.evaluatedItems.add(index);
+            mergeInto(result, itemResult);
+        }
+    }
+}
+function evaluateChild(graph, node, key, value, context) {
+    const child = node.children.get(key);
+    if (child === undefined) {
+        return validResult();
+    }
+    return evaluateNode(graph, child, value, context);
+}
+function evaluateInline(graph, node, schema, value, context, key) {
+    const child = node.children.get(key);
+    if (child !== undefined) {
+        return evaluateNode(graph, child, value, context);
+    }
+    if (typeof schema !== "boolean" && !isObject(schema)) {
+        return validResult();
+    }
+    const inlineNode = {
+        schema: schema,
+        documentId: node.documentId,
+        dialect: node.dialect,
+        baseUri: node.baseUri,
+        resourceUri: node.resourceUri,
+        resourceRoot: node.resourceRoot,
+        pointer: node.pointer,
+        validationVocabulary: node.validationVocabulary,
+        children: new Map()
+    };
+    return evaluateNode(graph, inlineNode, value, context);
+}
+function childContext(context, segment) {
+    return { ...context, instancePath: [...context.instancePath, segment] };
+}
+function mergeInto(target, source) {
+    target.valid &&= source.valid;
+    target.issues.push(...source.issues);
+    for (const key of source.evaluatedProperties) {
+        target.evaluatedProperties.add(key);
+    }
+    for (const index of source.evaluatedItems) {
+        target.evaluatedItems.add(index);
+    }
+}
+function atChildLocation(result) {
+    return {
+        valid: result.valid,
+        issues: result.issues,
+        evaluatedProperties: new Set(),
+        evaluatedItems: new Set()
+    };
+}
+function markProperty(result, key) {
+    result.evaluatedProperties.add(key);
+    return result;
+}
+function markItem(result, index) {
+    result.evaluatedItems.add(index);
+    return result;
+}

package/node_modules/toolcraft-schema/dist/json-schema/index.d.ts

@@ -0,0 +1,5 @@
+import type { ValidationIssue } from "../validate.js";
+import type { CompileJsonSchemaOptions, CompiledJsonSchema } from "./types.js";
+export type { CompileJsonSchemaOptions, CompiledJsonSchema } from "./types.js";
+export declare function compileJsonSchema(schema: unknown, options?: CompileJsonSchemaOptions): CompiledJsonSchema;
+export declare function formatIssues(issues: readonly ValidationIssue[]): string;

package/node_modules/toolcraft-schema/dist/json-schema/index.js

@@ -0,0 +1,19 @@
+import { compileGraph } from "./compiler.js";
+import { evaluateSchema } from "./evaluate.js";
+export function compileJsonSchema(schema, options = {}) {
+    const graph = compileGraph(schema, options);
+    return {
+        validate(value) {
+            const result = evaluateSchema(graph, value);
+            return result.valid ? { ok: true, value } : { ok: false, issues: result.issues };
+        }
+    };
+}
+export function formatIssues(issues) {
+    return issues
+        .map((current) => {
+        const path = current.path.length === 0 ? "data" : `data/${current.path.join("/")}`;
+        return `${path} ${current.message}`;
+    })
+        .join(", ");
+}

package/node_modules/toolcraft-schema/dist/json-schema/types.d.ts

@@ -0,0 +1,33 @@
+import type { ValidationIssue, ValidationResult } from "../validate.js";
+export type JsonSchemaRegistry = Record<string, unknown>;
+export interface CompileJsonSchemaOptions {
+    registry?: JsonSchemaRegistry;
+}
+export interface CompiledJsonSchema {
+    validate(value: unknown): ValidationResult<unknown>;
+}
+export type Dialect = "draft7" | "draft2020-12";
+export type SchemaObject = Record<string, unknown>;
+export type JsonSchema = boolean | SchemaObject;
+export interface SchemaNode {
+    schema: JsonSchema;
+    documentId: string;
+    dialect: Dialect;
+    baseUri: string;
+    resourceUri: string;
+    resourceRoot: SchemaNode;
+    pointer: string;
+    validationVocabulary: boolean;
+    children: Map<string, SchemaNode>;
+}
+export interface EvaluationResult {
+    valid: boolean;
+    issues: ValidationIssue[];
+    evaluatedProperties: Set<string>;
+    evaluatedItems: Set<number>;
+}
+export interface EvaluationContext {
+    instancePath: readonly string[];
+    dynamicScope: readonly SchemaNode[];
+    activePairs: Map<SchemaNode, Set<unknown>>;
+}

package/node_modules/toolcraft-schema/dist/json-schema/types.js

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

package/node_modules/toolcraft-schema/dist/json-schema/utils.d.ts

@@ -0,0 +1,19 @@
+import type { ValidationIssue } from "../validate.js";
+import type { Dialect, EvaluationResult, JsonSchema, SchemaObject } from "./types.js";
+export declare function isSchema(value: unknown): value is JsonSchema;
+export declare function isObject(value: unknown): value is SchemaObject;
+export declare function dialectFor(schema: SchemaObject, inherited: Dialect): Dialect;
+export declare function resolveUri(reference: string, baseUri: string): string;
+export declare function withoutFragment(uri: string): string;
+export declare function fragmentOf(uri: string): string;
+export declare function escapePointer(value: string): string;
+export declare function decodePointer(value: string): string;
+export declare function deepEqual(left: unknown, right: unknown): boolean;
+export declare function receivedType(value: unknown): string;
+export declare function issue(path: readonly string[], expected: string, value: unknown, message: string, keyword?: string): ValidationIssue;
+export declare function validResult(): EvaluationResult;
+export declare function invalidResult(problem: ValidationIssue): EvaluationResult;
+export declare function mergeResults(results: readonly EvaluationResult[]): EvaluationResult;
+export declare function typeMatches(type: string, value: unknown): boolean;
+export declare function unicodeLength(value: string): number;
+export declare function isMultipleOf(value: number, divisor: number): boolean;