@maroonedog/luq 0.1.2-alpha → 2.0.0

package/dist/plugins/compare-field/compare-field.mjs

@@ -0,0 +1,54 @@
+// ===========================================================================
+// L7  src/plugins/compare-field/compare-field.ts
+// The MIXED marker tuple: a FieldRef followed by a plain argument. The call
+// site therefore gets `FieldPath<TRoot> & string` for the path and the plain
+// comparison function verbatim, and build() sees a real string it can compile
+// into a reader ONCE.
+//
+// Legacy (docs/legacy-spec/plugin-catalog-relational.md) read the other field
+// with a hand-rolled dotted-path accessor and failed the whole rule when
+// `allValues` was missing. Here the root is always present in RuleContext, so
+// that branch does not exist, and the path is parsed by the ONE L1 parser.
+// ===========================================================================
+import { PASS, fail } from "../../types/index.mjs";
+import { check } from "../../plugin-kit/create-rule.mjs";
+import { definePlugin } from "../../plugin-kit/plugin-definition.mjs";
+import { createValueReader, parseFieldPath } from "../../path/index.mjs";
+const COMPARE_FIELD_SLOTS = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "object",
+    "array",
+    "tuple",
+    "union",
+];
+function equalsStrictly(value, targetValue) {
+    return value === targetValue;
+}
+export const compareFieldPlugin = /*#__PURE__*/ definePlugin()({
+    name: "compareField",
+    method: "compareField",
+    slots: COMPARE_FIELD_SLOTS,
+    build: (ctx, other, compare) => {
+        const readTarget = createValueReader(parseFieldPath(other));
+        const compares = compare ?? equalsStrictly;
+        return check({
+            code: ctx.code,
+            messageFactory: ctx.messageFactory,
+            severity: ctx.severity,
+            run: (value, runCtx) => {
+                const targetValue = readTarget(runCtx.root);
+                return compares(value, targetValue)
+                    ? PASS
+                    : fail({ expected: targetValue, actual: value });
+            },
+            describe: () => `Value must be equal to ${other}`,
+            buildMessageContext: (detail) => ({
+                fieldPath: other,
+                targetValue: detail.expected,
+            }),
+        });
+    },
+});

package/dist/plugins/compare-field/index.d.ts

@@ -0,0 +1,2 @@
+export { compareFieldPlugin } from "./compare-field";
+export type { CompareFieldExtra, CompareFieldValues } from "./compare-field";

package/dist/plugins/compare-field/index.js

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

package/dist/plugins/compare-field/index.mjs

@@ -0,0 +1 @@
+export { compareFieldPlugin } from "./compare-field.mjs";

package/dist/plugins/compareField.d.ts

@@ -1,58 +1 @@
-import { ValidationOptions } from "../core/plugin/types";
-type CompareFn = (value: any, targetValue: any) => boolean;
-interface CompareFieldOptions extends ValidationOptions {
-    compareFn?: CompareFn;
-}
-/**
- * @luq-plugin
- * @name compareField
- * @category standard
- * @description Validates a field's value by comparing it with another field's value using a custom comparison function
- * @allowedTypes ["string", "number", "boolean", "date", "object", "array", "null", "undefined"]
- * @example
- * ```typescript
- * // Default usage - strict equality
- * const validator = Builder()
- *   .use(compareFieldPlugin)
- *   .for<SignupForm>()
- *   .v("password", (b) => b.string.required().min(8))
- *   .v("confirmPassword", (b) => b.string.required().compareField("password"))
- *   .build();
- *
- * // Custom comparison - date before
- * builder.v("endDate", (b) => b.string.datetime().compareField("startDate", {
- *   compareFn: (endDate, startDate) => new Date(endDate) > new Date(startDate),
- *   messageFactory: () => "End date must be after start date"
- * }))
- *
- * // Number comparison
- * builder.v("maxValue", (b) => b.number.compareField("minValue", {
- *   compareFn: (max, min) => max >= min,
- *   messageFactory: () => "Max value must be greater than or equal to min value"
- * }))
- * ```
- * @params
- * - fieldPath: string - Path to the field to compare against (supports dot notation)
- * - options?: { compareFn?: (value, targetValue) => boolean, messageFactory?: (context) => string } - Optional configuration
- * @returns Validation function that returns true if comparison passes
- * @customError
- * ```typescript
- * .compareField("startDate", {
- *   compareFn: (end, start) => new Date(end) > new Date(start),
- *   messageFactory: ({ path, value, params }) =>
- *     `${path} must be after ${params.fieldPath}`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-export declare const compareFieldPlugin: import("../index").TypedPlugin<"compareField", "compareField", (fieldPath: string, options?: CompareFieldOptions) => {
-    check: (value: any, allValues?: any) => boolean;
-    code: string;
-    getErrorMessage: (value: any, path: string, allValues?: any) => string;
-    params: (string | CompareFieldOptions)[];
-    fieldReference: {
-        fieldPath: string;
-        compareFn: CompareFn;
-    };
-}, readonly ["string", "number", "boolean", "date", "object", "array", "tuple", "union"], "validator", "fieldReference">;
-export {};
+export * from "./compare-field/index";

package/dist/plugins/compareField.js

@@ -1 +1,2 @@
-"use strict";var u=Object.defineProperty;var g=Object.getOwnPropertyDescriptor;var d=Object.getOwnPropertyNames;var f=Object.prototype.hasOwnProperty;var T=(e,n)=>{for(var t in n)u(e,t,{get:n[t],enumerable:!0})},h=(e,n,t,a)=>{if(n&&typeof n=="object"||typeof n=="function")for(let r of d(n))!f.call(e,r)&&r!==t&&u(e,r,{get:()=>n[r],enumerable:!(a=g(n,r))||a.enumerable});return e};var x=e=>h(u({},"__esModule",{value:!0}),e);var C={};T(C,{compareFieldPlugin:()=>b});module.exports=x(C);var A=(e,n,t,a)=>{let s=(o=>(...i)=>{let l=o(...i);return l&&typeof l=="object"&&"check"in l?{...l,pluginName:a}:l})(t);switch(e){case"conditional":return(o,...i)=>s(o,...i);case"fieldReference":return(o,...i)=>s(o,...i);case"multiFieldReference":return s;case"transform":return o=>s(o);case"arrayElement":return(o,...i)=>s(o,...i);case"context":return o=>s(o);default:return s}};function c(e){let{name:n,methodName:t,allowedTypes:a,category:r,impl:s}=e;return{name:n,methodName:t,allowedTypes:a,category:r,create:()=>A(r,t,s,n)}}var m=".";function N(e){if(e.length===0)return n=>n;if(e.length===1){let n=e[0];return t=>t?.[n]}if(e.length===2){let[n,t]=e;return a=>a?.[n]?.[t]}if(e.length===3){let[n,t,a]=e;return r=>r?.[n]?.[t]?.[a]}if(e.length===4){let[n,t,a,r]=e;return s=>s?.[n]?.[t]?.[a]?.[r]}if(e.length===5){let[n,t,a,r,s]=e;return o=>o?.[n]?.[t]?.[a]?.[r]?.[s]}return n=>{let t=n,a=e.length;for(let r=0;r<a;r++){let s=e[r];if(t=t?.[s],t===void 0)return}return t}}function y(e){return N(e.split(m))}var k="equals";function P(e){return e.fieldPath?`Value must be equal to ${e.fieldPath}`:"Values must be equal"}var E=["string","number","boolean","date","object","array","tuple","union"],I=(e,n)=>e===n,b=c({name:"compareField",methodName:"compareField",allowedTypes:E,category:"fieldReference",impl:(e,n)=>{let t=y(e),a=n?.code||k,r=n?.messageFactory||P,s=n?.compareFn||I;return{check:(o,i)=>{if(!i)return!1;let l=t(i);return s(o,l)},code:a,getErrorMessage:(o,i,l)=>{let p=l?t(l):void 0;return r({path:i,value:o,code:a,fieldPath:e,targetValue:p})},params:[e,n],fieldReference:{fieldPath:e,compareFn:s}}}});0&&(module.exports={compareFieldPlugin});
+"use strict";
+module.exports = require("./compare-field/index");

package/dist/plugins/compareField.mjs

@@ -1 +1 @@
-var p=(e,n,t,s)=>{let r=(a=>(...i)=>{let l=a(...i);return l&&typeof l=="object"&&"check"in l?{...l,pluginName:s}:l})(t);switch(e){case"conditional":return(a,...i)=>r(a,...i);case"fieldReference":return(a,...i)=>r(a,...i);case"multiFieldReference":return r;case"transform":return a=>r(a);case"arrayElement":return(a,...i)=>r(a,...i);case"context":return a=>r(a);default:return r}};function u(e){let{name:n,methodName:t,allowedTypes:s,category:o,impl:r}=e;return{name:n,methodName:t,allowedTypes:s,category:o,create:()=>p(o,t,r,n)}}var c=".";function g(e){if(e.length===0)return n=>n;if(e.length===1){let n=e[0];return t=>t?.[n]}if(e.length===2){let[n,t]=e;return s=>s?.[n]?.[t]}if(e.length===3){let[n,t,s]=e;return o=>o?.[n]?.[t]?.[s]}if(e.length===4){let[n,t,s,o]=e;return r=>r?.[n]?.[t]?.[s]?.[o]}if(e.length===5){let[n,t,s,o,r]=e;return a=>a?.[n]?.[t]?.[s]?.[o]?.[r]}return n=>{let t=n,s=e.length;for(let o=0;o<s;o++){let r=e[o];if(t=t?.[r],t===void 0)return}return t}}function m(e){return g(e.split(c))}var d="equals";function f(e){return e.fieldPath?`Value must be equal to ${e.fieldPath}`:"Values must be equal"}var T=["string","number","boolean","date","object","array","tuple","union"],h=(e,n)=>e===n,b=u({name:"compareField",methodName:"compareField",allowedTypes:T,category:"fieldReference",impl:(e,n)=>{let t=m(e),s=n?.code||d,o=n?.messageFactory||f,r=n?.compareFn||h;return{check:(a,i)=>{if(!i)return!1;let l=t(i);return r(a,l)},code:s,getErrorMessage:(a,i,l)=>{let y=l?t(l):void 0;return o({path:i,value:a,code:s,fieldPath:e,targetValue:y})},params:[e,n],fieldReference:{fieldPath:e,compareFn:r}}}});export{b as compareFieldPlugin};
+export * from "./compare-field/index.mjs";

package/dist/plugins/conditional-schema/conditional-schema.d.ts

@@ -0,0 +1,17 @@
+import type { NarrowedChain, Unchanged } from "../../plugin-kit/marker.types";
+export type ConditionalArm = "then" | "else" | "none";
+export interface ConditionalSchemaContext {
+    readonly taken: ConditionalArm;
+}
+/**
+ * WHICH argument positions carry a sub-chain cannot be recovered from a
+ * plugin's type at run time — a NarrowedChain and a RootPredicate are both
+ * plain functions once erased — so src/chain/collect-branch-rules.ts reads it
+ * from this declared field. definePlugin's spec does not carry it yet (see
+ * needsFromOthers), which is why it is spread on rather than passed in.
+ */
+export declare const conditionalSchemaPlugin: import("../../plugin-kit/plugin-definition").PluginDefinition<"conditionalSchema", "conditionalSchema", readonly ["object", "array", "string", "number", "boolean"], {
+    args: readonly [condition: NarrowedChain, then?: NarrowedChain, otherwise?: NarrowedChain];
+    out: Unchanged;
+    context: ConditionalSchemaContext;
+}>;

package/dist/plugins/conditional-schema/conditional-schema.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.conditionalSchemaPlugin = void 0;
+// ===========================================================================
+// L7  src/plugins/conditional-schema/conditional-schema.ts
+// Draft-07 if / then / else, as a THREE-BRANCH composite.
+//
+// Legacy semantics (docs/legacy-spec/plugin-catalog-relational.md#conditionalSchema):
+// evaluate `if`; on success apply `then`, otherwise apply `else`; a missing
+// arm passes. The `if` arm never reports — its only job is to choose.
+//
+// NOT carried over: legacy took three JSONSchema7 documents and evaluated them
+// with a private `evaluateSchema` that understood `type`, and `const`/`enum` at
+// two levels, and nothing else. The arms are sub-chains here, so they are the
+// same rules, run by the same engine, as everything else in the schema; this
+// file contains no schema evaluator at all.
+//
+// REPAIR (the defect a declaration-only fixture could not catch): if/then/else
+// constrains the SAME instance, not its elements, so the sub-chains are
+// NarrowedChain — a chain over Present<TValue, TState>. Declared as
+// ElementChain, as the design appendix had it, every call on a non-array slot
+// fails with SlotTypeMismatch<"string", never>. See
+// test/support/conditional-schema-as-designed.ts, which keeps that version
+// alive so the difference stays visible.
+// ===========================================================================
+const plugin_definition_1 = require("../../plugin-kit/plugin-definition");
+const create_rule_1 = require("../../plugin-kit/create-rule");
+const types_1 = require("../../types");
+function readArm(branchLabel) {
+    if (branchLabel === "then")
+        return "then";
+    if (branchLabel === "else")
+        return "else";
+    return "none";
+}
+/**
+ * The arm's own failure detail is kept and re-labelled with the arm, so a
+ * message factory can say WHICH arm rejected the value without the runtime
+ * having to know that if/then/else exists.
+ */
+function routeConditional(runners, thenIndex, elseIndex) {
+    const condition = runners[0];
+    return (value, ctx) => {
+        if (condition === undefined)
+            return types_1.PASS;
+        const matched = condition.run(value, ctx).ok;
+        const taken = matched ? thenIndex : elseIndex;
+        if (taken < 0)
+            return types_1.PASS;
+        const runner = runners[taken];
+        if (runner === undefined)
+            return types_1.PASS;
+        const outcome = runner.run(value, ctx);
+        return outcome.ok
+            ? types_1.PASS
+            : (0, types_1.fail)({ ...outcome.detail, branch: matched ? "then" : "else" });
+    };
+}
+/**
+ * WHICH argument positions carry a sub-chain cannot be recovered from a
+ * plugin's type at run time — a NarrowedChain and a RootPredicate are both
+ * plain functions once erased — so src/chain/collect-branch-rules.ts reads it
+ * from this declared field. definePlugin's spec does not carry it yet (see
+ * needsFromOthers), which is why it is spread on rather than passed in.
+ */
+exports.conditionalSchemaPlugin = (0, plugin_definition_1.definePlugin)()({
+    name: "conditionalSchema",
+    method: "conditionalSchema",
+    slots: ["object", "array", "string", "number", "boolean"],
+    build: (ctx, condition, then, otherwise) => {
+        const branches = [(0, create_rule_1.branch)("if", condition)];
+        const thenIndex = then === undefined ? -1 : branches.push((0, create_rule_1.branch)("then", then)) - 1;
+        const elseIndex = otherwise === undefined
+            ? -1
+            : branches.push((0, create_rule_1.branch)("else", otherwise)) - 1;
+        return (0, create_rule_1.composite)({
+            code: ctx.code,
+            messageFactory: ctx.messageFactory,
+            severity: ctx.severity,
+            branches,
+            combine: (runners) => routeConditional(runners, thenIndex, elseIndex),
+            describe: (detail) => `Value must match the "${readArm(detail.branch)}" schema`,
+            buildMessageContext: (detail) => ({ taken: readArm(detail.branch) }),
+        });
+    },
+    subChainArguments: [0, 1, 2],
+});

package/dist/plugins/conditional-schema/conditional-schema.mjs

@@ -0,0 +1,84 @@
+// ===========================================================================
+// L7  src/plugins/conditional-schema/conditional-schema.ts
+// Draft-07 if / then / else, as a THREE-BRANCH composite.
+//
+// Legacy semantics (docs/legacy-spec/plugin-catalog-relational.md#conditionalSchema):
+// evaluate `if`; on success apply `then`, otherwise apply `else`; a missing
+// arm passes. The `if` arm never reports — its only job is to choose.
+//
+// NOT carried over: legacy took three JSONSchema7 documents and evaluated them
+// with a private `evaluateSchema` that understood `type`, and `const`/`enum` at
+// two levels, and nothing else. The arms are sub-chains here, so they are the
+// same rules, run by the same engine, as everything else in the schema; this
+// file contains no schema evaluator at all.
+//
+// REPAIR (the defect a declaration-only fixture could not catch): if/then/else
+// constrains the SAME instance, not its elements, so the sub-chains are
+// NarrowedChain — a chain over Present<TValue, TState>. Declared as
+// ElementChain, as the design appendix had it, every call on a non-array slot
+// fails with SlotTypeMismatch<"string", never>. See
+// test/support/conditional-schema-as-designed.ts, which keeps that version
+// alive so the difference stays visible.
+// ===========================================================================
+import { definePlugin } from "../../plugin-kit/plugin-definition.mjs";
+import { branch, composite } from "../../plugin-kit/create-rule.mjs";
+import { PASS, fail } from "../../types/index.mjs";
+function readArm(branchLabel) {
+    if (branchLabel === "then")
+        return "then";
+    if (branchLabel === "else")
+        return "else";
+    return "none";
+}
+/**
+ * The arm's own failure detail is kept and re-labelled with the arm, so a
+ * message factory can say WHICH arm rejected the value without the runtime
+ * having to know that if/then/else exists.
+ */
+function routeConditional(runners, thenIndex, elseIndex) {
+    const condition = runners[0];
+    return (value, ctx) => {
+        if (condition === undefined)
+            return PASS;
+        const matched = condition.run(value, ctx).ok;
+        const taken = matched ? thenIndex : elseIndex;
+        if (taken < 0)
+            return PASS;
+        const runner = runners[taken];
+        if (runner === undefined)
+            return PASS;
+        const outcome = runner.run(value, ctx);
+        return outcome.ok
+            ? PASS
+            : fail({ ...outcome.detail, branch: matched ? "then" : "else" });
+    };
+}
+/**
+ * WHICH argument positions carry a sub-chain cannot be recovered from a
+ * plugin's type at run time — a NarrowedChain and a RootPredicate are both
+ * plain functions once erased — so src/chain/collect-branch-rules.ts reads it
+ * from this declared field. definePlugin's spec does not carry it yet (see
+ * needsFromOthers), which is why it is spread on rather than passed in.
+ */
+export const conditionalSchemaPlugin = /*#__PURE__*/ definePlugin()({
+    name: "conditionalSchema",
+    method: "conditionalSchema",
+    slots: ["object", "array", "string", "number", "boolean"],
+    build: (ctx, condition, then, otherwise) => {
+        const branches = [branch("if", condition)];
+        const thenIndex = then === undefined ? -1 : branches.push(branch("then", then)) - 1;
+        const elseIndex = otherwise === undefined
+            ? -1
+            : branches.push(branch("else", otherwise)) - 1;
+        return composite({
+            code: ctx.code,
+            messageFactory: ctx.messageFactory,
+            severity: ctx.severity,
+            branches,
+            combine: (runners) => routeConditional(runners, thenIndex, elseIndex),
+            describe: (detail) => `Value must match the "${readArm(detail.branch)}" schema`,
+            buildMessageContext: (detail) => ({ taken: readArm(detail.branch) }),
+        });
+    },
+    subChainArguments: [0, 1, 2],
+});

package/dist/plugins/conditional-schema/index.d.ts

@@ -0,0 +1,2 @@
+export { conditionalSchemaPlugin } from "./conditional-schema";
+export type { ConditionalArm, ConditionalSchemaContext, } from "./conditional-schema";

package/dist/plugins/conditional-schema/index.js

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

package/dist/plugins/conditional-schema/index.mjs

@@ -0,0 +1 @@
+export { conditionalSchemaPlugin } from "./conditional-schema.mjs";

package/dist/plugins/conditionalSchema.d.ts

@@ -0,0 +1 @@
+export * from "./conditional-schema/index";

package/dist/plugins/conditionalSchema.js

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

package/dist/plugins/conditionalSchema.mjs

@@ -0,0 +1 @@
+export * from "./conditional-schema/index.mjs";

package/dist/plugins/custom/custom.d.ts

@@ -0,0 +1,12 @@
+import { type MessageContextExtra, type TypeName } from "../../types";
+import type { SelfReader, Unchanged } from "../../plugin-kit/marker.types";
+/** What a user predicate may answer: a verdict, or a verdict with a message. */
+export type CustomOutcome = boolean | {
+    readonly valid: boolean;
+    readonly message?: string;
+};
+export declare const customPlugin: import("../../plugin-kit/plugin-definition").PluginDefinition<"custom", "custom", readonly TypeName[], {
+    args: readonly [validate: SelfReader<CustomOutcome>];
+    out: Unchanged;
+    context: MessageContextExtra;
+}>;

package/dist/plugins/custom/custom.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customPlugin = void 0;
+// ===========================================================================
+// L7  src/plugins/custom/custom.ts — the arbitrary predicate.
+//
+// Legacy `custom` kept the message its validator returned in a MUTABLE closure
+// variable (`dynamicMessage`) that `getErrorMessage` read back, so validating a
+// second value could report the first value's message. It also called the user
+// predicate twice: once to decide, once to build the message.
+//
+// Here the predicate runs EXACTLY ONCE and its message travels with the
+// outcome, inside IssueDetail.causes. Nothing is stored between calls.
+// ===========================================================================
+const types_1 = require("../../types");
+const create_rule_1 = require("../../plugin-kit/create-rule");
+const plugin_definition_1 = require("../../plugin-kit/plugin-definition");
+const CUSTOM_SLOTS = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "array",
+    "tuple",
+    "object",
+    "union",
+    "any",
+];
+function isAccepted(outcome) {
+    return typeof outcome === "boolean" ? outcome : outcome.valid;
+}
+function readOutcomeMessage(outcome) {
+    if (typeof outcome === "boolean")
+        return undefined;
+    return (0, types_1.isString)(outcome.message) ? outcome.message : undefined;
+}
+/** The predicate's own message, carried as the single cause of the failure. */
+function toCauses(message, path, code, severity) {
+    if (message === undefined)
+        return undefined;
+    return [{ path, code, message, severity }];
+}
+function readCauseMessage(causes) {
+    const first = causes?.[0];
+    return first === undefined ? undefined : first.message;
+}
+exports.customPlugin = (0, plugin_definition_1.definePlugin)()({
+    name: "custom",
+    method: "custom",
+    slots: CUSTOM_SLOTS,
+    build: (ctx, validate) => (0, create_rule_1.check)({
+        code: ctx.code,
+        messageFactory: ctx.messageFactory,
+        severity: ctx.severity,
+        run: (value, ruleContext) => {
+            const outcome = runPredicate(validate, value);
+            if (isAccepted(outcome))
+                return types_1.PASS;
+            return (0, types_1.fail)({
+                actual: value,
+                causes: toCauses(readOutcomeMessage(outcome), ruleContext.path, ctx.code, ctx.severity),
+            });
+        },
+        describe: (detail, messageContext) => readCauseMessage(detail.causes) ??
+            `${messageContext.path} custom validation failed`,
+        buildMessageContext: () => ({}),
+    }),
+});
+/** A predicate that throws is a FAILED validation, never a crashed validate(). */
+function runPredicate(validate, value) {
+    try {
+        return validate(value);
+    }
+    catch (thrown) {
+        return { valid: false, message: describeThrown(thrown) };
+    }
+}
+function describeThrown(thrown) {
+    if (thrown instanceof Error)
+        return thrown.message;
+    return (0, types_1.isPlainObject)(thrown) ? undefined : String(thrown);
+}

package/dist/plugins/custom/custom.mjs

@@ -0,0 +1,79 @@
+// ===========================================================================
+// L7  src/plugins/custom/custom.ts — the arbitrary predicate.
+//
+// Legacy `custom` kept the message its validator returned in a MUTABLE closure
+// variable (`dynamicMessage`) that `getErrorMessage` read back, so validating a
+// second value could report the first value's message. It also called the user
+// predicate twice: once to decide, once to build the message.
+//
+// Here the predicate runs EXACTLY ONCE and its message travels with the
+// outcome, inside IssueDetail.causes. Nothing is stored between calls.
+// ===========================================================================
+import { PASS, fail, isPlainObject, isString, } from "../../types/index.mjs";
+import { check } from "../../plugin-kit/create-rule.mjs";
+import { definePlugin } from "../../plugin-kit/plugin-definition.mjs";
+const CUSTOM_SLOTS = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "array",
+    "tuple",
+    "object",
+    "union",
+    "any",
+];
+function isAccepted(outcome) {
+    return typeof outcome === "boolean" ? outcome : outcome.valid;
+}
+function readOutcomeMessage(outcome) {
+    if (typeof outcome === "boolean")
+        return undefined;
+    return isString(outcome.message) ? outcome.message : undefined;
+}
+/** The predicate's own message, carried as the single cause of the failure. */
+function toCauses(message, path, code, severity) {
+    if (message === undefined)
+        return undefined;
+    return [{ path, code, message, severity }];
+}
+function readCauseMessage(causes) {
+    const first = causes?.[0];
+    return first === undefined ? undefined : first.message;
+}
+export const customPlugin = /*#__PURE__*/ definePlugin()({
+    name: "custom",
+    method: "custom",
+    slots: CUSTOM_SLOTS,
+    build: (ctx, validate) => check({
+        code: ctx.code,
+        messageFactory: ctx.messageFactory,
+        severity: ctx.severity,
+        run: (value, ruleContext) => {
+            const outcome = runPredicate(validate, value);
+            if (isAccepted(outcome))
+                return PASS;
+            return fail({
+                actual: value,
+                causes: toCauses(readOutcomeMessage(outcome), ruleContext.path, ctx.code, ctx.severity),
+            });
+        },
+        describe: (detail, messageContext) => readCauseMessage(detail.causes) ??
+            `${messageContext.path} custom validation failed`,
+        buildMessageContext: () => ({}),
+    }),
+});
+/** A predicate that throws is a FAILED validation, never a crashed validate(). */
+function runPredicate(validate, value) {
+    try {
+        return validate(value);
+    }
+    catch (thrown) {
+        return { valid: false, message: describeThrown(thrown) };
+    }
+}
+function describeThrown(thrown) {
+    if (thrown instanceof Error)
+        return thrown.message;
+    return isPlainObject(thrown) ? undefined : String(thrown);
+}

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

@@ -0,0 +1 @@
+export { customPlugin, type CustomOutcome } from "./custom";

package/dist/plugins/custom/index.js

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

package/dist/plugins/custom/index.mjs

@@ -0,0 +1 @@
+export { customPlugin } from "./custom.mjs";

package/dist/plugins/custom.d.ts

@@ -1,60 +1 @@
-import { ValidationOptions, MessageContext } from "../core/plugin/types";
-/**
- * @luq-plugin
- * @name custom
- * @category standard
- * @description Allows custom validation logic
- * @allowedTypes ["string", "number", "boolean", "date", "array", "object", "tuple", "union"]
- * @example
- * ```typescript
- * // Basic custom validation
- * builder.v("username", b => b.string
- *   .custom((value) => {
- *     return !reservedUsernames.includes(value);
- *   }, {
- *     code: 'RESERVED_USERNAME',
- *     messageFactory: ({ path }) => `${path} username is reserved`
- *   })
- * )
- *
- * // With access to all values
- * builder.v("confirmPassword", b => b.string
- *   .custom((value, rootData) => {
- *     return value === rootData.password;
- *   }, {
- *     code: 'PASSWORD_MISMATCH',
- *     messageFactory: ({ path }) => `${path} passwords do not match`
- *   })
- * )
- * ```
- * @params
- * - validator: (value: any, rootData?: any) => boolean - Custom validation function
- * - options?: { code?: string; messageFactory?: (context: MessageContext) => string } - Error customization
- * @returns Validation function with custom logic
- * @customError
- * ```typescript
- * .custom(
- *   (value) => value.length > 5,
- *   {
- *     messageFactory: ({ path, value }) =>
- *       `${path} custom validation failed (received: ${value})`
- *   }
- * )
- * ```
- */
-export declare const customPlugin: import("../index").TypedPlugin<"custom", "custom", (validator: (value: any, rootData?: any) => boolean | {
-    valid: boolean;
-    message?: string;
-}, options?: ValidationOptions & {
-    messageFactory?: (context: MessageContext) => string;
-}) => {
-    check: (value: any, rootData?: any) => boolean;
-    code: string;
-    getErrorMessage: (value: any, path: string) => string;
-    params: (((value: any, rootData?: any) => boolean | {
-        valid: boolean;
-        message?: string;
-    }) | (ValidationOptions<{}> & {
-        messageFactory?: (context: MessageContext) => string;
-    }))[];
-}, readonly ["string", "number", "boolean", "date", "array", "object", "tuple", "union"], "validator", "standard">;
+export * from "./custom/index";

package/dist/plugins/custom.js

@@ -1 +1,2 @@
-"use strict";var l=Object.defineProperty;var T=Object.getOwnPropertyDescriptor;var p=Object.getOwnPropertyNames;var d=Object.prototype.hasOwnProperty;var g=(a,e)=>{for(var o in e)l(a,o,{get:e[o],enumerable:!0})},y=(a,e,o,m)=>{if(e&&typeof e=="object"||typeof e=="function")for(let s of p(e))!d.call(a,s)&&s!==o&&l(a,s,{get:()=>e[s],enumerable:!(m=T(e,s))||m.enumerable});return a};var c=a=>y(l({},"__esModule",{value:!0}),a);var I={};g(I,{customPlugin:()=>h});module.exports=c(I);var f=(a,e,o,m)=>{let r=(n=>(...i)=>{let t=n(...i);return t&&typeof t=="object"&&"check"in t?{...t,pluginName:m}:t})(o);switch(a){case"conditional":return(n,...i)=>r(n,...i);case"fieldReference":return(n,...i)=>r(n,...i);case"multiFieldReference":return r;case"transform":return n=>r(n);case"arrayElement":return(n,...i)=>r(n,...i);case"context":return n=>r(n);default:return r}};function u(a){let{name:e,methodName:o,allowedTypes:m,category:s,impl:r}=a;return{name:e,methodName:o,allowedTypes:m,category:s,create:()=>f(s,o,r,e)}}var N="CUSTOM_VALIDATION_FAILED",x=["string","number","boolean","date","array","object","tuple","union"],h=u({name:"custom",methodName:"custom",allowedTypes:x,category:"standard",impl:(a,e)=>{let o=e?.code||N,m="Custom validation failed",s=e?.messageFactory||(n=>`${n.path} ${m.toLowerCase()}`),r;return{check:(n,i)=>{try{let t=a(n,i);return typeof t=="boolean"?t:t&&typeof t=="object"&&"valid"in t?(r=t.message,t.valid):!1}catch{return!1}},code:o,getErrorMessage:(n,i)=>r||s({path:i,value:n,code:o}),params:[a,e]}}});0&&(module.exports={customPlugin});
+"use strict";
+module.exports = require("./custom/index");

package/dist/plugins/custom.mjs

@@ -1 +1 @@
-var u=(s,r,o,i)=>{let t=(e=>(...a)=>{let n=e(...a);return n&&typeof n=="object"&&"check"in n?{...n,pluginName:i}:n})(o);switch(s){case"conditional":return(e,...a)=>t(e,...a);case"fieldReference":return(e,...a)=>t(e,...a);case"multiFieldReference":return t;case"transform":return e=>t(e);case"arrayElement":return(e,...a)=>t(e,...a);case"context":return e=>t(e);default:return t}};function l(s){let{name:r,methodName:o,allowedTypes:i,category:m,impl:t}=s;return{name:r,methodName:o,allowedTypes:i,category:m,create:()=>u(m,o,t,r)}}var T="CUSTOM_VALIDATION_FAILED",p=["string","number","boolean","date","array","object","tuple","union"],y=l({name:"custom",methodName:"custom",allowedTypes:p,category:"standard",impl:(s,r)=>{let o=r?.code||T,i="Custom validation failed",m=r?.messageFactory||(e=>`${e.path} ${i.toLowerCase()}`),t;return{check:(e,a)=>{try{let n=s(e,a);return typeof n=="boolean"?n:n&&typeof n=="object"&&"valid"in n?(t=n.message,n.valid):!1}catch{return!1}},code:o,getErrorMessage:(e,a)=>t||m({path:a,value:e,code:o}),params:[s,r]}}});export{y as customPlugin};
+export * from "./custom/index.mjs";