@maroonedog/luq 2.3.1 → 2.4.1

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

@@ -0,0 +1,7 @@
+export { flattenSchema } from "../json-schema";
+export type { ReadChildSchemas, SchemaFieldDeclaration } from "../json-schema";
+export { readChildSchemas } from "../json-schema";
+export { isDraft07Schema, isSchemaObject } from "../json-schema";
+/** The vocabulary itself: what a tool must have a decision for. */
+export { listDraft07Keywords } from "../json-schema";
+export type { ChildSchema, Draft07Schema, Draft07SchemaObject, } from "../json-schema";

package/dist/schema-tooling/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listDraft07Keywords = exports.isSchemaObject = exports.isDraft07Schema = exports.readChildSchemas = exports.flattenSchema = void 0;
+// ===========================================================================
+// src/schema-tooling/index.ts — re-exports only. Nothing is defined here.
+//
+// The surface published as `@maroonedog/luq/schema-tooling`, for a tool that
+// reads a JSON Schema document at build time instead of validating one at run
+// time — a code generator, above all.
+//
+// It is listed by hand and kept short on purpose. Everything named here is
+// public API from the moment it ships, so the file answers one question only:
+// what does a generator need in order to decide the same field paths the
+// run-time conversion decides? Anything a generator does not need stays
+// internal, and re-exporting the whole layer would have frozen all of it.
+// ===========================================================================
+var json_schema_1 = require("../json-schema");
+Object.defineProperty(exports, "flattenSchema", { enumerable: true, get: function () { return json_schema_1.flattenSchema; } });
+var json_schema_2 = require("../json-schema");
+Object.defineProperty(exports, "readChildSchemas", { enumerable: true, get: function () { return json_schema_2.readChildSchemas; } });
+var json_schema_3 = require("../json-schema");
+Object.defineProperty(exports, "isDraft07Schema", { enumerable: true, get: function () { return json_schema_3.isDraft07Schema; } });
+Object.defineProperty(exports, "isSchemaObject", { enumerable: true, get: function () { return json_schema_3.isSchemaObject; } });
+/** The vocabulary itself: what a tool must have a decision for. */
+var json_schema_4 = require("../json-schema");
+Object.defineProperty(exports, "listDraft07Keywords", { enumerable: true, get: function () { return json_schema_4.listDraft07Keywords; } });

package/dist/schema-tooling/index.mjs

@@ -0,0 +1,18 @@
+// ===========================================================================
+// src/schema-tooling/index.ts — re-exports only. Nothing is defined here.
+//
+// The surface published as `@maroonedog/luq/schema-tooling`, for a tool that
+// reads a JSON Schema document at build time instead of validating one at run
+// time — a code generator, above all.
+//
+// It is listed by hand and kept short on purpose. Everything named here is
+// public API from the moment it ships, so the file answers one question only:
+// what does a generator need in order to decide the same field paths the
+// run-time conversion decides? Anything a generator does not need stays
+// internal, and re-exporting the whole layer would have frozen all of it.
+// ===========================================================================
+export { flattenSchema } from "../json-schema/index.mjs";
+export { readChildSchemas } from "../json-schema/index.mjs";
+export { isDraft07Schema, isSchemaObject } from "../json-schema/index.mjs";
+/** The vocabulary itself: what a tool must have a decision for. */
+export { listDraft07Keywords } from "../json-schema/index.mjs";

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

@@ -55,6 +55,16 @@ function emitFieldSchema(fieldPath, calls, policy) {
             continue;
         }
         const keywords = toKeywords(call.args);
+        // undefined is the table saying it cannot express THESE arguments, which
+        // is the same answer as having no entry at all: refuse, rather than emit a
+        // schema missing a constraint the validator enforces. null is different —
+        // it means type or presence already carries the declaration.
+        if (keywords === undefined) {
+            if (policy === "throw") {
+                throw new unrepresentable_rule_error_1.UnrepresentableRuleError(fieldPath, call.pluginName, "no JSON Schema keyword expresses the arguments it was given");
+            }
+            continue;
+        }
         if (keywords === null)
             continue;
         Object.assign(schema, keywords);

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

@@ -52,6 +52,16 @@ export function emitFieldSchema(fieldPath, calls, policy) {
             continue;
         }
         const keywords = toKeywords(call.args);
+        // undefined is the table saying it cannot express THESE arguments, which
+        // is the same answer as having no entry at all: refuse, rather than emit a
+        // schema missing a constraint the validator enforces. null is different —
+        // it means type or presence already carries the declaration.
+        if (keywords === undefined) {
+            if (policy === "throw") {
+                throw new UnrepresentableRuleError(fieldPath, call.pluginName, "no JSON Schema keyword expresses the arguments it was given");
+            }
+            continue;
+        }
         if (keywords === null)
             continue;
         Object.assign(schema, keywords);

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

@@ -1,3 +1,16 @@
-/** A keyword fragment made from the arguments; null means type or presence handles it. */
-export type ToKeywords = (args: readonly unknown[]) => Record<string, unknown> | null;
+/**
+ * A keyword fragment made from the arguments. Three answers, and the
+ * difference between the last two is the point:
+ *
+ *   an object   the keywords this declaration means
+ *   null        it adds no keyword, and that is correct — type or presence
+ *               already carries it
+ *   undefined   it cannot be expressed with these arguments, so the caller
+ *               must refuse rather than emit a schema that quietly says
+ *               something else
+ *
+ * Collapsing the last two into `null` is how a constraint disappears without
+ * a trace, which is the failure UnrepresentableRuleError exists to prevent.
+ */
+export type ToKeywords = (args: readonly unknown[]) => Record<string, unknown> | null | undefined;
 export declare const PLUGIN_KEYWORDS: Readonly<Record<string, ToKeywords>>;

package/dist/standard-schema/plugin-keyword-map.js

@@ -37,9 +37,14 @@ exports.PLUGIN_KEYWORDS = Object.freeze({
         maxLength: numberAt(args, 0),
     }),
     // Draft-07's `pattern` is an ECMA-262 SOURCE string. Flags cannot be
-    // spelled there, and dropping them changes the meaning, so a flagged
-    // RegExp counts as unwritable rather than being silently narrowed.
-    stringPattern: (args) => args[0] instanceof RegExp ? { pattern: args[0].source } : null,
+    // spelled there, and dropping them changes the meaning — `/^a.c$/i`
+    // accepts "ABC" and `{"pattern":"^a.c$"}` does not — so a flagged RegExp
+    // is unwritable rather than something to narrow quietly. Anything that is
+    // not a RegExp at all is unwritable for the same reason: refusing is the
+    // only answer that does not lose the constraint in silence.
+    stringPattern: (args) => args[0] instanceof RegExp && args[0].flags === ""
+        ? { pattern: args[0].source }
+        : undefined,
     stringContentEncoding: (args) => ({ contentEncoding: args[0] }),
     stringContentMediaType: (args) => ({ contentMediaType: args[0] }),
     // --- formats (names taken verbatim from the format map) ---------------
@@ -81,7 +86,9 @@ exports.PLUGIN_KEYWORDS = Object.freeze({
     arrayUnique: () => ({ uniqueItems: true }),
     // --- values -----------------------------------------------------------
     literal: (args) => ({ const: args[0] }),
-    oneOf: (args) => (Array.isArray(args[0]) ? { enum: args[0] } : null),
+    // `enum` needs the list itself. Given something else there is no list to
+    // write, and answering "no keyword" would drop the constraint.
+    oneOf: (args) => (Array.isArray(args[0]) ? { enum: args[0] } : undefined),
     // --- handled by type or presence, adding no keyword -------------------
     // numberInteger becomes `type: "integer"`, so it feeds the type decision.
     numberInteger: () => null,

package/dist/standard-schema/plugin-keyword-map.mjs

@@ -34,9 +34,14 @@ export const PLUGIN_KEYWORDS = Object.freeze({
         maxLength: numberAt(args, 0),
     }),
     // Draft-07's `pattern` is an ECMA-262 SOURCE string. Flags cannot be
-    // spelled there, and dropping them changes the meaning, so a flagged
-    // RegExp counts as unwritable rather than being silently narrowed.
-    stringPattern: (args) => args[0] instanceof RegExp ? { pattern: args[0].source } : null,
+    // spelled there, and dropping them changes the meaning — `/^a.c$/i`
+    // accepts "ABC" and `{"pattern":"^a.c$"}` does not — so a flagged RegExp
+    // is unwritable rather than something to narrow quietly. Anything that is
+    // not a RegExp at all is unwritable for the same reason: refusing is the
+    // only answer that does not lose the constraint in silence.
+    stringPattern: (args) => args[0] instanceof RegExp && args[0].flags === ""
+        ? { pattern: args[0].source }
+        : undefined,
     stringContentEncoding: (args) => ({ contentEncoding: args[0] }),
     stringContentMediaType: (args) => ({ contentMediaType: args[0] }),
     // --- formats (names taken verbatim from the format map) ---------------
@@ -78,7 +83,9 @@ export const PLUGIN_KEYWORDS = Object.freeze({
     arrayUnique: () => ({ uniqueItems: true }),
     // --- values -----------------------------------------------------------
     literal: (args) => ({ const: args[0] }),
-    oneOf: (args) => (Array.isArray(args[0]) ? { enum: args[0] } : null),
+    // `enum` needs the list itself. Given something else there is no list to
+    // write, and answering "no keyword" would drop the constraint.
+    oneOf: (args) => (Array.isArray(args[0]) ? { enum: args[0] } : undefined),
     // --- handled by type or presence, adding no keyword -------------------
     // numberInteger becomes `type: "integer"`, so it feeds the type decision.
     numberInteger: () => null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maroonedog/luq",
-  "version": "2.3.1",
+  "version": "2.4.1",
   "description": "Universal Model & API Definition Platform - TypeScript validation library evolving into cross-language code generation",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -47,6 +47,11 @@
       "import": "./dist/plugins/index.mjs",
       "require": "./dist/plugins/index.js"
     },
+    "./schema-tooling": {
+      "types": "./dist/schema-tooling/index.d.ts",
+      "import": "./dist/schema-tooling/index.mjs",
+      "require": "./dist/schema-tooling/index.js"
+    },
     "./plugins/arrayContains": {
       "types": "./dist/plugins/arrayContains.d.ts",
       "import": "./dist/plugins/arrayContains.mjs",