@maroonedog/luq 0.1.2-alpha → 2.0.0

package/dist/plugins/objectMinProperties.d.ts

@@ -1,42 +1 @@
-import { ValidationOptions } from "../core/plugin/types";
-/**
- * @luq-plugin
- * @name objectMinProperties
- * @category standard
- * @description Validates that an object has at least the specified minimum number of properties
- * @allowedTypes ["object"]
- * @example
- * ```typescript
- * // Basic usage - ensure object has minimum properties
- * const validator = Builder()
- *   .use(objectMinPropertiesPlugin)
- *   .for<ConfigObject>()
- *   .v("metadata", (b) => b.object.minProperties(2))
- *   .v("settings", (b) => b.object.minProperties(1))
- *   .build();
- *
- * // With custom error message
- * builder.v("config", b => b.object.minProperties(3, {
- *   messageFactory: ({ path, params }) =>
- *     `${path} must have at least ${params.min} properties`
- * }))
- * ```
- * @params
- * - min: number - Minimum number of properties required
- * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
- * @returns Validation function that returns true if object has at least minimum properties
- * @customError
- * ```typescript
- * .minProperties(3, {
- *   messageFactory: ({ path, value, params }) =>
- *     `${path} requires at least ${params.min} properties (has ${Object.keys(value).length})`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-export declare const objectMinPropertiesPlugin: import("../index").TypedPlugin<"objectMinProperties", "minProperties", (minValue: number, options?: ValidationOptions) => {
-    check: (value: any) => boolean;
-    code: string;
-    getErrorMessage: (value: any, path: string) => string;
-    params: (number | ValidationOptions<{}>)[];
-}, readonly ["object"], "validator", "standard">;
+export * from "./object-min-properties/index";

package/dist/plugins/objectMinProperties.js

@@ -1 +1,2 @@
-"use strict";var l=Object.defineProperty;var T=Object.getOwnPropertyDescriptor;var u=Object.getOwnPropertyNames;var d=Object.prototype.hasOwnProperty;var g=(n,t)=>{for(var r in t)l(n,r,{get:t[r],enumerable:!0})},y=(n,t,r,s)=>{if(t&&typeof t=="object"||typeof t=="function")for(let e of u(t))!d.call(n,e)&&e!==r&&l(n,e,{get:()=>t[e],enumerable:!(s=T(t,e))||s.enumerable});return n};var c=n=>y(l({},"__esModule",{value:!0}),n);var I={};g(I,{objectMinPropertiesPlugin:()=>x});module.exports=c(I);var f=(n,t,r,s)=>{let o=(a=>(...i)=>{let m=a(...i);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:s}:m})(r);switch(n){case"conditional":return(a,...i)=>o(a,...i);case"fieldReference":return(a,...i)=>o(a,...i);case"multiFieldReference":return o;case"transform":return a=>o(a);case"arrayElement":return(a,...i)=>o(a,...i);case"context":return a=>o(a);default:return o}};function p(n){let{name:t,methodName:r,allowedTypes:s,category:e,impl:o}=n;return{name:t,methodName:r,allowedTypes:s,category:e,create:()=>f(e,r,o,t)}}var N="objectMinProperties",h=["object"],x=p({name:"objectMinProperties",methodName:"minProperties",allowedTypes:h,category:"standard",impl:(n,t)=>{let r=t?.code||N,s=t?.messageFactory||(e=>`Must have at least ${e.min} properties, but has ${e.actual}`);if(typeof n!="number"||isNaN(n)||n<0)throw new Error(`Invalid minValue: ${n}. Must be a non-negative number.`);return{check:e=>typeof e!="object"||e===null?!0:Object.keys(e).length>=n,code:r,getErrorMessage:(e,o)=>{let a=typeof e=="object"&&e!==null?Object.keys(e).length:0;return s({path:o,value:e,code:r,min:n,actual:a})},params:[n,t]}}});0&&(module.exports={objectMinPropertiesPlugin});
+"use strict";
+module.exports = require("./object-min-properties/index");

package/dist/plugins/objectMinProperties.mjs

@@ -1 +1 @@
-var p=(a,o,s,i)=>{let t=(n=>(...r)=>{let m=n(...r);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:i}:m})(s);switch(a){case"conditional":return(n,...r)=>t(n,...r);case"fieldReference":return(n,...r)=>t(n,...r);case"multiFieldReference":return t;case"transform":return n=>t(n);case"arrayElement":return(n,...r)=>t(n,...r);case"context":return n=>t(n);default:return t}};function l(a){let{name:o,methodName:s,allowedTypes:i,category:e,impl:t}=a;return{name:o,methodName:s,allowedTypes:i,category:e,create:()=>p(e,s,t,o)}}var T="objectMinProperties",u=["object"],y=l({name:"objectMinProperties",methodName:"minProperties",allowedTypes:u,category:"standard",impl:(a,o)=>{let s=o?.code||T,i=o?.messageFactory||(e=>`Must have at least ${e.min} properties, but has ${e.actual}`);if(typeof a!="number"||isNaN(a)||a<0)throw new Error(`Invalid minValue: ${a}. Must be a non-negative number.`);return{check:e=>typeof e!="object"||e===null?!0:Object.keys(e).length>=a,code:s,getErrorMessage:(e,t)=>{let n=typeof e=="object"&&e!==null?Object.keys(e).length:0;return i({path:t,value:e,code:s,min:a,actual:n})},params:[a,o]}}});export{y as objectMinPropertiesPlugin};
+export * from "./object-min-properties/index.mjs";

package/dist/plugins/objectPatternProperties.d.ts

@@ -1,46 +1 @@
-/**
- * @luq-plugin
- * @name objectPatternProperties
- * @category object
- * @description Validates object properties that match specific patterns with corresponding schemas
- * @allowedTypes ["object"]
- * @example
- * ```typescript
- * // Pattern-based property validation
- * const validator = Builder()
- *   .use(objectPatternPropertiesPlugin)
- *   .for<{ [key: string]: any }>()
- *   .v("config", (b) => b.object.patternProperties({
- *     "^str_": (value) => typeof value === "string",
- *     "^num_": (value) => typeof value === "number"
- *   }))
- *   .build();
- *
- * // With custom validators and messages
- * builder.v("data", b => b.object.patternProperties({
- *   "^email_": {
- *     validator: (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value),
- *     message: "Email properties must be valid email addresses"
- *   },
- *   "^id_": {
- *     validator: (value) => typeof value === "string" && value.length > 0,
- *     message: "ID properties must be non-empty strings"
- *   }
- * }))
- * ```
- * @params
- * - patterns: Record<string, (value: any) => boolean | PatternValidator> - Pattern to validator mapping
- * @returns Validation function that checks properties matching patterns
- * @since 0.1.0-alpha
- */
-export interface PatternValidator {
-    validator: (value: any) => boolean;
-    message?: string;
-}
-export type PatternPropertiesSchema = Record<string, ((value: any) => boolean) | PatternValidator>;
-export declare const objectPatternPropertiesPlugin: import("../index").TypedPlugin<"objectPatternProperties", "patternProperties", (patterns: PatternPropertiesSchema) => {
-    check: (value: any) => boolean;
-    code: string;
-    getErrorMessage: (value: any, path: string) => string;
-    params: PatternPropertiesSchema[];
-}, readonly ["object"], "validator", "standard">;
+export * from "./object-pattern-properties/index";

package/dist/plugins/objectPatternProperties.js

@@ -1 +1,2 @@
-"use strict";var u=Object.defineProperty;var g=Object.getOwnPropertyDescriptor;var y=Object.getOwnPropertyNames;var c=Object.prototype.hasOwnProperty;var f=(r,e)=>{for(var o in e)u(r,o,{get:e[o],enumerable:!0})},N=(r,e,o,l)=>{if(e&&typeof e=="object"||typeof e=="function")for(let i of y(e))!c.call(r,i)&&i!==o&&u(r,i,{get:()=>e[i],enumerable:!(l=g(e,i))||l.enumerable});return r};var P=r=>N(u({},"__esModule",{value:!0}),r);var I={};f(I,{objectPatternPropertiesPlugin:()=>x});module.exports=P(I);var h=(r,e,o,l)=>{let n=(t=>(...a)=>{let m=t(...a);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:l}:m})(o);switch(r){case"conditional":return(t,...a)=>n(t,...a);case"fieldReference":return(t,...a)=>n(t,...a);case"multiFieldReference":return n;case"transform":return t=>n(t);case"arrayElement":return(t,...a)=>n(t,...a);case"context":return t=>n(t);default:return n}};function d(r){let{name:e,methodName:o,allowedTypes:l,category:i,impl:n}=r;return{name:e,methodName:o,allowedTypes:l,category:i,create:()=>h(i,o,n,e)}}var x=d({name:"objectPatternProperties",methodName:"patternProperties",allowedTypes:["object"],category:"standard",impl:r=>({check:e=>{if(!e||typeof e!="object"||Array.isArray(e))return!1;let o=Object.keys(e),l=Object.entries(r);for(let i of o){let n=e[i];for(let[t,a]of l)if(new RegExp(t).test(i)){let s=!1;if(typeof a=="function"?s=a(n):typeof a=="object"&&a!==null&&"validator"in a&&(s=a.validator(n)),!s)return!1;break}}return!0},code:"PATTERN_PROPERTIES",getErrorMessage:(e,o)=>{let l=Object.keys(e||{}),i=Object.entries(r),n=[];for(let t of l){let a=e[t];for(let[m,s]of i)if(new RegExp(m).test(t)){let p=!1,T;typeof s=="function"?p=s(a):typeof s=="object"&&s!==null&&"validator"in s&&(p=s.validator(a),T=s.message),p||(T?n.push(`${t}: ${T}`):n.push(`${t} (matching pattern ${m}) has invalid value`));break}}return n.length>0?`${o} has pattern property violations: ${n.join(", ")}`:`${o} has invalid pattern properties`},params:[r]})});0&&(module.exports={objectPatternPropertiesPlugin});
+"use strict";
+module.exports = require("./object-pattern-properties/index");

package/dist/plugins/objectPatternProperties.mjs

@@ -1 +1 @@
-var d=(l,a,o,m)=>{let t=(e=>(...n)=>{let i=e(...n);return i&&typeof i=="object"&&"check"in i?{...i,pluginName:m}:i})(o);switch(l){case"conditional":return(e,...n)=>t(e,...n);case"fieldReference":return(e,...n)=>t(e,...n);case"multiFieldReference":return t;case"transform":return e=>t(e);case"arrayElement":return(e,...n)=>t(e,...n);case"context":return e=>t(e);default:return t}};function u(l){let{name:a,methodName:o,allowedTypes:m,category:s,impl:t}=l;return{name:a,methodName:o,allowedTypes:m,category:s,create:()=>d(s,o,t,a)}}var f=u({name:"objectPatternProperties",methodName:"patternProperties",allowedTypes:["object"],category:"standard",impl:l=>({check:a=>{if(!a||typeof a!="object"||Array.isArray(a))return!1;let o=Object.keys(a),m=Object.entries(l);for(let s of o){let t=a[s];for(let[e,n]of m)if(new RegExp(e).test(s)){let r=!1;if(typeof n=="function"?r=n(t):typeof n=="object"&&n!==null&&"validator"in n&&(r=n.validator(t)),!r)return!1;break}}return!0},code:"PATTERN_PROPERTIES",getErrorMessage:(a,o)=>{let m=Object.keys(a||{}),s=Object.entries(l),t=[];for(let e of m){let n=a[e];for(let[i,r]of s)if(new RegExp(i).test(e)){let p=!1,T;typeof r=="function"?p=r(n):typeof r=="object"&&r!==null&&"validator"in r&&(p=r.validator(n),T=r.message),p||(T?t.push(`${e}: ${T}`):t.push(`${e} (matching pattern ${i}) has invalid value`));break}}return t.length>0?`${o} has pattern property violations: ${t.join(", ")}`:`${o} has invalid pattern properties`},params:[l]})});export{f as objectPatternPropertiesPlugin};
+export * from "./object-pattern-properties/index.mjs";

package/dist/plugins/objectPropertyNames.d.ts

@@ -1,36 +1 @@
-/**
- * @luq-plugin
- * @name objectPropertyNames
- * @category object
- * @description Validates that all property names in an object match a specified pattern or schema
- * @allowedTypes ["object"]
- * @example
- * ```typescript
- * // Property names must match pattern
- * const validator = Builder()
- *   .use(objectPropertyNamesPlugin)
- *   .for<{ [key: string]: any }>()
- *   .v("config", (b) => b.object.propertyNames(/^[a-zA-Z_][a-zA-Z0-9_]*$/))
- *   .build();
- *
- * // Property names with custom validator
- * builder.v("data", b => b.object.propertyNames({
- *   validator: (name) => name.length >= 3 && !name.startsWith('_'),
- *   message: "Property names must be at least 3 characters and not start with underscore"
- * }))
- * ```
- * @params
- * - schema: RegExp | string | { validator: (name: string) => boolean, message?: string } - Pattern or validation schema for property names
- * @returns Validation function that checks all property names
- * @since 0.1.0-alpha
- */
-export interface PropertyNamesSchema {
-    validator: (name: string) => boolean;
-    message?: string;
-}
-export declare const objectPropertyNamesPlugin: import("../index").TypedPlugin<"objectPropertyNames", "propertyNames", (schema: RegExp | string | PropertyNamesSchema) => {
-    check: (value: any) => boolean;
-    code: string;
-    getErrorMessage: (value: any, path: string) => string;
-    params: (string | RegExp | PropertyNamesSchema)[];
-}, readonly ["object"], "validator", "standard">;
+export * from "./object-property-names/index";

package/dist/plugins/objectPropertyNames.js

@@ -1 +1,2 @@
-"use strict";var p=Object.defineProperty;var u=Object.getOwnPropertyDescriptor;var T=Object.getOwnPropertyNames;var g=Object.prototype.hasOwnProperty;var d=(e,n)=>{for(var t in n)p(e,t,{get:n[t],enumerable:!0})},y=(e,n,t,a)=>{if(n&&typeof n=="object"||typeof n=="function")for(let o of T(n))!g.call(e,o)&&o!==t&&p(e,o,{get:()=>n[o],enumerable:!(a=u(n,o))||a.enumerable});return e};var f=e=>y(p({},"__esModule",{value:!0}),e);var x={};d(x,{objectPropertyNamesPlugin:()=>c});module.exports=f(x);var N=(e,n,t,a)=>{let r=(i=>(...s)=>{let l=i(...s);return l&&typeof l=="object"&&"check"in l?{...l,pluginName:a}:l})(t);switch(e){case"conditional":return(i,...s)=>r(i,...s);case"fieldReference":return(i,...s)=>r(i,...s);case"multiFieldReference":return r;case"transform":return i=>r(i);case"arrayElement":return(i,...s)=>r(i,...s);case"context":return i=>r(i);default:return r}};function m(e){let{name:n,methodName:t,allowedTypes:a,category:o,impl:r}=e;return{name:n,methodName:t,allowedTypes:a,category:o,create:()=>N(o,t,r,n)}}var c=m({name:"objectPropertyNames",methodName:"propertyNames",allowedTypes:["object"],category:"standard",impl:e=>({check:n=>{if(!n||typeof n!="object"||Array.isArray(n))return!1;let t=Object.keys(n);for(let a of t)if(e instanceof RegExp){if(!e.test(a))return!1}else if(typeof e=="string"){if(!new RegExp(e).test(a))return!1}else if(typeof e=="object"&&e!==null&&"validator"in e){if(!e.validator(a))return!1}else return!1;return!0},code:"PROPERTY_NAMES",getErrorMessage:(n,t)=>{let a=Object.keys(n||{}).filter(r=>e instanceof RegExp?!e.test(r):typeof e=="string"?!new RegExp(e).test(r):typeof e=="object"&&e!==null&&"validator"in e?!e.validator(r):!0);if(typeof e=="object"&&e!==null&&"message"in e&&e.message)return e.message;let o=e instanceof RegExp?e.toString():typeof e=="string"?`/${e}/`:"the specified pattern";return`${t} has invalid property names: ${a.join(", ")}. Property names must match ${o}`},params:[e]})});0&&(module.exports={objectPropertyNamesPlugin});
+"use strict";
+module.exports = require("./object-property-names/index");

package/dist/plugins/objectPropertyNames.mjs

@@ -1 +1 @@
-var m=(e,r,o,a)=>{let n=(t=>(...i)=>{let l=t(...i);return l&&typeof l=="object"&&"check"in l?{...l,pluginName:a}:l})(o);switch(e){case"conditional":return(t,...i)=>n(t,...i);case"fieldReference":return(t,...i)=>n(t,...i);case"multiFieldReference":return n;case"transform":return t=>n(t);case"arrayElement":return(t,...i)=>n(t,...i);case"context":return t=>n(t);default:return n}};function p(e){let{name:r,methodName:o,allowedTypes:a,category:s,impl:n}=e;return{name:r,methodName:o,allowedTypes:a,category:s,create:()=>m(s,o,n,r)}}var g=p({name:"objectPropertyNames",methodName:"propertyNames",allowedTypes:["object"],category:"standard",impl:e=>({check:r=>{if(!r||typeof r!="object"||Array.isArray(r))return!1;let o=Object.keys(r);for(let a of o)if(e instanceof RegExp){if(!e.test(a))return!1}else if(typeof e=="string"){if(!new RegExp(e).test(a))return!1}else if(typeof e=="object"&&e!==null&&"validator"in e){if(!e.validator(a))return!1}else return!1;return!0},code:"PROPERTY_NAMES",getErrorMessage:(r,o)=>{let a=Object.keys(r||{}).filter(n=>e instanceof RegExp?!e.test(n):typeof e=="string"?!new RegExp(e).test(n):typeof e=="object"&&e!==null&&"validator"in e?!e.validator(n):!0);if(typeof e=="object"&&e!==null&&"message"in e&&e.message)return e.message;let s=e instanceof RegExp?e.toString():typeof e=="string"?`/${e}/`:"the specified pattern";return`${o} has invalid property names: ${a.join(", ")}. Property names must match ${s}`},params:[e]})});export{g as objectPropertyNamesPlugin};
+export * from "./object-property-names/index.mjs";

package/dist/plugins/objectRecursively.d.ts

@@ -0,0 +1 @@
+export * from "./object-recursively/index";

package/dist/plugins/objectRecursively.js

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = require("./object-recursively/index");

package/dist/plugins/objectRecursively.mjs

@@ -0,0 +1 @@
+export * from "./object-recursively/index.mjs";

package/dist/plugins/one-of/index.d.ts

@@ -0,0 +1 @@
+export { oneOfPlugin } from "./one-of";

package/dist/plugins/one-of/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.oneOfPlugin = void 0;
+var one_of_1 = require("./one-of");
+Object.defineProperty(exports, "oneOfPlugin", { enumerable: true, get: function () { return one_of_1.oneOfPlugin; } });

package/dist/plugins/one-of/index.mjs

@@ -0,0 +1 @@
+export { oneOfPlugin } from "./one-of.mjs";

package/dist/plugins/one-of/one-of.d.ts

@@ -0,0 +1,7 @@
+import { type MessageContextExtra } from "../../types";
+import type { SelfValue, Unchanged } from "../../plugin-kit/marker.types";
+export declare const oneOfPlugin: import("../../plugin-kit/plugin-definition").PluginDefinition<"oneOf", "oneOf", readonly ["string", "number", "boolean"], {
+    args: readonly [allowed: readonly SelfValue[]];
+    out: Unchanged;
+    context: MessageContextExtra;
+}>;

package/dist/plugins/one-of/one-of.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.oneOfPlugin = void 0;
+// ===========================================================================
+// L7  src/plugins/one-of/one-of.ts — the legacy VALUE enum.
+//
+// `readonly SelfValue[]` types the list against the field: at the call site it
+// is `readonly string[]` on a string chain and `readonly unknown[]` inside
+// build(). That also makes it correctly NON-bindable by bindKeyword, whose
+// PluginArgs is the DECLARED tuple — binding it as if declared == runtime
+// would hand JSON Schema a list of markers.
+//
+// Distinct from the COMPOSITION keyword `oneOf` (src/plugins/composition/),
+// which takes sub-schemas rather than values.
+//
+// MEMBERSHIP IS STRUCTURAL. `allowed.includes` compares by reference, so a list
+// holding `{"a":1}` or `[1,2]` could never match a parsed document — measured
+// on the official Draft-07 suite, that cost 17 of 929 cases through the `enum`
+// keyword, which is this plugin's other front door. The one definition lives in
+// src/plugin-kit/is-json-value-equal.ts and `unique` and `includes` use it too.
+// The Set fast path is kept for the case it was written for and can still be
+// taken: a list whose members are ALL primitives, where SameValueZero and
+// structural equality are the same answer.
+// ===========================================================================
+const types_1 = require("../../types");
+const create_rule_1 = require("../../plugin-kit/create-rule");
+const plugin_definition_1 = require("../../plugin-kit/plugin-definition");
+const is_json_value_equal_1 = require("../../plugin-kit/is-json-value-equal");
+/** Above this many members a Set beats a linear scan. Legacy used the same. */
+const SET_MEMBERSHIP_THRESHOLD = 7;
+function describeAllowed(allowed) {
+    return allowed.map((member) => JSON.stringify(member)).join(", ");
+}
+/** A Set answers with SameValueZero, which is only the whole answer here when
+ *  no member has a structure to compare. `null` is a primitive for this. */
+function areAllMembersPrimitive(allowed) {
+    return allowed.every((member) => member === null || typeof member !== "object");
+}
+/** One membership test, decided ONCE at build time and never re-decided. */
+function createMembershipTest(allowed) {
+    if (allowed.length > SET_MEMBERSHIP_THRESHOLD &&
+        areAllMembersPrimitive(allowed)) {
+        const members = new Set(allowed);
+        return (value) => members.has(value);
+    }
+    return (value) => allowed.some((member) => (0, is_json_value_equal_1.isJsonValueEqual)(member, value));
+}
+exports.oneOfPlugin = (0, plugin_definition_1.definePlugin)()({
+    name: "oneOf",
+    method: "oneOf",
+    slots: ["string", "number", "boolean"],
+    build: (ctx, allowed) => {
+        if (!(0, types_1.isArray)(allowed) || allowed.length === 0) {
+            throw new plugin_definition_1.PluginArgumentError(ctx.pluginName, "allowed", allowed);
+        }
+        const isMember = createMembershipTest(allowed);
+        const rendered = describeAllowed(allowed);
+        return (0, create_rule_1.check)({
+            code: ctx.code,
+            messageFactory: ctx.messageFactory,
+            severity: ctx.severity,
+            run: (value) => isMember(value) ? types_1.PASS : (0, types_1.fail)({ expected: allowed, actual: value }),
+            describe: () => `Value must be one of: ${rendered}`,
+            buildMessageContext: () => ({}),
+        });
+    },
+});

package/dist/plugins/one-of/one-of.mjs

@@ -0,0 +1,64 @@
+// ===========================================================================
+// L7  src/plugins/one-of/one-of.ts — the legacy VALUE enum.
+//
+// `readonly SelfValue[]` types the list against the field: at the call site it
+// is `readonly string[]` on a string chain and `readonly unknown[]` inside
+// build(). That also makes it correctly NON-bindable by bindKeyword, whose
+// PluginArgs is the DECLARED tuple — binding it as if declared == runtime
+// would hand JSON Schema a list of markers.
+//
+// Distinct from the COMPOSITION keyword `oneOf` (src/plugins/composition/),
+// which takes sub-schemas rather than values.
+//
+// MEMBERSHIP IS STRUCTURAL. `allowed.includes` compares by reference, so a list
+// holding `{"a":1}` or `[1,2]` could never match a parsed document — measured
+// on the official Draft-07 suite, that cost 17 of 929 cases through the `enum`
+// keyword, which is this plugin's other front door. The one definition lives in
+// src/plugin-kit/is-json-value-equal.ts and `unique` and `includes` use it too.
+// The Set fast path is kept for the case it was written for and can still be
+// taken: a list whose members are ALL primitives, where SameValueZero and
+// structural equality are the same answer.
+// ===========================================================================
+import { PASS, fail, isArray } from "../../types/index.mjs";
+import { check } from "../../plugin-kit/create-rule.mjs";
+import { definePlugin, PluginArgumentError, } from "../../plugin-kit/plugin-definition.mjs";
+import { isJsonValueEqual } from "../../plugin-kit/is-json-value-equal.mjs";
+/** Above this many members a Set beats a linear scan. Legacy used the same. */
+const SET_MEMBERSHIP_THRESHOLD = 7;
+function describeAllowed(allowed) {
+    return allowed.map((member) => JSON.stringify(member)).join(", ");
+}
+/** A Set answers with SameValueZero, which is only the whole answer here when
+ *  no member has a structure to compare. `null` is a primitive for this. */
+function areAllMembersPrimitive(allowed) {
+    return allowed.every((member) => member === null || typeof member !== "object");
+}
+/** One membership test, decided ONCE at build time and never re-decided. */
+function createMembershipTest(allowed) {
+    if (allowed.length > SET_MEMBERSHIP_THRESHOLD &&
+        areAllMembersPrimitive(allowed)) {
+        const members = new Set(allowed);
+        return (value) => members.has(value);
+    }
+    return (value) => allowed.some((member) => isJsonValueEqual(member, value));
+}
+export const oneOfPlugin = /*#__PURE__*/ definePlugin()({
+    name: "oneOf",
+    method: "oneOf",
+    slots: ["string", "number", "boolean"],
+    build: (ctx, allowed) => {
+        if (!isArray(allowed) || allowed.length === 0) {
+            throw new PluginArgumentError(ctx.pluginName, "allowed", allowed);
+        }
+        const isMember = createMembershipTest(allowed);
+        const rendered = describeAllowed(allowed);
+        return check({
+            code: ctx.code,
+            messageFactory: ctx.messageFactory,
+            severity: ctx.severity,
+            run: (value) => isMember(value) ? PASS : fail({ expected: allowed, actual: value }),
+            describe: () => `Value must be one of: ${rendered}`,
+            buildMessageContext: () => ({}),
+        });
+    },
+});

package/dist/plugins/oneOf.d.ts

@@ -1,44 +1 @@
-import { ValidationOptions } from "../core/plugin/types";
-/**
- * @luq-plugin
- * @name oneOf
- * @category standard
- * @description Validates that a value is one of the specified allowed values (enum-like validation)
- * @allowedTypes ["string", "number", "boolean"]
- * @example
- * ```typescript
- * // String enum validation
- * const validator = Builder()
- *   .use(oneOfPlugin)
- *   .for<FormData>()
- *   .v("status", (b) => b.string.oneOf(["active", "inactive", "pending"]))
- *   .v("role", (b) => b.string.oneOf(["admin", "user", "guest"]))
- *   .build();
- *
- * // Number enum validation
- * builder.v("priority", b => b.number.oneOf([0, 1, 2, 3]))
- *
- * // With TypeScript const for type safety
- * const ROLES = ["admin", "user", "guest"] as const;
- * builder.v("userRole", b => b.string.oneOf(ROLES))
- * ```
- * @params
- * - allowed: Array<string | number | boolean> - Array of allowed values
- * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
- * @returns Validation function that returns true if value is in the allowed list
- * @customError
- * ```typescript
- * .oneOf(["A", "B", "C"], {
- *   messageFactory: ({ path, value, params }) =>
- *     `${path} must be one of: ${params.allowed.join(", ")} (received: ${value})`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-export declare const oneOfPlugin: import("../index").TypedPlugin<"oneOf", "oneOf", (allowedValues: readonly any[], options?: ValidationOptions) => {
-    check: (value: any) => boolean;
-    code: string;
-    getErrorMessage: (value: any, path: string) => string;
-    params: (any[] | ValidationOptions<{}>)[];
-    allowedValues: readonly any[];
-}, readonly ["string", "number", "boolean"], "validator", "standard">;
+export * from "./one-of/index";

package/dist/plugins/oneOf.js

@@ -1 +1,2 @@
-"use strict";var l=Object.defineProperty;var u=Object.getOwnPropertyDescriptor;var d=Object.getOwnPropertyNames;var g=Object.prototype.hasOwnProperty;var y=(e,n)=>{for(var a in n)l(e,a,{get:n[a],enumerable:!0})},c=(e,n,a,i)=>{if(n&&typeof n=="object"||typeof n=="function")for(let o of d(n))!g.call(e,o)&&o!==a&&l(e,o,{get:()=>n[o],enumerable:!(i=u(n,o))||i.enumerable});return e};var f=e=>c(l({},"__esModule",{value:!0}),e);var w={};y(w,{oneOfPlugin:()=>P});module.exports=f(w);var N=(e,n,a,i)=>{let s=(r=>(...t)=>{let m=r(...t);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:i}:m})(a);switch(e){case"conditional":return(r,...t)=>s(r,...t);case"fieldReference":return(r,...t)=>s(r,...t);case"multiFieldReference":return s;case"transform":return r=>s(r);case"arrayElement":return(r,...t)=>s(r,...t);case"context":return r=>s(r);default:return s}};function p(e){let{name:n,methodName:a,allowedTypes:i,category:o,impl:s}=e;return{name:n,methodName:a,allowedTypes:i,category:o,create:()=>N(o,a,s,n)}}var h="oneOf",x=e=>Array.isArray(e)?`Value must be one of: ${e.map(a=>JSON.stringify(a)).join(", ")}`:"Value must be one of the allowed values",I=["string","number","boolean"],P=p({name:"oneOf",methodName:"oneOf",allowedTypes:I,category:"standard",impl:(e,n)=>{if(!Array.isArray(e)||e.length===0)throw new Error("oneOf requires a non-empty array of allowed values");let a=n?.code||h,i=n?.messageFactory||(t=>x(t.options)),o=Object.freeze([...e]),s=e.length>7,r=s?new Set(e):null;return{check:t=>t==null?!0:s?r.has(t):e.includes(t),code:a,getErrorMessage:(t,m)=>{let T={path:m,value:t,code:a,options:[...o]};return i(T)},params:[e,n],allowedValues:o}}});0&&(module.exports={oneOfPlugin});
+"use strict";
+module.exports = require("./one-of/index");

package/dist/plugins/oneOf.mjs

@@ -1 +1 @@
-var T=(n,o,r,m)=>{let a=(t=>(...e)=>{let s=t(...e);return s&&typeof s=="object"&&"check"in s?{...s,pluginName:m}:s})(r);switch(n){case"conditional":return(t,...e)=>a(t,...e);case"fieldReference":return(t,...e)=>a(t,...e);case"multiFieldReference":return a;case"transform":return t=>a(t);case"arrayElement":return(t,...e)=>a(t,...e);case"context":return t=>a(t);default:return a}};function l(n){let{name:o,methodName:r,allowedTypes:m,category:i,impl:a}=n;return{name:o,methodName:r,allowedTypes:m,category:i,create:()=>T(i,r,a,o)}}var u="oneOf",d=n=>Array.isArray(n)?`Value must be one of: ${n.map(r=>JSON.stringify(r)).join(", ")}`:"Value must be one of the allowed values",g=["string","number","boolean"],f=l({name:"oneOf",methodName:"oneOf",allowedTypes:g,category:"standard",impl:(n,o)=>{if(!Array.isArray(n)||n.length===0)throw new Error("oneOf requires a non-empty array of allowed values");let r=o?.code||u,m=o?.messageFactory||(e=>d(e.options)),i=Object.freeze([...n]),a=n.length>7,t=a?new Set(n):null;return{check:e=>e==null?!0:a?t.has(e):n.includes(e),code:r,getErrorMessage:(e,s)=>{let p={path:s,value:e,code:r,options:[...i]};return m(p)},params:[n,o],allowedValues:i}}});export{f as oneOfPlugin};
+export * from "./one-of/index.mjs";

package/dist/plugins/optional/index.d.ts

@@ -0,0 +1 @@
+export { optionalPlugin } from "./optional";

package/dist/plugins/optional/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optionalPlugin = void 0;
+var optional_1 = require("./optional");
+Object.defineProperty(exports, "optionalPlugin", { enumerable: true, get: function () { return optional_1.optionalPlugin; } });

package/dist/plugins/optional/index.mjs

@@ -0,0 +1 @@
+export { optionalPlugin } from "./optional.mjs";

package/dist/plugins/optional/optional.d.ts

@@ -0,0 +1,7 @@
+import type { MessageContextExtra, TypeName } from "../../types";
+import type { PresenceShift } from "../../plugin-kit/marker.types";
+export declare const optionalPlugin: import("../../plugin-kit/plugin-definition").PluginDefinition<"optional", "optional", readonly TypeName[], {
+    args: readonly [];
+    out: PresenceShift<"excludeNull">;
+    context: MessageContextExtra;
+}>;

package/dist/plugins/optional/optional.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optionalPlugin = void 0;
+// ===========================================================================
+// L7  src/plugins/optional/optional.ts
+//
+// `.optional()` accepts a MISSING value and still rejects an explicit null:
+// legacy's optional returned false for null and said so in its message, and
+// that split between "not there" and "there, and null" is the whole point of
+// having both optional and nullable.
+//
+// The empty string is NOT absence here (emptyStringIsMissing: false), which is
+// why `.optional().min(3)` still judges "" — legacy did the same.
+// ===========================================================================
+const create_rule_1 = require("../../plugin-kit/create-rule");
+const plugin_definition_1 = require("../../plugin-kit/plugin-definition");
+const OPTIONAL_SLOTS = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "array",
+    "tuple",
+    "object",
+    "union",
+    "any",
+];
+exports.optionalPlugin = (0, plugin_definition_1.definePlugin)()({
+    name: "optional",
+    method: "optional",
+    slots: OPTIONAL_SLOTS,
+    build: (ctx) => (0, create_rule_1.presence)({
+        code: ctx.code,
+        messageFactory: ctx.messageFactory,
+        severity: ctx.severity,
+        allowUndefined: true,
+        allowNull: false,
+        emptyStringIsMissing: false,
+        describe: (messageContext) => `${messageContext.path} cannot be null (use undefined for optional fields)`,
+        buildMessageContext: () => ({}),
+    }),
+});

package/dist/plugins/optional/optional.mjs

@@ -0,0 +1,39 @@
+// ===========================================================================
+// L7  src/plugins/optional/optional.ts
+//
+// `.optional()` accepts a MISSING value and still rejects an explicit null:
+// legacy's optional returned false for null and said so in its message, and
+// that split between "not there" and "there, and null" is the whole point of
+// having both optional and nullable.
+//
+// The empty string is NOT absence here (emptyStringIsMissing: false), which is
+// why `.optional().min(3)` still judges "" — legacy did the same.
+// ===========================================================================
+import { presence } from "../../plugin-kit/create-rule.mjs";
+import { definePlugin } from "../../plugin-kit/plugin-definition.mjs";
+const OPTIONAL_SLOTS = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "array",
+    "tuple",
+    "object",
+    "union",
+    "any",
+];
+export const optionalPlugin = /*#__PURE__*/ definePlugin()({
+    name: "optional",
+    method: "optional",
+    slots: OPTIONAL_SLOTS,
+    build: (ctx) => presence({
+        code: ctx.code,
+        messageFactory: ctx.messageFactory,
+        severity: ctx.severity,
+        allowUndefined: true,
+        allowNull: false,
+        emptyStringIsMissing: false,
+        describe: (messageContext) => `${messageContext.path} cannot be null (use undefined for optional fields)`,
+        buildMessageContext: () => ({}),
+    }),
+});

package/dist/plugins/optional-if/index.d.ts

@@ -0,0 +1 @@
+export { optionalIfPlugin, type OptionalIfExtra } from "./optional-if";

package/dist/plugins/optional-if/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optionalIfPlugin = void 0;
+var optional_if_1 = require("./optional-if");
+Object.defineProperty(exports, "optionalIfPlugin", { enumerable: true, get: function () { return optional_if_1.optionalIfPlugin; } });

package/dist/plugins/optional-if/index.mjs

@@ -0,0 +1 @@
+export { optionalIfPlugin } from "./optional-if.mjs";

package/dist/plugins/optional-if/optional-if.d.ts

@@ -0,0 +1,11 @@
+import type { TypeName } from "../../types";
+import type { RootPredicate, Unchanged } from "../../plugin-kit/marker.types";
+/** Legacy OptionalIfContext: the condition that made the field optional. */
+export interface OptionalIfExtra {
+    readonly condition: boolean;
+}
+export declare const optionalIfPlugin: import("../../plugin-kit/plugin-definition").PluginDefinition<"optionalIf", "optionalIf", readonly TypeName[], {
+    args: readonly [when: RootPredicate];
+    out: Unchanged;
+    context: OptionalIfExtra;
+}>;

package/dist/plugins/optional-if/optional-if.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optionalIfPlugin = void 0;
+const create_conditional_presence_1 = require("../../plugin-kit/create-conditional-presence");
+const plugin_definition_1 = require("../../plugin-kit/plugin-definition");
+const OPTIONAL_IF_SLOTS = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "array",
+    "tuple",
+    "object",
+    "union",
+    "any",
+];
+exports.optionalIfPlugin = (0, plugin_definition_1.definePlugin)()({
+    name: "optionalIf",
+    method: "optionalIf",
+    slots: OPTIONAL_IF_SLOTS,
+    build: (ctx, when) => (0, create_conditional_presence_1.conditionalPresence)({
+        code: ctx.code,
+        messageFactory: ctx.messageFactory,
+        severity: ctx.severity,
+        when,
+        whenMet: create_conditional_presence_1.PERMITS_ABSENCE,
+        whenUnmet: create_conditional_presence_1.REQUIRES_A_VALUE,
+        describe: () => "Field is optional when condition is met",
+        buildMessageContext: () => ({ condition: false }),
+    }),
+});

package/dist/plugins/optional-if/optional-if.mjs

@@ -0,0 +1,28 @@
+import { PERMITS_ABSENCE, REQUIRES_A_VALUE, conditionalPresence, } from "../../plugin-kit/create-conditional-presence.mjs";
+import { definePlugin } from "../../plugin-kit/plugin-definition.mjs";
+const OPTIONAL_IF_SLOTS = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "array",
+    "tuple",
+    "object",
+    "union",
+    "any",
+];
+export const optionalIfPlugin = /*#__PURE__*/ definePlugin()({
+    name: "optionalIf",
+    method: "optionalIf",
+    slots: OPTIONAL_IF_SLOTS,
+    build: (ctx, when) => conditionalPresence({
+        code: ctx.code,
+        messageFactory: ctx.messageFactory,
+        severity: ctx.severity,
+        when,
+        whenMet: PERMITS_ABSENCE,
+        whenUnmet: REQUIRES_A_VALUE,
+        describe: () => "Field is optional when condition is met",
+        buildMessageContext: () => ({ condition: false }),
+    }),
+});