@maroonedog/luq 2.2.0 → 2.3.0

package/dist/standard-schema/assemble-json-schema.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assembleJsonSchema = assembleJsonSchema;
+// ===========================================================================
+// L10 src/standard-schema/assemble-json-schema.ts
+//
+// Builds the nested object and array schema from a list of paths.
+//
+// `"owner.name"` becomes `properties.owner.properties.name`, and
+// `"employees[*].name"` becomes
+// `properties.employees.items.properties.name`. Paths are read with the
+// existing path parser rather than a second grammar written here.
+//
+// `required` belongs to the PARENT. In JSON Schema it says "this object must
+// carry this key", which is a fact about the object, not about the key.
+// ===========================================================================
+const parse_field_path_1 = require("../path/parse-field-path");
+const emit_field_schema_1 = require("./emit-field-schema");
+const declarations_unavailable_error_1 = require("./declarations-unavailable-error");
+const newNode = () => ({
+    properties: new Map(),
+    required: new Set(),
+    element: null,
+    leaf: null,
+});
+/** Descends through `key`, creating it when absent. */
+function descend(node, key) {
+    const existing = node.properties.get(key);
+    if (existing !== undefined)
+        return existing;
+    const created = newNode();
+    node.properties.set(key, created);
+    return created;
+}
+/** Places one path in the tree, setting the schema where the leaf lands. */
+function place(root, segments, schema, isRequired) {
+    let node = root;
+    let owner = null;
+    let ownerKey = "";
+    for (const segment of segments) {
+        if (segment.kind === "each") {
+            node.element ?? (node.element = newNode());
+            node = node.element;
+            owner = null;
+            continue;
+        }
+        owner = node;
+        ownerKey = segment.key;
+        node = descend(node, segment.key);
+    }
+    node.leaf = schema;
+    if (isRequired && owner !== null)
+        owner.required.add(ownerKey);
+}
+/**
+ * Freezes a node into a JSON Schema.
+ *
+ * On a node that has children, the leaf schema is the FOUNDATION. When both
+ * `.object.required()` and `"user.name"` are declared, the properties from
+ * the latter sit on top of the `type: "object"` from the former.
+ */
+function freeze(node) {
+    const schema = { ...node.leaf };
+    if (node.element !== null) {
+        schema["type"] ?? (schema["type"] = "array");
+        schema["items"] = freeze(node.element);
+    }
+    if (node.properties.size > 0) {
+        schema["type"] ?? (schema["type"] = "object");
+        const properties = {};
+        for (const [key, child] of node.properties) {
+            properties[key] = freeze(child);
+        }
+        schema["properties"] = properties;
+    }
+    if (node.required.size > 0)
+        schema["required"] = [...node.required];
+    return schema;
+}
+/** Assembles the root schema from the list of declarations. */
+function assembleJsonSchema(fields, policy) {
+    const root = newNode();
+    for (const field of fields) {
+        // One field with no record is enough to refuse, whatever the policy says.
+        if (field.calls === null)
+            throw new declarations_unavailable_error_1.DeclarationsUnavailableError(field.path);
+        const emitted = (0, emit_field_schema_1.emitFieldSchema)(field.path, field.calls, policy);
+        place(root, (0, parse_field_path_1.parseFieldPath)(field.path), emitted.schema, emitted.isRequired);
+    }
+    const schema = freeze(root);
+    // Even with nothing declared, or everything dropped, the root is an object:
+    // the builder only accepts an object type in the first place.
+    schema["type"] ?? (schema["type"] = "object");
+    return schema;
+}

package/dist/standard-schema/assemble-json-schema.mjs

@@ -0,0 +1,92 @@
+// ===========================================================================
+// L10 src/standard-schema/assemble-json-schema.ts
+//
+// Builds the nested object and array schema from a list of paths.
+//
+// `"owner.name"` becomes `properties.owner.properties.name`, and
+// `"employees[*].name"` becomes
+// `properties.employees.items.properties.name`. Paths are read with the
+// existing path parser rather than a second grammar written here.
+//
+// `required` belongs to the PARENT. In JSON Schema it says "this object must
+// carry this key", which is a fact about the object, not about the key.
+// ===========================================================================
+import { parseFieldPath } from "../path/parse-field-path.mjs";
+import { emitFieldSchema } from "./emit-field-schema.mjs";
+import { DeclarationsUnavailableError } from "./declarations-unavailable-error.mjs";
+const newNode = () => ({
+    properties: new Map(),
+    required: new Set(),
+    element: null,
+    leaf: null,
+});
+/** Descends through `key`, creating it when absent. */
+function descend(node, key) {
+    const existing = node.properties.get(key);
+    if (existing !== undefined)
+        return existing;
+    const created = newNode();
+    node.properties.set(key, created);
+    return created;
+}
+/** Places one path in the tree, setting the schema where the leaf lands. */
+function place(root, segments, schema, isRequired) {
+    let node = root;
+    let owner = null;
+    let ownerKey = "";
+    for (const segment of segments) {
+        if (segment.kind === "each") {
+            node.element ?? (node.element = newNode());
+            node = node.element;
+            owner = null;
+            continue;
+        }
+        owner = node;
+        ownerKey = segment.key;
+        node = descend(node, segment.key);
+    }
+    node.leaf = schema;
+    if (isRequired && owner !== null)
+        owner.required.add(ownerKey);
+}
+/**
+ * Freezes a node into a JSON Schema.
+ *
+ * On a node that has children, the leaf schema is the FOUNDATION. When both
+ * `.object.required()` and `"user.name"` are declared, the properties from
+ * the latter sit on top of the `type: "object"` from the former.
+ */
+function freeze(node) {
+    const schema = { ...node.leaf };
+    if (node.element !== null) {
+        schema["type"] ?? (schema["type"] = "array");
+        schema["items"] = freeze(node.element);
+    }
+    if (node.properties.size > 0) {
+        schema["type"] ?? (schema["type"] = "object");
+        const properties = {};
+        for (const [key, child] of node.properties) {
+            properties[key] = freeze(child);
+        }
+        schema["properties"] = properties;
+    }
+    if (node.required.size > 0)
+        schema["required"] = [...node.required];
+    return schema;
+}
+/** Assembles the root schema from the list of declarations. */
+export function assembleJsonSchema(fields, policy) {
+    const root = newNode();
+    for (const field of fields) {
+        // One field with no record is enough to refuse, whatever the policy says.
+        if (field.calls === null)
+            throw new DeclarationsUnavailableError(field.path);
+        const emitted = emitFieldSchema(field.path, field.calls, policy);
+        place(root, parseFieldPath(field.path), emitted.schema, emitted.isRequired);
+    }
+    const schema = freeze(root);
+    // Even with nothing declared, or everything dropped, the root is an object:
+    // the builder only accepts an object type in the first place.
+    schema["type"] ?? (schema["type"] = "object");
+    return schema;
+}

package/dist/standard-schema/declaration-recorder.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Idempotent. Call it at module scope, never from inside a function: the
+ * recorder has to be in place before any chain runs, and hiding the call
+ * behind a function makes that ordering depend on who calls it first.
+ */
+export declare function installJsonSchemaDeclarationRecorder(): void;

package/dist/standard-schema/declaration-recorder.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installJsonSchemaDeclarationRecorder = installJsonSchemaDeclarationRecorder;
+const declaration_recorder_port_1 = require("../chain/declaration-recorder.port");
+const NONE = Object.freeze([]);
+const callsByNode = new WeakMap();
+const recorder = {
+    record(parent, child, plugin, slot, args) {
+        callsByNode.set(child, [
+            ...(callsByNode.get(parent) ?? NONE),
+            { pluginName: plugin.name, method: plugin.method, slot, args },
+        ]);
+    },
+    inherit(parent, child) {
+        const calls = callsByNode.get(parent);
+        if (calls !== undefined)
+            callsByNode.set(child, calls);
+    },
+    read(node) {
+        return callsByNode.get(node);
+    },
+};
+/**
+ * Idempotent. Call it at module scope, never from inside a function: the
+ * recorder has to be in place before any chain runs, and hiding the call
+ * behind a function makes that ordering depend on who calls it first.
+ */
+function installJsonSchemaDeclarationRecorder() {
+    (0, declaration_recorder_port_1.installDeclarationRecorder)(recorder);
+}

package/dist/standard-schema/declaration-recorder.mjs

@@ -0,0 +1,27 @@
+import { installDeclarationRecorder, } from "../chain/declaration-recorder.port.mjs";
+const NONE = Object.freeze([]);
+const callsByNode = new WeakMap();
+const recorder = {
+    record(parent, child, plugin, slot, args) {
+        callsByNode.set(child, [
+            ...(callsByNode.get(parent) ?? NONE),
+            { pluginName: plugin.name, method: plugin.method, slot, args },
+        ]);
+    },
+    inherit(parent, child) {
+        const calls = callsByNode.get(parent);
+        if (calls !== undefined)
+            callsByNode.set(child, calls);
+    },
+    read(node) {
+        return callsByNode.get(node);
+    },
+};
+/**
+ * Idempotent. Call it at module scope, never from inside a function: the
+ * recorder has to be in place before any chain runs, and hiding the call
+ * behind a function makes that ordering depend on who calls it first.
+ */
+export function installJsonSchemaDeclarationRecorder() {
+    installDeclarationRecorder(recorder);
+}

package/dist/standard-schema/declarations-unavailable-error.d.ts

@@ -0,0 +1,4 @@
+export declare class DeclarationsUnavailableError extends Error {
+    readonly fieldPath?: string | undefined;
+    constructor(fieldPath?: string | undefined);
+}

package/dist/standard-schema/declarations-unavailable-error.js

@@ -0,0 +1,32 @@
+"use strict";
+// ===========================================================================
+// L10 src/standard-schema/declarations-unavailable-error.ts
+//
+// "Nothing was declared" and "what was declared is not known" are different
+// answers, and only one of them can be written out.
+//
+// Collapsing them into an empty list produces a schema that permits everything
+// and looks entirely confident about it. This refusal exists to stop that.
+//
+// It outranks the unrepresentable policy: `omit` is permission to drop a
+// declaration that cannot be written, not permission to write without knowing
+// what was declared.
+// ===========================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeclarationsUnavailableError = void 0;
+class DeclarationsUnavailableError extends Error {
+    constructor(fieldPath) {
+        super((fieldPath === undefined
+            ? "This validator carries no declarations"
+            : `"${fieldPath}" carries no declarations`) +
+            ", so no JSON Schema can be emitted from it. Two things cause " +
+            "this. A validator from fromJsonSchema() was assembled from rules " +
+            "directly and never went through the builder chain. Otherwise the " +
+            'build() ran before "@maroonedog/luq/standard-schema" was loaded — ' +
+            "import it from the module that builds the validator, or from one " +
+            "evaluated before it.");
+        this.fieldPath = fieldPath;
+        this.name = "DeclarationsUnavailableError";
+    }
+}
+exports.DeclarationsUnavailableError = DeclarationsUnavailableError;

package/dist/standard-schema/declarations-unavailable-error.mjs

@@ -0,0 +1,28 @@
+// ===========================================================================
+// L10 src/standard-schema/declarations-unavailable-error.ts
+//
+// "Nothing was declared" and "what was declared is not known" are different
+// answers, and only one of them can be written out.
+//
+// Collapsing them into an empty list produces a schema that permits everything
+// and looks entirely confident about it. This refusal exists to stop that.
+//
+// It outranks the unrepresentable policy: `omit` is permission to drop a
+// declaration that cannot be written, not permission to write without knowing
+// what was declared.
+// ===========================================================================
+export class DeclarationsUnavailableError extends Error {
+    constructor(fieldPath) {
+        super((fieldPath === undefined
+            ? "This validator carries no declarations"
+            : `"${fieldPath}" carries no declarations`) +
+            ", so no JSON Schema can be emitted from it. Two things cause " +
+            "this. A validator from fromJsonSchema() was assembled from rules " +
+            "directly and never went through the builder chain. Otherwise the " +
+            'build() ran before "@maroonedog/luq/standard-schema" was loaded — ' +
+            "import it from the module that builds the validator, or from one " +
+            "evaluated before it.");
+        this.fieldPath = fieldPath;
+        this.name = "DeclarationsUnavailableError";
+    }
+}

package/dist/standard-schema/emit-field-schema.d.ts

@@ -0,0 +1,9 @@
+import type { DeclaredCall } from "../chain/declared-call.types";
+import { type UnrepresentablePolicy } from "./unrepresentable-rule-error";
+/** One emitted field. `required` is separate: the parent assembles it. */
+export interface EmittedField {
+    readonly schema: Record<string, unknown>;
+    readonly isRequired: boolean;
+}
+/** Makes one field's schema from that field's declared calls. */
+export declare function emitFieldSchema(fieldPath: string, calls: readonly DeclaredCall[], policy: UnrepresentablePolicy): EmittedField;

package/dist/standard-schema/emit-field-schema.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitFieldSchema = emitFieldSchema;
+const plugin_keyword_map_1 = require("./plugin-keyword-map");
+const unrepresentable_rule_error_1 = require("./unrepresentable-rule-error");
+/** Slot to JSON Schema type name; undefined when it cannot be decided. */
+const TYPE_OF_SLOT = Object.freeze({
+    string: "string",
+    number: "number",
+    boolean: "boolean",
+    array: "array",
+    object: "object",
+    // date is not a JSON type. Draft-07 convention writes it as a string with
+    // `format: "date-time"`, but the date slot judges Date instances, which
+    // are not JSON values. Counted as unwritable rather than conflated.
+});
+function typeOf(calls) {
+    const slots = new Set(calls.map((call) => call.slot));
+    slots.delete("any");
+    if (slots.size !== 1)
+        return undefined;
+    const [slot] = [...slots];
+    return slot === undefined ? undefined : TYPE_OF_SLOT[slot];
+}
+/**
+ * How `type` is spelled. Draft-07 expresses `.nullable()` as a list of
+ * types (`{"type": ["string", "null"]}`). `{"nullable": true}` is the
+ * OpenAPI 3.0 spelling and is not in the JSON Schema vocabulary.
+ */
+function typeKeyword(calls, fieldPath, policy) {
+    const isInteger = calls.some((call) => call.pluginName === "numberInteger");
+    const isNullable = calls.some((call) => call.pluginName === "nullable");
+    const base = isInteger ? "integer" : typeOf(calls);
+    if (base === undefined) {
+        if (policy === "throw") {
+            throw new unrepresentable_rule_error_1.UnrepresentableRuleError(fieldPath, "the chain", "its declarations do not settle on one JSON type");
+        }
+        return {};
+    }
+    return { type: isNullable ? [base, "null"] : base };
+}
+/** Makes one field's schema from that field's declared calls. */
+function emitFieldSchema(fieldPath, calls, policy) {
+    if (calls.length === 0 && policy === "throw") {
+        throw new unrepresentable_rule_error_1.UnrepresentableRuleError(fieldPath, "this field", "no declaration was recorded for it (it was not built through the " +
+            "builder chain)");
+    }
+    const schema = typeKeyword(calls, fieldPath, policy);
+    for (const call of calls) {
+        const toKeywords = plugin_keyword_map_1.PLUGIN_KEYWORDS[call.pluginName];
+        if (toKeywords === undefined) {
+            if (policy === "throw") {
+                throw new unrepresentable_rule_error_1.UnrepresentableRuleError(fieldPath, call.pluginName, "no JSON Schema keyword expresses it");
+            }
+            continue;
+        }
+        const keywords = toKeywords(call.args);
+        if (keywords === null)
+            continue;
+        Object.assign(schema, keywords);
+    }
+    return {
+        schema,
+        // `.optional()` counts wherever it appears in the chain, not only first.
+        isRequired: calls.some((call) => call.pluginName === "required") &&
+            !calls.some((call) => call.pluginName === "optional"),
+    };
+}

package/dist/standard-schema/emit-field-schema.mjs

@@ -0,0 +1,65 @@
+import { PLUGIN_KEYWORDS } from "./plugin-keyword-map.mjs";
+import { UnrepresentableRuleError, } from "./unrepresentable-rule-error.mjs";
+/** Slot to JSON Schema type name; undefined when it cannot be decided. */
+const TYPE_OF_SLOT = Object.freeze({
+    string: "string",
+    number: "number",
+    boolean: "boolean",
+    array: "array",
+    object: "object",
+    // date is not a JSON type. Draft-07 convention writes it as a string with
+    // `format: "date-time"`, but the date slot judges Date instances, which
+    // are not JSON values. Counted as unwritable rather than conflated.
+});
+function typeOf(calls) {
+    const slots = new Set(calls.map((call) => call.slot));
+    slots.delete("any");
+    if (slots.size !== 1)
+        return undefined;
+    const [slot] = [...slots];
+    return slot === undefined ? undefined : TYPE_OF_SLOT[slot];
+}
+/**
+ * How `type` is spelled. Draft-07 expresses `.nullable()` as a list of
+ * types (`{"type": ["string", "null"]}`). `{"nullable": true}` is the
+ * OpenAPI 3.0 spelling and is not in the JSON Schema vocabulary.
+ */
+function typeKeyword(calls, fieldPath, policy) {
+    const isInteger = calls.some((call) => call.pluginName === "numberInteger");
+    const isNullable = calls.some((call) => call.pluginName === "nullable");
+    const base = isInteger ? "integer" : typeOf(calls);
+    if (base === undefined) {
+        if (policy === "throw") {
+            throw new UnrepresentableRuleError(fieldPath, "the chain", "its declarations do not settle on one JSON type");
+        }
+        return {};
+    }
+    return { type: isNullable ? [base, "null"] : base };
+}
+/** Makes one field's schema from that field's declared calls. */
+export function emitFieldSchema(fieldPath, calls, policy) {
+    if (calls.length === 0 && policy === "throw") {
+        throw new UnrepresentableRuleError(fieldPath, "this field", "no declaration was recorded for it (it was not built through the " +
+            "builder chain)");
+    }
+    const schema = typeKeyword(calls, fieldPath, policy);
+    for (const call of calls) {
+        const toKeywords = PLUGIN_KEYWORDS[call.pluginName];
+        if (toKeywords === undefined) {
+            if (policy === "throw") {
+                throw new UnrepresentableRuleError(fieldPath, call.pluginName, "no JSON Schema keyword expresses it");
+            }
+            continue;
+        }
+        const keywords = toKeywords(call.args);
+        if (keywords === null)
+            continue;
+        Object.assign(schema, keywords);
+    }
+    return {
+        schema,
+        // `.optional()` counts wherever it appears in the chain, not only first.
+        isRequired: calls.some((call) => call.pluginName === "required") &&
+            !calls.some((call) => call.pluginName === "optional"),
+    };
+}

package/dist/standard-schema/index.d.ts

@@ -4,3 +4,8 @@ export type { IssuePathSegments } from "./split-issue-path";
 export { splitIssuePath } from "./split-issue-path";
 export type { StandardLuqSchema } from "./to-standard-schema";
 export { toStandardSchema } from "./to-standard-schema";
+export type { JsonSchemaOptions, StandardJsonSchemaLuqSchema, } from "./to-standard-json-schema";
+export { toStandardJsonSchema } from "./to-standard-json-schema";
+export { DeclarationsUnavailableError } from "./declarations-unavailable-error";
+export { UnsupportedJsonSchemaTargetError } from "./json-schema-target";
+export { UnrepresentableRuleError, type UnrepresentablePolicy, } from "./unrepresentable-rule-error";

package/dist/standard-schema/index.js

@@ -1,7 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toStandardSchema = exports.splitIssuePath = void 0;
+exports.UnrepresentableRuleError = exports.UnsupportedJsonSchemaTargetError = exports.DeclarationsUnavailableError = exports.toStandardJsonSchema = exports.toStandardSchema = exports.splitIssuePath = void 0;
 var split_issue_path_1 = require("./split-issue-path");
 Object.defineProperty(exports, "splitIssuePath", { enumerable: true, get: function () { return split_issue_path_1.splitIssuePath; } });
 var to_standard_schema_1 = require("./to-standard-schema");
 Object.defineProperty(exports, "toStandardSchema", { enumerable: true, get: function () { return to_standard_schema_1.toStandardSchema; } });
+var to_standard_json_schema_1 = require("./to-standard-json-schema");
+Object.defineProperty(exports, "toStandardJsonSchema", { enumerable: true, get: function () { return to_standard_json_schema_1.toStandardJsonSchema; } });
+var declarations_unavailable_error_1 = require("./declarations-unavailable-error");
+Object.defineProperty(exports, "DeclarationsUnavailableError", { enumerable: true, get: function () { return declarations_unavailable_error_1.DeclarationsUnavailableError; } });
+var json_schema_target_1 = require("./json-schema-target");
+Object.defineProperty(exports, "UnsupportedJsonSchemaTargetError", { enumerable: true, get: function () { return json_schema_target_1.UnsupportedJsonSchemaTargetError; } });
+var unrepresentable_rule_error_1 = require("./unrepresentable-rule-error");
+Object.defineProperty(exports, "UnrepresentableRuleError", { enumerable: true, get: function () { return unrepresentable_rule_error_1.UnrepresentableRuleError; } });

package/dist/standard-schema/index.mjs

@@ -1,2 +1,6 @@
 export { splitIssuePath } from "./split-issue-path.mjs";
 export { toStandardSchema } from "./to-standard-schema.mjs";
+export { toStandardJsonSchema } from "./to-standard-json-schema.mjs";
+export { DeclarationsUnavailableError } from "./declarations-unavailable-error.mjs";
+export { UnsupportedJsonSchemaTargetError } from "./json-schema-target.mjs";
+export { UnrepresentableRuleError, } from "./unrepresentable-rule-error.mjs";

package/dist/standard-schema/json-schema-target.d.ts

@@ -0,0 +1,6 @@
+export declare class UnsupportedJsonSchemaTargetError extends Error {
+    readonly target: string;
+    constructor(target: string);
+}
+/** Returns the `$schema` for a supported target; throws for anything else. */
+export declare function resolveJsonSchemaTarget(target: string): string;

package/dist/standard-schema/json-schema-target.js

@@ -0,0 +1,44 @@
+"use strict";
+// ===========================================================================
+// L10 src/standard-schema/json-schema-target.ts
+//
+// Takes the spec's `target` and admits only what is actually supported.
+//
+// The spec says to throw on an unsupported target, and it is right to: writing
+// draft-07 silently when 2020-12 was asked for hands the caller a document
+// they will read under the wrong rules.
+//
+// Two are supported, draft-2020-12 and draft-07 — the two the spec names as
+// widely used and strongly recommends implementing. openapi-3.0 descends from
+// draft-04 and is a different lineage, so it is not admitted on a guess.
+//
+// Across the vocabulary currently emitted, the two differ only in `$schema`:
+// every keyword written today is spelled and means the same in both. Tuples
+// would differ, and are not emitted. This is where the branch goes if that
+// changes.
+// ===========================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsupportedJsonSchemaTargetError = void 0;
+exports.resolveJsonSchemaTarget = resolveJsonSchemaTarget;
+/** The supported targets, and the `$schema` each one announces. */
+const SCHEMA_URI = Object.freeze({
+    "draft-2020-12": "https://json-schema.org/draft/2020-12/schema",
+    "draft-07": "http://json-schema.org/draft-07/schema#",
+});
+class UnsupportedJsonSchemaTargetError extends Error {
+    constructor(target) {
+        super(`Luq does not emit JSON Schema for the target "${target}". ` +
+            `Supported targets: ${Object.keys(SCHEMA_URI).join(", ")}.`);
+        this.target = target;
+        this.name = "UnsupportedJsonSchemaTargetError";
+    }
+}
+exports.UnsupportedJsonSchemaTargetError = UnsupportedJsonSchemaTargetError;
+/** Returns the `$schema` for a supported target; throws for anything else. */
+function resolveJsonSchemaTarget(target) {
+    const schemaUri = SCHEMA_URI[target];
+    if (schemaUri === undefined) {
+        throw new UnsupportedJsonSchemaTargetError(target);
+    }
+    return schemaUri;
+}

package/dist/standard-schema/json-schema-target.mjs

@@ -0,0 +1,39 @@
+// ===========================================================================
+// L10 src/standard-schema/json-schema-target.ts
+//
+// Takes the spec's `target` and admits only what is actually supported.
+//
+// The spec says to throw on an unsupported target, and it is right to: writing
+// draft-07 silently when 2020-12 was asked for hands the caller a document
+// they will read under the wrong rules.
+//
+// Two are supported, draft-2020-12 and draft-07 — the two the spec names as
+// widely used and strongly recommends implementing. openapi-3.0 descends from
+// draft-04 and is a different lineage, so it is not admitted on a guess.
+//
+// Across the vocabulary currently emitted, the two differ only in `$schema`:
+// every keyword written today is spelled and means the same in both. Tuples
+// would differ, and are not emitted. This is where the branch goes if that
+// changes.
+// ===========================================================================
+/** The supported targets, and the `$schema` each one announces. */
+const SCHEMA_URI = Object.freeze({
+    "draft-2020-12": "https://json-schema.org/draft/2020-12/schema",
+    "draft-07": "http://json-schema.org/draft-07/schema#",
+});
+export class UnsupportedJsonSchemaTargetError extends Error {
+    constructor(target) {
+        super(`Luq does not emit JSON Schema for the target "${target}". ` +
+            `Supported targets: ${Object.keys(SCHEMA_URI).join(", ")}.`);
+        this.target = target;
+        this.name = "UnsupportedJsonSchemaTargetError";
+    }
+}
+/** Returns the `$schema` for a supported target; throws for anything else. */
+export function resolveJsonSchemaTarget(target) {
+    const schemaUri = SCHEMA_URI[target];
+    if (schemaUri === undefined) {
+        throw new UnsupportedJsonSchemaTargetError(target);
+    }
+    return schemaUri;
+}

package/dist/standard-schema/plugin-keyword-map.d.ts

@@ -0,0 +1,3 @@
+/** A keyword fragment made from the arguments; null means type or presence handles it. */
+export type ToKeywords = (args: readonly unknown[]) => Record<string, unknown> | null;
+export declare const PLUGIN_KEYWORDS: Readonly<Record<string, ToKeywords>>;