@maroonedog/luq 0.1.2-alpha → 2.0.0

package/dist/json-schema/keyword-map-string.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringKeywordMap = exports.contentMediaTypeBinding = exports.contentEncodingBinding = exports.patternBinding = exports.maxLengthBinding = exports.minLengthBinding = void 0;
+// ===========================================================================
+// L8  src/json-schema/keyword-map-string.ts — the six string keywords.
+//
+// `format` is the only structural one, and it is structural for a reason worth
+// stating: its VALUE selects the binding. One keyword, twenty possible chain
+// methods. The selection lives in format-map.ts, which is the single format
+// table in this repository — 1.x shipped three of them and they disagreed
+// (docs/legacy-spec/json-schema-mapping.md records the disagreements).
+// ===========================================================================
+const bind_keyword_1 = require("./bind-keyword");
+const string_min_1 = require("../plugins/string-min");
+const string_max_1 = require("../plugins/string-max");
+const string_pattern_1 = require("../plugins/string-pattern");
+const string_content_encoding_1 = require("../plugins/string-content-encoding");
+const string_content_media_type_1 = require("../plugins/string-content-media-type");
+exports.minLengthBinding = (0, bind_keyword_1.bindKeyword)("string", "min", string_min_1.stringMinPlugin, (v) => [v]);
+exports.maxLengthBinding = (0, bind_keyword_1.bindKeyword)("string", "max", string_max_1.stringMaxPlugin, (v) => [v]);
+/**
+ * Draft-07 spells `pattern` as an ECMA-262 SOURCE string; the plugin accepts a
+ * RegExp and only a RegExp, because 1.x's `new RegExp(source)` at the call site
+ * dropped flags silently and gave the caller no compile-time check. Compiling
+ * the schema's string therefore happens HERE, once, and nowhere else.
+ */
+exports.patternBinding = (0, bind_keyword_1.bindKeyword)("string", "pattern", string_pattern_1.stringPatternPlugin, (v) => [new RegExp(v)]);
+/**
+ * The value type is `ContentEncodingName`, not `string`: an encoding the
+ * plugin does not know must be refused by the converter rather than accepted
+ * silently, and the compiler is what forces that narrowing to happen.
+ */
+exports.contentEncodingBinding = (0, bind_keyword_1.bindKeyword)("string", "contentEncoding", string_content_encoding_1.stringContentEncodingPlugin, (v) => [v]);
+exports.contentMediaTypeBinding = (0, bind_keyword_1.bindKeyword)("string", "contentMediaType", string_content_media_type_1.stringContentMediaTypePlugin, (v) => [v]);
+exports.stringKeywordMap = {
+    maxLength: exports.maxLengthBinding,
+    minLength: exports.minLengthBinding,
+    pattern: exports.patternBinding,
+    format: (0, bind_keyword_1.structural)("the keyword's VALUE selects which of the sixteen format plugins runs; " +
+        "see format-map.ts, the only format table in src. An unknown format " +
+        "name is an annotation and passes, which is what Draft-07 §7.2 requires"),
+    contentEncoding: exports.contentEncodingBinding,
+    contentMediaType: exports.contentMediaTypeBinding,
+};

package/dist/json-schema/keyword-map-string.mjs

@@ -0,0 +1,41 @@
+// ===========================================================================
+// L8  src/json-schema/keyword-map-string.ts — the six string keywords.
+//
+// `format` is the only structural one, and it is structural for a reason worth
+// stating: its VALUE selects the binding. One keyword, twenty possible chain
+// methods. The selection lives in format-map.ts, which is the single format
+// table in this repository — 1.x shipped three of them and they disagreed
+// (docs/legacy-spec/json-schema-mapping.md records the disagreements).
+// ===========================================================================
+import { bindKeyword, structural } from "./bind-keyword.mjs";
+import { stringMinPlugin } from "../plugins/string-min/index.mjs";
+import { stringMaxPlugin } from "../plugins/string-max/index.mjs";
+import { stringPatternPlugin } from "../plugins/string-pattern/index.mjs";
+import { stringContentEncodingPlugin, } from "../plugins/string-content-encoding/index.mjs";
+import { stringContentMediaTypePlugin } from "../plugins/string-content-media-type/index.mjs";
+export const minLengthBinding = bindKeyword("string", "min", stringMinPlugin, (v) => [v]);
+export const maxLengthBinding = bindKeyword("string", "max", stringMaxPlugin, (v) => [v]);
+/**
+ * Draft-07 spells `pattern` as an ECMA-262 SOURCE string; the plugin accepts a
+ * RegExp and only a RegExp, because 1.x's `new RegExp(source)` at the call site
+ * dropped flags silently and gave the caller no compile-time check. Compiling
+ * the schema's string therefore happens HERE, once, and nowhere else.
+ */
+export const patternBinding = bindKeyword("string", "pattern", stringPatternPlugin, (v) => [new RegExp(v)]);
+/**
+ * The value type is `ContentEncodingName`, not `string`: an encoding the
+ * plugin does not know must be refused by the converter rather than accepted
+ * silently, and the compiler is what forces that narrowing to happen.
+ */
+export const contentEncodingBinding = bindKeyword("string", "contentEncoding", stringContentEncodingPlugin, (v) => [v]);
+export const contentMediaTypeBinding = bindKeyword("string", "contentMediaType", stringContentMediaTypePlugin, (v) => [v]);
+export const stringKeywordMap = {
+    maxLength: maxLengthBinding,
+    minLength: minLengthBinding,
+    pattern: patternBinding,
+    format: structural("the keyword's VALUE selects which of the sixteen format plugins runs; " +
+        "see format-map.ts, the only format table in src. An unknown format " +
+        "name is an annotation and passes, which is what Draft-07 §7.2 requires"),
+    contentEncoding: contentEncodingBinding,
+    contentMediaType: contentMediaTypeBinding,
+};

package/dist/json-schema/keyword-map.d.ts

@@ -0,0 +1,32 @@
+import type { AnyKeywordHandling, KeywordTable } from "./keyword-binding.types";
+import type { Draft07Keyword } from "./draft07-keyword-value.types";
+export declare const draft07KeywordMap: KeywordTable<Draft07Keyword>;
+/**
+ * Keywords Luq recognises the NAME of but which are not Draft-07. They are
+ * listed so that "we did not implement it" and "it is not in this dialect"
+ * stay different answers. `$defs` is the one exception that still does
+ * something: resolve-ref follows it, because a 2019-09 document's pointers
+ * would otherwise dangle.
+ */
+export declare const NON_DRAFT07_KEYWORDS: Readonly<Record<string, string>>;
+export declare function isDraft07Keyword(keyword: string): keyword is Draft07Keyword;
+/** Every keyword the table decides on. No assertion; the guard narrows. */
+export declare function listDraft07Keywords(): readonly Draft07Keyword[];
+/** `undefined` = not a Draft-07 keyword at all. See NON_DRAFT07_KEYWORDS. */
+export declare function findKeywordHandling(keyword: string): AnyKeywordHandling | undefined;
+/** Throws for a keyword the table declares out of scope. Never silent. */
+export declare function assertKeywordSupported(keyword: string): void;
+/**
+ * Every plugin the two tables bind, de-duplicated and sorted. Step 26 GENERATES
+ * the full-feature bundle's use() list from this, so the bundle cannot name a
+ * plugin that is not bound, and cannot omit one that is.
+ */
+export declare function listBoundPluginNames(): readonly string[];
+export interface KeywordHandlingCounts {
+    readonly bind: number;
+    readonly structural: number;
+    readonly unsupported: number;
+    readonly total: number;
+}
+/** Counted, never asserted: the published numbers come from this function. */
+export declare function countKeywordHandlings(table: Readonly<Record<string, AnyKeywordHandling>>): KeywordHandlingCounts;

package/dist/json-schema/keyword-map.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NON_DRAFT07_KEYWORDS = exports.draft07KeywordMap = void 0;
+exports.isDraft07Keyword = isDraft07Keyword;
+exports.listDraft07Keywords = listDraft07Keywords;
+exports.findKeywordHandling = findKeywordHandling;
+exports.assertKeywordSupported = assertKeywordSupported;
+exports.listBoundPluginNames = listBoundPluginNames;
+exports.countKeywordHandlings = countKeywordHandlings;
+const keyword_map_core_1 = require("./keyword-map-core");
+const keyword_map_number_1 = require("./keyword-map-number");
+const keyword_map_string_1 = require("./keyword-map-string");
+const keyword_map_array_1 = require("./keyword-map-array");
+const keyword_map_object_1 = require("./keyword-map-object");
+const format_map_1 = require("./format-map");
+const unsupported_keyword_error_1 = require("./unsupported-keyword-error");
+exports.draft07KeywordMap = {
+    ...keyword_map_core_1.coreKeywordMap,
+    ...keyword_map_number_1.numberKeywordMap,
+    ...keyword_map_string_1.stringKeywordMap,
+    ...keyword_map_array_1.arrayKeywordMap,
+    ...keyword_map_object_1.objectKeywordMap,
+};
+/**
+ * Keywords Luq recognises the NAME of but which are not Draft-07. They are
+ * listed so that "we did not implement it" and "it is not in this dialect"
+ * stay different answers. `$defs` is the one exception that still does
+ * something: resolve-ref follows it, because a 2019-09 document's pointers
+ * would otherwise dangle.
+ */
+exports.NON_DRAFT07_KEYWORDS = {
+    $defs: "2019-09 spelling of `definitions`; resolve-ref follows it anyway",
+    $anchor: "2019-09 anchors; resolve-ref resolves JSON Pointers only",
+    $dynamicRef: "2020-12 dynamic references",
+    $recursiveRef: "2019-09 recursive references",
+    dependentRequired: "2019-09 split of `dependencies`; use `dependencies`",
+    dependentSchemas: "2019-09 split of `dependencies`; use `dependencies`",
+    unevaluatedItems: "2019-09; no annotation-collection model in Luq",
+    unevaluatedProperties: "2019-09; no annotation-collection model in Luq",
+    contentSchema: "2019-09 companion to contentMediaType",
+    deprecated: "2019-09 annotation",
+    prefixItems: "2020-12 spelling of the tuple form of `items`",
+};
+function isDraft07Keyword(keyword) {
+    return Object.prototype.hasOwnProperty.call(exports.draft07KeywordMap, keyword);
+}
+/** Every keyword the table decides on. No assertion; the guard narrows. */
+function listDraft07Keywords() {
+    return Object.keys(exports.draft07KeywordMap).filter(isDraft07Keyword);
+}
+/** `undefined` = not a Draft-07 keyword at all. See NON_DRAFT07_KEYWORDS. */
+function findKeywordHandling(keyword) {
+    return isDraft07Keyword(keyword) ? exports.draft07KeywordMap[keyword] : undefined;
+}
+/** Throws for a keyword the table declares out of scope. Never silent. */
+function assertKeywordSupported(keyword) {
+    const handling = findKeywordHandling(keyword);
+    if (handling === undefined) {
+        const note = exports.NON_DRAFT07_KEYWORDS[keyword];
+        throw new unsupported_keyword_error_1.UnsupportedKeywordError(keyword, note ?? "not a Draft-07 keyword");
+    }
+    if (handling.handling === "unsupported") {
+        throw new unsupported_keyword_error_1.UnsupportedKeywordError(keyword, handling.reason);
+    }
+}
+/**
+ * Every plugin the two tables bind, de-duplicated and sorted. Step 26 GENERATES
+ * the full-feature bundle's use() list from this, so the bundle cannot name a
+ * plugin that is not bound, and cannot omit one that is.
+ */
+function listBoundPluginNames() {
+    const names = new Set();
+    const handlings = [
+        ...Object.values(exports.draft07KeywordMap),
+        ...Object.values(format_map_1.draft07FormatMap),
+    ];
+    for (const handling of handlings) {
+        if (handling.handling === "bind")
+            names.add(handling.pluginName);
+    }
+    return [...names].sort();
+}
+/** Counted, never asserted: the published numbers come from this function. */
+function countKeywordHandlings(table) {
+    const entries = Object.values(table);
+    const countOf = (kind) => entries.filter((handling) => handling.handling === kind).length;
+    return {
+        bind: countOf("bind"),
+        structural: countOf("structural"),
+        unsupported: countOf("unsupported"),
+        total: entries.length,
+    };
+}

package/dist/json-schema/keyword-map.mjs

@@ -0,0 +1,84 @@
+import { coreKeywordMap } from "./keyword-map-core.mjs";
+import { numberKeywordMap } from "./keyword-map-number.mjs";
+import { stringKeywordMap } from "./keyword-map-string.mjs";
+import { arrayKeywordMap } from "./keyword-map-array.mjs";
+import { objectKeywordMap } from "./keyword-map-object.mjs";
+import { draft07FormatMap } from "./format-map.mjs";
+import { UnsupportedKeywordError } from "./unsupported-keyword-error.mjs";
+export const draft07KeywordMap = {
+    ...coreKeywordMap,
+    ...numberKeywordMap,
+    ...stringKeywordMap,
+    ...arrayKeywordMap,
+    ...objectKeywordMap,
+};
+/**
+ * Keywords Luq recognises the NAME of but which are not Draft-07. They are
+ * listed so that "we did not implement it" and "it is not in this dialect"
+ * stay different answers. `$defs` is the one exception that still does
+ * something: resolve-ref follows it, because a 2019-09 document's pointers
+ * would otherwise dangle.
+ */
+export const NON_DRAFT07_KEYWORDS = {
+    $defs: "2019-09 spelling of `definitions`; resolve-ref follows it anyway",
+    $anchor: "2019-09 anchors; resolve-ref resolves JSON Pointers only",
+    $dynamicRef: "2020-12 dynamic references",
+    $recursiveRef: "2019-09 recursive references",
+    dependentRequired: "2019-09 split of `dependencies`; use `dependencies`",
+    dependentSchemas: "2019-09 split of `dependencies`; use `dependencies`",
+    unevaluatedItems: "2019-09; no annotation-collection model in Luq",
+    unevaluatedProperties: "2019-09; no annotation-collection model in Luq",
+    contentSchema: "2019-09 companion to contentMediaType",
+    deprecated: "2019-09 annotation",
+    prefixItems: "2020-12 spelling of the tuple form of `items`",
+};
+export function isDraft07Keyword(keyword) {
+    return Object.prototype.hasOwnProperty.call(draft07KeywordMap, keyword);
+}
+/** Every keyword the table decides on. No assertion; the guard narrows. */
+export function listDraft07Keywords() {
+    return Object.keys(draft07KeywordMap).filter(isDraft07Keyword);
+}
+/** `undefined` = not a Draft-07 keyword at all. See NON_DRAFT07_KEYWORDS. */
+export function findKeywordHandling(keyword) {
+    return isDraft07Keyword(keyword) ? draft07KeywordMap[keyword] : undefined;
+}
+/** Throws for a keyword the table declares out of scope. Never silent. */
+export function assertKeywordSupported(keyword) {
+    const handling = findKeywordHandling(keyword);
+    if (handling === undefined) {
+        const note = NON_DRAFT07_KEYWORDS[keyword];
+        throw new UnsupportedKeywordError(keyword, note ?? "not a Draft-07 keyword");
+    }
+    if (handling.handling === "unsupported") {
+        throw new UnsupportedKeywordError(keyword, handling.reason);
+    }
+}
+/**
+ * Every plugin the two tables bind, de-duplicated and sorted. Step 26 GENERATES
+ * the full-feature bundle's use() list from this, so the bundle cannot name a
+ * plugin that is not bound, and cannot omit one that is.
+ */
+export function listBoundPluginNames() {
+    const names = new Set();
+    const handlings = [
+        ...Object.values(draft07KeywordMap),
+        ...Object.values(draft07FormatMap),
+    ];
+    for (const handling of handlings) {
+        if (handling.handling === "bind")
+            names.add(handling.pluginName);
+    }
+    return [...names].sort();
+}
+/** Counted, never asserted: the published numbers come from this function. */
+export function countKeywordHandlings(table) {
+    const entries = Object.values(table);
+    const countOf = (kind) => entries.filter((handling) => handling.handling === kind).length;
+    return {
+        bind: countOf("bind"),
+        structural: countOf("structural"),
+        unsupported: countOf("unsupported"),
+        total: entries.length,
+    };
+}

package/dist/json-schema/resolve-ref.d.ts

@@ -0,0 +1,16 @@
+import type { Draft07Schema } from "./draft07.types";
+export declare class RefResolutionError extends Error {
+    readonly ref: string;
+    constructor(ref: string, reason: string);
+}
+/**
+ * Resolves `ref` against `root`, then keeps following `$ref` until it reaches
+ * a schema that is not one. `visited` holds the pointers already entered on
+ * THIS chain, so `a -> b -> a` throws instead of looping forever.
+ */
+export declare function resolveRef(ref: string, root: Draft07Schema): Draft07Schema;
+/**
+ * True when `ref` resolves without leaving the document and without entering a
+ * cycle. It answers the question without making the caller catch to find out.
+ */
+export declare function isResolvableRef(ref: string, root: Draft07Schema): boolean;

package/dist/json-schema/resolve-ref.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RefResolutionError = void 0;
+exports.resolveRef = resolveRef;
+exports.isResolvableRef = isResolvableRef;
+const draft07_types_1 = require("./draft07.types");
+const types_1 = require("../types");
+class RefResolutionError extends Error {
+    constructor(ref, reason) {
+        super(`Cannot resolve $ref "${ref}": ${reason}`);
+        this.name = "RefResolutionError";
+        this.ref = ref;
+        // Without this, `instanceof` fails when the package is compiled to ES5.
+        Object.setPrototypeOf(this, RefResolutionError.prototype);
+    }
+}
+exports.RefResolutionError = RefResolutionError;
+/** No legitimate document chains this many `$ref`s. See resolveRef. */
+const MAX_REF_HOPS = 1000;
+/** RFC 6901: `~1` is "/" and `~0` is "~", decoded in that order. */
+function decodePointerToken(token) {
+    return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function toPointerTokens(ref) {
+    const pointer = ref.slice(1);
+    if (pointer === "" || pointer === "/")
+        return [];
+    return pointer.split("/").slice(1).map(decodePointerToken);
+}
+/**
+ * `definitions` and `$defs` are the same container to a pointer: a Draft-07
+ * document spells it one way, a 2019-09 document the other, and a schema that
+ * mixes them (they exist) must still resolve. A real `definitions` member
+ * always wins, so a property literally named "definitions" is unaffected.
+ */
+function stepInto(current, token) {
+    if ((0, types_1.isArray)(current))
+        return current[Number(token)];
+    if (!(0, types_1.isPlainObject)(current))
+        return undefined;
+    if (token === "definitions" || token === "$defs") {
+        return current["definitions"] ?? current["$defs"];
+    }
+    return current[token];
+}
+function followPointer(ref, root) {
+    let current = root;
+    for (const token of toPointerTokens(ref)) {
+        current = stepInto(current, token);
+        if (current === undefined) {
+            throw new RefResolutionError(ref, `no schema at segment "${token}"`);
+        }
+    }
+    if (!(0, draft07_types_1.isDraft07Schema)(current)) {
+        throw new RefResolutionError(ref, "the target is not a schema");
+    }
+    return current;
+}
+/**
+ * Resolves `ref` against `root`, then keeps following `$ref` until it reaches
+ * a schema that is not one. `visited` holds the pointers already entered on
+ * THIS chain, so `a -> b -> a` throws instead of looping forever.
+ */
+function resolveRef(ref, root) {
+    const visited = new Set();
+    let currentRef = ref;
+    for (let hop = 0;; hop += 1) {
+        // The visited set is the real cycle detector and gives the good message.
+        // This bound is the SECOND line: a synchronous infinite loop cannot be
+        // interrupted by a test timeout, so a defect in the detector above must
+        // still terminate. Measured: removing the visited check without this made
+        // the resolver hang the whole test process instead of failing it.
+        if (hop > MAX_REF_HOPS) {
+            throw new RefResolutionError(ref, `more than ${MAX_REF_HOPS} $ref hops`);
+        }
+        if (!currentRef.startsWith("#")) {
+            throw new RefResolutionError(currentRef, "external references are not supported");
+        }
+        if (visited.has(currentRef)) {
+            throw new RefResolutionError(ref, `circular reference: ${[...visited, currentRef].join(" -> ")}`);
+        }
+        visited.add(currentRef);
+        const target = followPointer(currentRef, root);
+        if (!(0, draft07_types_1.isSchemaObject)(target) || target.$ref === undefined)
+            return target;
+        currentRef = target.$ref;
+    }
+}
+/**
+ * True when `ref` resolves without leaving the document and without entering a
+ * cycle. It answers the question without making the caller catch to find out.
+ */
+function isResolvableRef(ref, root) {
+    try {
+        resolveRef(ref, root);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof RefResolutionError)
+            return false;
+        throw error;
+    }
+}

package/dist/json-schema/resolve-ref.mjs

@@ -0,0 +1,97 @@
+import { isDraft07Schema, isSchemaObject } from "./draft07.types.mjs";
+import { isArray, isPlainObject } from "../types/index.mjs";
+export class RefResolutionError extends Error {
+    constructor(ref, reason) {
+        super(`Cannot resolve $ref "${ref}": ${reason}`);
+        this.name = "RefResolutionError";
+        this.ref = ref;
+        // Without this, `instanceof` fails when the package is compiled to ES5.
+        Object.setPrototypeOf(this, RefResolutionError.prototype);
+    }
+}
+/** No legitimate document chains this many `$ref`s. See resolveRef. */
+const MAX_REF_HOPS = 1000;
+/** RFC 6901: `~1` is "/" and `~0` is "~", decoded in that order. */
+function decodePointerToken(token) {
+    return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function toPointerTokens(ref) {
+    const pointer = ref.slice(1);
+    if (pointer === "" || pointer === "/")
+        return [];
+    return pointer.split("/").slice(1).map(decodePointerToken);
+}
+/**
+ * `definitions` and `$defs` are the same container to a pointer: a Draft-07
+ * document spells it one way, a 2019-09 document the other, and a schema that
+ * mixes them (they exist) must still resolve. A real `definitions` member
+ * always wins, so a property literally named "definitions" is unaffected.
+ */
+function stepInto(current, token) {
+    if (isArray(current))
+        return current[Number(token)];
+    if (!isPlainObject(current))
+        return undefined;
+    if (token === "definitions" || token === "$defs") {
+        return current["definitions"] ?? current["$defs"];
+    }
+    return current[token];
+}
+function followPointer(ref, root) {
+    let current = root;
+    for (const token of toPointerTokens(ref)) {
+        current = stepInto(current, token);
+        if (current === undefined) {
+            throw new RefResolutionError(ref, `no schema at segment "${token}"`);
+        }
+    }
+    if (!isDraft07Schema(current)) {
+        throw new RefResolutionError(ref, "the target is not a schema");
+    }
+    return current;
+}
+/**
+ * Resolves `ref` against `root`, then keeps following `$ref` until it reaches
+ * a schema that is not one. `visited` holds the pointers already entered on
+ * THIS chain, so `a -> b -> a` throws instead of looping forever.
+ */
+export function resolveRef(ref, root) {
+    const visited = new Set();
+    let currentRef = ref;
+    for (let hop = 0;; hop += 1) {
+        // The visited set is the real cycle detector and gives the good message.
+        // This bound is the SECOND line: a synchronous infinite loop cannot be
+        // interrupted by a test timeout, so a defect in the detector above must
+        // still terminate. Measured: removing the visited check without this made
+        // the resolver hang the whole test process instead of failing it.
+        if (hop > MAX_REF_HOPS) {
+            throw new RefResolutionError(ref, `more than ${MAX_REF_HOPS} $ref hops`);
+        }
+        if (!currentRef.startsWith("#")) {
+            throw new RefResolutionError(currentRef, "external references are not supported");
+        }
+        if (visited.has(currentRef)) {
+            throw new RefResolutionError(ref, `circular reference: ${[...visited, currentRef].join(" -> ")}`);
+        }
+        visited.add(currentRef);
+        const target = followPointer(currentRef, root);
+        if (!isSchemaObject(target) || target.$ref === undefined)
+            return target;
+        currentRef = target.$ref;
+    }
+}
+/**
+ * True when `ref` resolves without leaving the document and without entering a
+ * cycle. It answers the question without making the caller catch to find out.
+ */
+export function isResolvableRef(ref, root) {
+    try {
+        resolveRef(ref, root);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof RefResolutionError)
+            return false;
+        throw error;
+    }
+}

package/dist/json-schema/schema-to-declarations.d.ts

@@ -0,0 +1,9 @@
+import type { Rule } from "../plugin-kit/compiled-rule";
+import type { Draft07SchemaObject } from "./draft07.types";
+import type { ChildSchema, StructuralContext, StructuralExpansionTable, StructuralKeyword } from "./structural-expansion.types";
+export declare const STRUCTURAL_EXPANSIONS: StructuralExpansionTable;
+export declare function isStructuralKeyword(name: string): name is StructuralKeyword;
+/** Every child path a schema declares: `properties` keys and `items`' `[*]`. */
+export declare function readChildSchemas(schema: Draft07SchemaObject): readonly ChildSchema[];
+/** The rules a schema imposes ON ITS OWN SUBJECT, children excluded. */
+export declare function expandSchemaRules(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];

package/dist/json-schema/schema-to-declarations.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STRUCTURAL_EXPANSIONS = void 0;
+exports.isStructuralKeyword = isStructuralKeyword;
+exports.readChildSchemas = readChildSchemas;
+exports.expandSchemaRules = expandSchemaRules;
+const collect_definitions_1 = require("./collect-definitions");
+const compose_conditional_1 = require("./compose-conditional");
+const compose_keyword_1 = require("./compose-keyword");
+const declare_object_keywords_1 = require("./declare-object-keywords");
+const declare_required_properties_1 = require("./declare-required-properties");
+const declare_scalar_keywords_1 = require("./declare-scalar-keywords");
+const declare_value_keywords_1 = require("./declare-value-keywords");
+const flatten_array_schema_1 = require("./flatten-array-schema");
+const keyword_map_1 = require("./keyword-map");
+const structural_expansion_types_1 = require("./structural-expansion.types");
+const unsupported_keyword_error_1 = require("./unsupported-keyword-error");
+const CONSUMED_BY_IF = "inert without `if` (Draft-07 §6.6.2); composed there";
+exports.STRUCTURAL_EXPANSIONS = {
+    $ref: {
+        expandsTo: "consumed",
+        consumedBy: "resolve-ref",
+        reason: "the node is replaced before any keyword is read",
+    },
+    definitions: {
+        expandsTo: "consumed",
+        consumedBy: "collect-definitions",
+        reason: "a container of schemas, never a constraint",
+    },
+    type: {
+        expandsTo: "rules",
+        toRules: (schema, context) => [
+            ...(0, declare_value_keywords_1.declareTypeRules)(schema, context),
+            ...(0, declare_value_keywords_1.declareIntegerRules)(schema, context),
+        ],
+    },
+    enum: { expandsTo: "rules", toRules: declare_value_keywords_1.declareEnumRules },
+    allOf: { expandsTo: "rules", toRules: compose_keyword_1.composeAllOf },
+    anyOf: { expandsTo: "rules", toRules: compose_keyword_1.composeAnyOf },
+    oneOf: { expandsTo: "rules", toRules: compose_keyword_1.composeOneOf },
+    not: { expandsTo: "rules", toRules: compose_keyword_1.composeNot },
+    if: { expandsTo: "rules", toRules: compose_conditional_1.composeConditional },
+    then: {
+        expandsTo: "consumed",
+        consumedBy: "compose-conditional",
+        reason: CONSUMED_BY_IF,
+    },
+    else: {
+        expandsTo: "consumed",
+        consumedBy: "compose-conditional",
+        reason: CONSUMED_BY_IF,
+    },
+    format: { expandsTo: "rules", toRules: declare_scalar_keywords_1.declareFormatRules },
+    items: {
+        expandsTo: "rules-and-declarations",
+        toRules: flatten_array_schema_1.composeTupleItems,
+        toChildren: flatten_array_schema_1.readItemChildren,
+    },
+    additionalItems: {
+        expandsTo: "consumed",
+        consumedBy: "flatten-array-schema",
+        reason: "the rest branch of the tuple form of `items`",
+    },
+    contains: { expandsTo: "rules", toRules: flatten_array_schema_1.composeContains },
+    properties: { expandsTo: "declarations", toChildren: declare_object_keywords_1.readPropertyChildren },
+    patternProperties: { expandsTo: "rules", toRules: declare_object_keywords_1.declarePatternProperties },
+    dependencies: { expandsTo: "rules", toRules: declare_object_keywords_1.declareDependencies },
+    propertyNames: { expandsTo: "rules", toRules: declare_object_keywords_1.declarePropertyNames },
+};
+function isStructuralKeyword(name) {
+    return Object.prototype.hasOwnProperty.call(exports.STRUCTURAL_EXPANSIONS, name);
+}
+/** Every child path a schema declares: `properties` keys and `items`' `[*]`. */
+function readChildSchemas(schema) {
+    const children = [];
+    for (const expansion of Object.values(exports.STRUCTURAL_EXPANSIONS)) {
+        const toChildren = (0, structural_expansion_types_1.readChildExpansion)(expansion);
+        if (toChildren === undefined)
+            continue;
+        children.push(...toChildren(schema));
+    }
+    return Object.freeze(children);
+}
+/**
+ * A name the table does not know is an ANNOTATION and is ignored (Draft-07
+ * §4.3.2). A name Luq recognises as belonging to another dialect is not: it
+ * would change the meaning of the document, so it is refused by name.
+ */
+function assertKeywordIsConvertible(keyword) {
+    if ((0, keyword_map_1.findKeywordHandling)(keyword) !== undefined)
+        return;
+    if ((0, collect_definitions_1.isDefinitionContainer)(keyword))
+        return;
+    const note = keyword_map_1.NON_DRAFT07_KEYWORDS[keyword];
+    if (note !== undefined)
+        throw new unsupported_keyword_error_1.UnsupportedKeywordError(keyword, note);
+}
+/** The rules a schema imposes ON ITS OWN SUBJECT, children excluded. */
+function expandSchemaRules(schema, context) {
+    const rules = [
+        ...(0, declare_scalar_keywords_1.declareStringRules)(schema, context),
+        ...(0, declare_scalar_keywords_1.declareNumberRules)(schema, context),
+        ...(0, flatten_array_schema_1.declareArrayRules)(schema, context),
+        ...(0, declare_object_keywords_1.declareObjectRules)(schema, context),
+        ...(0, declare_value_keywords_1.declareConstRules)(schema, context),
+        ...(0, declare_object_keywords_1.declareAdditionalPropertiesSchema)(schema, context),
+        ...(0, declare_required_properties_1.declareRequiredProperties)(schema, context),
+    ];
+    for (const keyword of Object.keys(schema)) {
+        assertKeywordIsConvertible(keyword);
+    }
+    // Driven by the TABLE, not by the keys somebody remembered to look at: every
+    // expansion self-gates on its own keyword, so a structural keyword can never
+    // be present in the document and unreached here.
+    for (const expansion of Object.values(exports.STRUCTURAL_EXPANSIONS)) {
+        const toRules = (0, structural_expansion_types_1.readRuleExpansion)(expansion);
+        if (toRules === undefined)
+            continue;
+        rules.push(...toRules(schema, context));
+    }
+    return Object.freeze(rules);
+}