@maroonedog/luq 2.4.0 → 2.4.1

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.4.0",
+  "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",