@maroonedog/luq 0.1.2-alpha → 2.0.0

package/dist/json-schema/declare-object-keywords.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.declareObjectRules = declareObjectRules;
+exports.declareAdditionalPropertiesSchema = declareAdditionalPropertiesSchema;
+exports.declarePatternProperties = declarePatternProperties;
+exports.declarePropertyNames = declarePropertyNames;
+exports.declareDependencies = declareDependencies;
+exports.readPropertyChildren = readPropertyChildren;
+// ===========================================================================
+// L8  src/json-schema/declare-object-keywords.ts — the object keywords: the
+// three that bind, and the four object shapes that expand.
+//
+// THE NORMALISATIONS THE COMPILER FORCES (draft07-keyword-value.types.ts):
+//   additionalProperties  a schema is a sub-CHAIN and only the boolean form
+//                         binds. `declaredSiblingKeys` on the chain context is
+//                         set by schema-to-declarations to THIS schema's own
+//                         `properties` keys, so the plugin's allowed set is the
+//                         draft's — 1.x defaulted it to the empty list and
+//                         `additionalProperties: false` rejected every property.
+//   dependencies          one keyword, two chain methods: a key list drives
+//                         .dependentRequired(), a sub-schema .dependentSchemas().
+// ===========================================================================
+const create_chain_node_1 = require("../chain/create-chain-node");
+const create_field_slots_1 = require("../chain/create-field-slots");
+const types_1 = require("../types");
+const apply_keyword_binding_1 = require("./apply-keyword-binding");
+const collect_definitions_1 = require("./collect-definitions");
+const keyword_map_object_1 = require("./keyword-map-object");
+const NO_RULES = Object.freeze([]);
+function readRules(chain) {
+    return (0, create_chain_node_1.readChainRules)(chain) ?? NO_RULES;
+}
+function declareObjectRules(schema, context) {
+    let chain = (0, create_field_slots_1.createFieldSlots)(context.bag, context.build).object;
+    if (schema.minProperties !== undefined) {
+        chain = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_object_1.minPropertiesBinding, schema.minProperties);
+    }
+    if (schema.maxProperties !== undefined) {
+        chain = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_object_1.maxPropertiesBinding, schema.maxProperties);
+    }
+    const additional = schema.additionalProperties;
+    if (typeof additional === "boolean") {
+        chain = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_object_1.additionalPropertiesBinding, additional);
+    }
+    return readRules(chain);
+}
+/** The SCHEMA form of `additionalProperties`: every undeclared value obeys it. */
+function declareAdditionalPropertiesSchema(schema, context) {
+    const additional = schema.additionalProperties;
+    if (additional === undefined || typeof additional === "boolean") {
+        return NO_RULES;
+    }
+    const plugin = context.bag.objectAdditionalPropertiesSchema;
+    return Object.freeze([
+        plugin.build(context.ruleContextFor(plugin.name, "additionalProperties"), context.collectSubSchemaRules(additional)),
+    ]);
+}
+/** EVERY matching pattern applies; 1.x broke after the first match. */
+function declarePatternProperties(schema, context) {
+    const patterns = schema.patternProperties;
+    if (patterns === undefined)
+        return NO_RULES;
+    const byPattern = {};
+    for (const [pattern, member] of Object.entries(patterns)) {
+        byPattern[pattern] = context.collectSubSchemaRules(member);
+    }
+    const plugin = context.bag.objectPatternProperties;
+    return Object.freeze([
+        plugin.build(context.ruleContextFor(plugin.name, "patternProperties"), Object.freeze(byPattern)),
+    ]);
+}
+/** A sub-chain over the property NAMES, which are always strings. */
+function declarePropertyNames(schema, context) {
+    const names = schema.propertyNames;
+    if (names === undefined)
+        return NO_RULES;
+    const plugin = context.bag.objectPropertyNames;
+    return Object.freeze([
+        plugin.build(context.ruleContextFor(plugin.name, "propertyNames"), context.collectSubSchemaRules(names)),
+    ]);
+}
+function splitDependencies(dependencies) {
+    const required = {};
+    const schemas = {};
+    for (const [key, dependency] of Object.entries(dependencies)) {
+        if ((0, types_1.isStringArray)(dependency)) {
+            required[key] = dependency;
+            continue;
+        }
+        schemas[key] = (0, collect_definitions_1.toSchemaObject)(dependency);
+    }
+    return { required, schemas };
+}
+function declareDependencies(schema, context) {
+    const dependencies = schema.dependencies;
+    if (dependencies === undefined)
+        return NO_RULES;
+    const split = splitDependencies(dependencies);
+    const rules = [];
+    if (Object.keys(split.required).length > 0) {
+        const plugin = context.bag.objectDependentRequired;
+        rules.push(plugin.build(context.ruleContextFor(plugin.name, "dependencies"), Object.freeze(split.required)));
+    }
+    const schemaKeys = Object.keys(split.schemas);
+    if (schemaKeys.length > 0) {
+        const byKey = {};
+        for (const key of schemaKeys) {
+            const member = split.schemas[key];
+            if (member === undefined)
+                continue;
+            byKey[key] = context.collectSubSchemaRules(member);
+        }
+        const plugin = context.bag.objectDependentSchemas;
+        rules.push(plugin.build(context.ruleContextFor(plugin.name, "dependencies"), Object.freeze(byKey)));
+    }
+    return Object.freeze(rules);
+}
+/**
+ * `properties` becomes one declared path per key; see flatten-schema.ts.
+ *
+ * Every child is declared NOT required here: requiredness belongs to the object
+ * (declareRequiredProperties). A name in `required` with no `properties` entry
+ * still gets a path on the empty schema, because §6.5.3 makes the two keywords
+ * independent and the root distribution needs the path to exist.
+ */
+function readPropertyChildren(schema) {
+    const properties = schema.properties ?? {};
+    const required = schema.required ?? [];
+    const children = Object.entries(properties).map(([key, member]) => ({
+        step: key,
+        schema: member,
+        isRequired: false,
+    }));
+    for (const key of required) {
+        if (Object.prototype.hasOwnProperty.call(properties, key))
+            continue;
+        children.push({ step: key, schema: true, isRequired: false });
+    }
+    return Object.freeze(children);
+}

package/dist/json-schema/declare-object-keywords.mjs

@@ -0,0 +1,132 @@
+// ===========================================================================
+// L8  src/json-schema/declare-object-keywords.ts — the object keywords: the
+// three that bind, and the four object shapes that expand.
+//
+// THE NORMALISATIONS THE COMPILER FORCES (draft07-keyword-value.types.ts):
+//   additionalProperties  a schema is a sub-CHAIN and only the boolean form
+//                         binds. `declaredSiblingKeys` on the chain context is
+//                         set by schema-to-declarations to THIS schema's own
+//                         `properties` keys, so the plugin's allowed set is the
+//                         draft's — 1.x defaulted it to the empty list and
+//                         `additionalProperties: false` rejected every property.
+//   dependencies          one keyword, two chain methods: a key list drives
+//                         .dependentRequired(), a sub-schema .dependentSchemas().
+// ===========================================================================
+import { readChainRules } from "../chain/create-chain-node.mjs";
+import { createFieldSlots } from "../chain/create-field-slots.mjs";
+import { isStringArray } from "../types/index.mjs";
+import { applyKeywordBinding } from "./apply-keyword-binding.mjs";
+import { toSchemaObject } from "./collect-definitions.mjs";
+import { additionalPropertiesBinding, maxPropertiesBinding, minPropertiesBinding, } from "./keyword-map-object.mjs";
+const NO_RULES = Object.freeze([]);
+function readRules(chain) {
+    return readChainRules(chain) ?? NO_RULES;
+}
+export function declareObjectRules(schema, context) {
+    let chain = createFieldSlots(context.bag, context.build).object;
+    if (schema.minProperties !== undefined) {
+        chain = applyKeywordBinding(chain, minPropertiesBinding, schema.minProperties);
+    }
+    if (schema.maxProperties !== undefined) {
+        chain = applyKeywordBinding(chain, maxPropertiesBinding, schema.maxProperties);
+    }
+    const additional = schema.additionalProperties;
+    if (typeof additional === "boolean") {
+        chain = applyKeywordBinding(chain, additionalPropertiesBinding, additional);
+    }
+    return readRules(chain);
+}
+/** The SCHEMA form of `additionalProperties`: every undeclared value obeys it. */
+export function declareAdditionalPropertiesSchema(schema, context) {
+    const additional = schema.additionalProperties;
+    if (additional === undefined || typeof additional === "boolean") {
+        return NO_RULES;
+    }
+    const plugin = context.bag.objectAdditionalPropertiesSchema;
+    return Object.freeze([
+        plugin.build(context.ruleContextFor(plugin.name, "additionalProperties"), context.collectSubSchemaRules(additional)),
+    ]);
+}
+/** EVERY matching pattern applies; 1.x broke after the first match. */
+export function declarePatternProperties(schema, context) {
+    const patterns = schema.patternProperties;
+    if (patterns === undefined)
+        return NO_RULES;
+    const byPattern = {};
+    for (const [pattern, member] of Object.entries(patterns)) {
+        byPattern[pattern] = context.collectSubSchemaRules(member);
+    }
+    const plugin = context.bag.objectPatternProperties;
+    return Object.freeze([
+        plugin.build(context.ruleContextFor(plugin.name, "patternProperties"), Object.freeze(byPattern)),
+    ]);
+}
+/** A sub-chain over the property NAMES, which are always strings. */
+export function declarePropertyNames(schema, context) {
+    const names = schema.propertyNames;
+    if (names === undefined)
+        return NO_RULES;
+    const plugin = context.bag.objectPropertyNames;
+    return Object.freeze([
+        plugin.build(context.ruleContextFor(plugin.name, "propertyNames"), context.collectSubSchemaRules(names)),
+    ]);
+}
+function splitDependencies(dependencies) {
+    const required = {};
+    const schemas = {};
+    for (const [key, dependency] of Object.entries(dependencies)) {
+        if (isStringArray(dependency)) {
+            required[key] = dependency;
+            continue;
+        }
+        schemas[key] = toSchemaObject(dependency);
+    }
+    return { required, schemas };
+}
+export function declareDependencies(schema, context) {
+    const dependencies = schema.dependencies;
+    if (dependencies === undefined)
+        return NO_RULES;
+    const split = splitDependencies(dependencies);
+    const rules = [];
+    if (Object.keys(split.required).length > 0) {
+        const plugin = context.bag.objectDependentRequired;
+        rules.push(plugin.build(context.ruleContextFor(plugin.name, "dependencies"), Object.freeze(split.required)));
+    }
+    const schemaKeys = Object.keys(split.schemas);
+    if (schemaKeys.length > 0) {
+        const byKey = {};
+        for (const key of schemaKeys) {
+            const member = split.schemas[key];
+            if (member === undefined)
+                continue;
+            byKey[key] = context.collectSubSchemaRules(member);
+        }
+        const plugin = context.bag.objectDependentSchemas;
+        rules.push(plugin.build(context.ruleContextFor(plugin.name, "dependencies"), Object.freeze(byKey)));
+    }
+    return Object.freeze(rules);
+}
+/**
+ * `properties` becomes one declared path per key; see flatten-schema.ts.
+ *
+ * Every child is declared NOT required here: requiredness belongs to the object
+ * (declareRequiredProperties). A name in `required` with no `properties` entry
+ * still gets a path on the empty schema, because §6.5.3 makes the two keywords
+ * independent and the root distribution needs the path to exist.
+ */
+export function readPropertyChildren(schema) {
+    const properties = schema.properties ?? {};
+    const required = schema.required ?? [];
+    const children = Object.entries(properties).map(([key, member]) => ({
+        step: key,
+        schema: member,
+        isRequired: false,
+    }));
+    for (const key of required) {
+        if (Object.prototype.hasOwnProperty.call(properties, key))
+            continue;
+        children.push({ step: key, schema: true, isRequired: false });
+    }
+    return Object.freeze(children);
+}

package/dist/json-schema/declare-presence.d.ts

@@ -0,0 +1,12 @@
+import type { Rule } from "../plugin-kit/compiled-rule";
+import type { IssueSeverity } from "../types";
+export interface PresenceDeclaration {
+    readonly isRequired: boolean;
+    readonly allowsNull: boolean;
+    readonly severity: IssueSeverity;
+}
+/**
+ * A field that may be absent AND may be null needs no rule at all: that is
+ * OPEN_PRESENCE, the policy a field with no presence rule already carries.
+ */
+export declare function declarePresenceRules(declaration: PresenceDeclaration): readonly Rule[];

package/dist/json-schema/declare-presence.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.declarePresenceRules = declarePresenceRules;
+// ===========================================================================
+// L8  src/json-schema/declare-presence.ts — is this property allowed to be
+// ABSENT, and is it allowed to be NULL?
+//
+// Draft-07 answers with two different keywords in two different places: the
+// PARENT's `required` array decides absence, and the child's own `type` decides
+// null (a `type` that omits "null" forbids it; NO `type` at all forbids
+// nothing). Luq answers with one merged PresencePolicy per field, so the two
+// have to be resolved together — which is also why this is not the `required`
+// KEYWORD BINDING from keyword-map-object.ts.
+//
+// WHY NOT `.required()` (measured, and a deliberate deviation): requiredPlugin
+// declares `emptyStringIsMissing: true`, carried over verbatim from 1.x's
+// form-oriented emptiness, and src/compile/resolve-presence.ts merges that flag
+// with `.some()`, so no companion rule can switch it back off. Under
+// `.required()` the document `{"name": ""}` therefore FAILS `required: ["name"]`,
+// which Draft-07 §6.5.3 permits — the keyword is about the property being
+// PRESENT, not about it being non-empty. The policy below is the same rule kind
+// from the same factory with `emptyStringIsMissing: false`.
+// ===========================================================================
+const create_rule_1 = require("../plugin-kit/create-rule");
+/**
+ * A field that may be absent AND may be null needs no rule at all: that is
+ * OPEN_PRESENCE, the policy a field with no presence rule already carries.
+ */
+function declarePresenceRules(declaration) {
+    if (!declaration.isRequired && declaration.allowsNull) {
+        return Object.freeze([]);
+    }
+    return Object.freeze([
+        (0, create_rule_1.presence)({
+            code: declaration.isRequired ? "required" : "type",
+            severity: declaration.severity,
+            allowUndefined: !declaration.isRequired,
+            allowNull: declaration.allowsNull,
+            emptyStringIsMissing: false,
+            describe: (messageContext) => declaration.isRequired
+                ? `${messageContext.path} is required`
+                : `${messageContext.path} must not be null`,
+            buildMessageContext: () => ({}),
+        }),
+    ]);
+}

package/dist/json-schema/declare-presence.mjs

@@ -0,0 +1,43 @@
+// ===========================================================================
+// L8  src/json-schema/declare-presence.ts — is this property allowed to be
+// ABSENT, and is it allowed to be NULL?
+//
+// Draft-07 answers with two different keywords in two different places: the
+// PARENT's `required` array decides absence, and the child's own `type` decides
+// null (a `type` that omits "null" forbids it; NO `type` at all forbids
+// nothing). Luq answers with one merged PresencePolicy per field, so the two
+// have to be resolved together — which is also why this is not the `required`
+// KEYWORD BINDING from keyword-map-object.ts.
+//
+// WHY NOT `.required()` (measured, and a deliberate deviation): requiredPlugin
+// declares `emptyStringIsMissing: true`, carried over verbatim from 1.x's
+// form-oriented emptiness, and src/compile/resolve-presence.ts merges that flag
+// with `.some()`, so no companion rule can switch it back off. Under
+// `.required()` the document `{"name": ""}` therefore FAILS `required: ["name"]`,
+// which Draft-07 §6.5.3 permits — the keyword is about the property being
+// PRESENT, not about it being non-empty. The policy below is the same rule kind
+// from the same factory with `emptyStringIsMissing: false`.
+// ===========================================================================
+import { presence } from "../plugin-kit/create-rule.mjs";
+/**
+ * A field that may be absent AND may be null needs no rule at all: that is
+ * OPEN_PRESENCE, the policy a field with no presence rule already carries.
+ */
+export function declarePresenceRules(declaration) {
+    if (!declaration.isRequired && declaration.allowsNull) {
+        return Object.freeze([]);
+    }
+    return Object.freeze([
+        presence({
+            code: declaration.isRequired ? "required" : "type",
+            severity: declaration.severity,
+            allowUndefined: !declaration.isRequired,
+            allowNull: declaration.allowsNull,
+            emptyStringIsMissing: false,
+            describe: (messageContext) => declaration.isRequired
+                ? `${messageContext.path} is required`
+                : `${messageContext.path} must not be null`,
+            buildMessageContext: () => ({}),
+        }),
+    ]);
+}

package/dist/json-schema/declare-required-properties.d.ts

@@ -0,0 +1,18 @@
+import type { Rule } from "../plugin-kit/compiled-rule";
+import type { Draft07SchemaObject } from "./draft07.types";
+import type { StructuralContext } from "./structural-expansion.types";
+/**
+ * `required` as a rule on the OBJECT, not as a presence rule on each child.
+ *
+ * The difference decides a verdict. A child's presence rule fires whenever the
+ * child reads `undefined`, which includes the case where the PARENT is absent —
+ * so `{properties:{a:{properties:{b:{}},required:["b"]}}}` would refuse `{}`,
+ * although Draft-07 applies a sub-schema only to a value that is there. Asking
+ * the object itself asks the question the draft asks, and §6.5.3 also says a
+ * NON-object is none of `required`'s business, which is why a non-object passes.
+ *
+ * The document ROOT is the exception and is handled in flatten-schema.ts: it has
+ * no declarable path to carry this rule, and it is always present anyway
+ * (src/runtime/create-validator.ts refuses a missing root before the plan runs).
+ */
+export declare function declareRequiredProperties(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];

package/dist/json-schema/declare-required-properties.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.declareRequiredProperties = declareRequiredProperties;
+// ===========================================================================
+// L8  src/json-schema/declare-required-properties.ts — `required`, as a rule on
+// the OBJECT rather than on each named child.
+//
+// The distinction decides verdicts, so it is worth a file of its own. See the
+// doc comment below; the short version is that a child's presence rule cannot
+// tell "the property is missing from an object that IS there" from "the whole
+// object is absent", and Draft-07 applies a sub-schema only to a value that is
+// there.
+//
+// This is also the reason the `required` KEYWORD BINDING in keyword-map-object.ts
+// is not the mechanism here: `.required()` is a presence rule on ONE field, and
+// it additionally treats "" as absent (1.x's form emptiness), which §6.5.3 does
+// not. The binding stays as the type-checked record that `required` maps to
+// `.required()`; the converter needs the object-level question instead.
+// ===========================================================================
+const create_rule_1 = require("../plugin-kit/create-rule");
+const types_1 = require("../types");
+const NO_RULES = Object.freeze([]);
+/**
+ * `required` as a rule on the OBJECT, not as a presence rule on each child.
+ *
+ * The difference decides a verdict. A child's presence rule fires whenever the
+ * child reads `undefined`, which includes the case where the PARENT is absent —
+ * so `{properties:{a:{properties:{b:{}},required:["b"]}}}` would refuse `{}`,
+ * although Draft-07 applies a sub-schema only to a value that is there. Asking
+ * the object itself asks the question the draft asks, and §6.5.3 also says a
+ * NON-object is none of `required`'s business, which is why a non-object passes.
+ *
+ * The document ROOT is the exception and is handled in flatten-schema.ts: it has
+ * no declarable path to carry this rule, and it is always present anyway
+ * (src/runtime/create-validator.ts refuses a missing root before the plan runs).
+ */
+function declareRequiredProperties(schema, context) {
+    const required = schema.required;
+    if (required === undefined || required.length === 0)
+        return NO_RULES;
+    const missingOf = (value) => required.filter((key) => !Object.prototype.hasOwnProperty.call(value, key));
+    return Object.freeze([
+        (0, create_rule_1.check)({
+            code: "required",
+            severity: context.build.config.defaultSeverity,
+            run: (value) => {
+                if (!(0, types_1.isPlainObject)(value))
+                    return types_1.PASS;
+                const missing = missingOf(value);
+                return missing.length === 0
+                    ? types_1.PASS
+                    : (0, types_1.fail)({ expected: required, actual: missing });
+            },
+            describe: (detail) => `Missing required propert${(0, types_1.isArray)(detail.actual) && detail.actual.length === 1 ? "y" : "ies"}: ${String(detail.actual)}`,
+            buildMessageContext: () => ({}),
+        }),
+    ]);
+}

package/dist/json-schema/declare-required-properties.mjs

@@ -0,0 +1,55 @@
+// ===========================================================================
+// L8  src/json-schema/declare-required-properties.ts — `required`, as a rule on
+// the OBJECT rather than on each named child.
+//
+// The distinction decides verdicts, so it is worth a file of its own. See the
+// doc comment below; the short version is that a child's presence rule cannot
+// tell "the property is missing from an object that IS there" from "the whole
+// object is absent", and Draft-07 applies a sub-schema only to a value that is
+// there.
+//
+// This is also the reason the `required` KEYWORD BINDING in keyword-map-object.ts
+// is not the mechanism here: `.required()` is a presence rule on ONE field, and
+// it additionally treats "" as absent (1.x's form emptiness), which §6.5.3 does
+// not. The binding stays as the type-checked record that `required` maps to
+// `.required()`; the converter needs the object-level question instead.
+// ===========================================================================
+import { check } from "../plugin-kit/create-rule.mjs";
+import { PASS, fail, isArray, isPlainObject } from "../types/index.mjs";
+const NO_RULES = Object.freeze([]);
+/**
+ * `required` as a rule on the OBJECT, not as a presence rule on each child.
+ *
+ * The difference decides a verdict. A child's presence rule fires whenever the
+ * child reads `undefined`, which includes the case where the PARENT is absent —
+ * so `{properties:{a:{properties:{b:{}},required:["b"]}}}` would refuse `{}`,
+ * although Draft-07 applies a sub-schema only to a value that is there. Asking
+ * the object itself asks the question the draft asks, and §6.5.3 also says a
+ * NON-object is none of `required`'s business, which is why a non-object passes.
+ *
+ * The document ROOT is the exception and is handled in flatten-schema.ts: it has
+ * no declarable path to carry this rule, and it is always present anyway
+ * (src/runtime/create-validator.ts refuses a missing root before the plan runs).
+ */
+export function declareRequiredProperties(schema, context) {
+    const required = schema.required;
+    if (required === undefined || required.length === 0)
+        return NO_RULES;
+    const missingOf = (value) => required.filter((key) => !Object.prototype.hasOwnProperty.call(value, key));
+    return Object.freeze([
+        check({
+            code: "required",
+            severity: context.build.config.defaultSeverity,
+            run: (value) => {
+                if (!isPlainObject(value))
+                    return PASS;
+                const missing = missingOf(value);
+                return missing.length === 0
+                    ? PASS
+                    : fail({ expected: required, actual: missing });
+            },
+            describe: (detail) => `Missing required propert${isArray(detail.actual) && detail.actual.length === 1 ? "y" : "ies"}: ${String(detail.actual)}`,
+            buildMessageContext: () => ({}),
+        }),
+    ]);
+}

package/dist/json-schema/declare-scalar-keywords.d.ts

@@ -0,0 +1,11 @@
+import type { Rule } from "../plugin-kit/compiled-rule";
+import type { Draft07SchemaObject } from "./draft07.types";
+import type { StructuralContext } from "./structural-expansion.types";
+export declare function declareStringRules(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];
+/**
+ * Draft-07 §7.2: an unknown format is an ANNOTATION and passes. A format the
+ * table declares out of scope is a different answer and throws — 1.x confused
+ * the two and its validator and its error generator disagreed about which.
+ */
+export declare function declareFormatRules(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];
+export declare function declareNumberRules(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];

package/dist/json-schema/declare-scalar-keywords.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.declareStringRules = declareStringRules;
+exports.declareFormatRules = declareFormatRules;
+exports.declareNumberRules = declareNumberRules;
+// ===========================================================================
+// L8  src/json-schema/declare-scalar-keywords.ts — the keywords that BIND.
+//
+// Every call below goes through applyKeywordBinding, so the chain method a
+// keyword drives is checked by the compiler against the plugin that declares
+// it. That is the whole reason step 24 exists: 1.x wrote
+// `chain.minItems && chain.minItems(n)` and the constraint evaporated.
+//
+// The slot chains are built and driven here, but a slot is NOT a filter: every
+// bound plugin in the bag passes a wrong-typed value on purpose (see
+// string-min.ts: "a wrong-typed value PASSES"), which is exactly Draft-07 §6 —
+// `minLength` says nothing about a number. So the converter applies the string
+// keywords AND the number keywords whenever they appear, without first deciding
+// what the value will be, and `type` (declare-value-keywords.ts) is the only rule
+// that judges the type. That is also what makes `type: ["string","number"]`
+// with a `minLength` correct rather than approximated.
+// ===========================================================================
+const create_chain_node_1 = require("../chain/create-chain-node");
+const create_field_slots_1 = require("../chain/create-field-slots");
+const apply_keyword_binding_1 = require("./apply-keyword-binding");
+const format_map_1 = require("./format-map");
+const keyword_map_number_1 = require("./keyword-map-number");
+const keyword_map_string_1 = require("./keyword-map-string");
+const unsupported_keyword_error_1 = require("./unsupported-keyword-error");
+const NO_RULES = Object.freeze([]);
+/** Total over the plugin's own union, so a new encoding breaks THIS line. */
+const CONTENT_ENCODING_NAMES = {
+    base64: true,
+    base32: true,
+    binary: true,
+    "7bit": true,
+    "8bit": true,
+    "quoted-printable": true,
+};
+function isContentEncodingName(name) {
+    return Object.prototype.hasOwnProperty.call(CONTENT_ENCODING_NAMES, name);
+}
+function readRules(chain) {
+    return (0, create_chain_node_1.readChainRules)(chain) ?? NO_RULES;
+}
+function emptyStringChain(bag, context) {
+    return (0, create_field_slots_1.createFieldSlots)(bag, context.build)
+        .string;
+}
+function declareStringRules(schema, context) {
+    let chain = emptyStringChain(context.bag, context);
+    if (schema.minLength !== undefined) {
+        chain = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_string_1.minLengthBinding, schema.minLength);
+    }
+    if (schema.maxLength !== undefined) {
+        chain = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_string_1.maxLengthBinding, schema.maxLength);
+    }
+    if (schema.pattern !== undefined) {
+        chain = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_string_1.patternBinding, schema.pattern);
+    }
+    if (schema.contentMediaType !== undefined) {
+        chain = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_string_1.contentMediaTypeBinding, schema.contentMediaType);
+    }
+    const encoding = schema.contentEncoding;
+    if (encoding !== undefined) {
+        if (!isContentEncodingName(encoding)) {
+            throw new unsupported_keyword_error_1.UnsupportedKeywordError("contentEncoding", `"${encoding}" is not one of the encodings stringContentEncoding ` +
+                "recognises; 1.x accepted every unknown name and validated nothing");
+        }
+        chain = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_string_1.contentEncodingBinding, encoding);
+    }
+    return readRules(chain);
+}
+/**
+ * Draft-07 §7.2: an unknown format is an ANNOTATION and passes. A format the
+ * table declares out of scope is a different answer and throws — 1.x confused
+ * the two and its validator and its error generator disagreed about which.
+ */
+function declareFormatRules(schema, context) {
+    const format = schema.format;
+    if (format === undefined)
+        return NO_RULES;
+    const handling = (0, format_map_1.findFormatHandling)(format);
+    if (handling === undefined)
+        return NO_RULES;
+    if (handling.handling === "unsupported") {
+        throw new unsupported_keyword_error_1.UnsupportedKeywordError(`format: ${format}`, handling.reason);
+    }
+    const chain = emptyStringChain(context.bag, context);
+    return readRules((0, apply_keyword_binding_1.applyKeywordBinding)(chain, handling, "format"));
+}
+function declareNumberRules(schema, context) {
+    let chain = (0, create_field_slots_1.createFieldSlots)(context.bag, context.build).number;
+    if (schema.minimum !== undefined) {
+        chain = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_number_1.minimumBinding, schema.minimum);
+    }
+    if (schema.maximum !== undefined) {
+        chain = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_number_1.maximumBinding, schema.maximum);
+    }
+    if (schema.exclusiveMinimum !== undefined) {
+        chain = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_number_1.exclusiveMinimumBinding, schema.exclusiveMinimum);
+    }
+    if (schema.exclusiveMaximum !== undefined) {
+        chain = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_number_1.exclusiveMaximumBinding, schema.exclusiveMaximum);
+    }
+    if (schema.multipleOf !== undefined) {
+        chain = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_number_1.multipleOfBinding, schema.multipleOf);
+    }
+    return readRules(chain);
+}