@maroonedog/luq 0.1.2-alpha → 2.0.0

package/dist/plugins/required.js

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

package/dist/plugins/required.mjs

@@ -1 +1 @@
-var u=(t,r,o,i)=>{let e=(n=>(...a)=>{let s=n(...a);return s&&typeof s=="object"&&"check"in s?{...s,pluginName:i}:s})(o);switch(t){case"conditional":return(n,...a)=>e(n,...a);case"fieldReference":return(n,...a)=>e(n,...a);case"multiFieldReference":return e;case"transform":return n=>e(n);case"arrayElement":return(n,...a)=>e(n,...a);case"context":return n=>e(n);default:return e}};function l(t){let{name:r,methodName:o,allowedTypes:i,category:m,impl:e}=t;return{name:r,methodName:o,allowedTypes:i,category:m,create:()=>u(m,o,e,r)}}var T="required",d=t=>`${t} is required`,p=["array","boolean","number","object","string","date","union","tuple"],c=l({name:"required",methodName:"required",allowedTypes:p,category:"standard",impl:t=>{let r=t?.code||T,o=t?.messageFactory||(e=>d(e.field)),i=t?.fieldName,m=t?.allowNull||!1;return{check:e=>m?!(e===void 0||e===""):!(e==null||e===""),code:r,getErrorMessage:(e,n)=>o({field:i||n,path:n,value:e,code:r}),params:t?[t]:[]}}});export{c as requiredPlugin};
+export * from "./required/index.mjs";

package/dist/plugins/requiredIf.d.ts

@@ -1,66 +1 @@
-import { ValidationOptions, MessageContext } from "../core/plugin/types";
-export interface RequiredIfContext extends MessageContext {
-    condition?: boolean;
-}
-/**
- * @luq-plugin
- * @name requiredIf
- * @category conditional
- * @description Makes a field required based on a dynamic condition evaluated at validation time, with support for array context validation
- * @allowedTypes ["string", "number", "boolean", "array", "object", "date", "union"]
- * @example
- * ```typescript
- * // Basic conditional required
- * const validator = Builder()
- *   .use(requiredIfPlugin)
- *   .for<ContactForm>()
- *   .v("email", (b) => b.string.requiredIf(values => values.contactMethod === 'email'))
- *   .v("phone", (b) => b.string.requiredIf(values => values.contactMethod === 'phone'))
- *   .build();
- *
- * // Multiple conditions
- * builder.v("ssn", b =>
- *   b.string.requiredIf(values =>
- *     values.country === 'US' && values.employmentType === 'full-time'
- *   )
- * )
- *
- * // Array context validation - conditional required within array items
- * builder.v("items[].billingAddress", b =>
- *   b.string.requiredIf((allValues, arrayContext) => {
- *     // arrayContext.index: current index in array
- *     // arrayContext.item: current object at index
- *     // arrayContext.array: full array
- *     return arrayContext?.item?.type === 'premium';
- *   })
- * )
- *
- * // Mixed validation - access both form values and array context
- * builder.v("orders[].shippingAddress", b =>
- *   b.string.requiredIf((allValues, arrayContext) => {
- *     const isInternational = allValues.country !== 'US';
- *     const requiresShipping = arrayContext?.item?.requiresShipping;
- *     return isInternational && requiresShipping;
- *   })
- * )
- * ```
- * @params
- * - condition: (allValues: TObject, arrayContext?: ArrayContext) => boolean - Condition function that receives all form values and optional array context
- * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
- * @returns Validation function that checks if field is required based on condition
- * @customError
- * ```typescript
- * .requiredIf(
- *   (values, arrayContext) => values.hasAccount && arrayContext?.item?.isActive,
- *   { messageFactory: ({ path }) => `${path} is required when account exists and item is active` }
- * )
- * ```
- * @since 0.1.0-alpha
- */
-export declare const requiredIfPlugin: import("../index").TypedPlugin<"requiredIf", "requiredIf", <TObject>(condition: (allValues: TObject, arrayContext?: import("./types").ArrayContext) => boolean, options?: ValidationOptions<RequiredIfContext>) => {
-    check: (value: any, allValues?: TObject, arrayContext?: import("./types").ArrayContext) => boolean;
-    code: string;
-    getErrorMessage: (value: any, path: string, allValues?: TObject, arrayContext?: import("./types").ArrayContext) => string;
-    params: (((allValues: TObject, arrayContext?: import("./types").ArrayContext) => boolean) | ValidationOptions<RequiredIfContext>)[];
-    evaluateCondition: (allValues?: TObject, arrayContext?: import("./types").ArrayContext) => boolean;
-}, readonly ["string", "number", "boolean", "array", "object", "date", "union"], "validator", "conditional">;
+export * from "./required-if/index";

package/dist/plugins/requiredIf.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=(n,t)=>{for(var o in t)l(n,o,{get:t[o],enumerable:!0})},y=(n,t,o,s)=>{if(t&&typeof t=="object"||typeof t=="function")for(let e of p(t))!d.call(n,e)&&e!==o&&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 C={};g(C,{requiredIfPlugin:()=>P});module.exports=c(C);var f=(n,t,o,s)=>{let r=(a=>(...i)=>{let m=a(...i);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:s}:m})(o);switch(n){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(n){let{name:t,methodName:o,allowedTypes:s,category:e,impl:r}=n;return{name:t,methodName:o,allowedTypes:s,category:e,create:()=>f(e,o,r,t)}}var x="requiredIf",N="Field is required when condition is met";function I(n){return N}var h=["string","number","boolean","array","object","date","union"],P=u({name:"requiredIf",methodName:"requiredIf",allowedTypes:h,category:"conditional",impl:(n,t)=>{let o=t?.code||x,s=t?.messageFactory||I;return{check:(e,r,a)=>r&&n(r,a)?!(e==null||e===""):!0,code:o,getErrorMessage:(e,r,a,i)=>{let m=a?n(a,i):!1;return s({path:r,value:e,code:o,condition:m})},params:[n,t],evaluateCondition:(e,r)=>e?n(e,r):!1}}});0&&(module.exports={requiredIfPlugin});
+"use strict";
+module.exports = require("./required-if/index");

package/dist/plugins/requiredIf.mjs

@@ -1 +1 @@
-var u=(a,o,i,m)=>{let e=(n=>(...r)=>{let s=n(...r);return s&&typeof s=="object"&&"check"in s?{...s,pluginName:m}:s})(i);switch(a){case"conditional":return(n,...r)=>e(n,...r);case"fieldReference":return(n,...r)=>e(n,...r);case"multiFieldReference":return e;case"transform":return n=>e(n);case"arrayElement":return(n,...r)=>e(n,...r);case"context":return n=>e(n);default:return e}};function l(a){let{name:o,methodName:i,allowedTypes:m,category:t,impl:e}=a;return{name:o,methodName:i,allowedTypes:m,category:t,create:()=>u(t,i,e,o)}}var T="requiredIf",p="Field is required when condition is met";function d(a){return p}var g=["string","number","boolean","array","object","date","union"],x=l({name:"requiredIf",methodName:"requiredIf",allowedTypes:g,category:"conditional",impl:(a,o)=>{let i=o?.code||T,m=o?.messageFactory||d;return{check:(t,e,n)=>e&&a(e,n)?!(t==null||t===""):!0,code:i,getErrorMessage:(t,e,n,r)=>{let s=n?a(n,r):!1;return m({path:e,value:t,code:i,condition:s})},params:[a,o],evaluateCondition:(t,e)=>t?a(t,e):!1}}});export{x as requiredIfPlugin};
+export * from "./required-if/index.mjs";

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

@@ -0,0 +1 @@
+export { skipPlugin } from "./skip";

package/dist/plugins/skip/index.js

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

package/dist/plugins/skip/index.mjs

@@ -0,0 +1 @@
+export { skipPlugin } from "./skip.mjs";

package/dist/plugins/skip/skip.d.ts

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

package/dist/plugins/skip/skip.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.skipPlugin = void 0;
+const create_rule_1 = require("../../plugin-kit/create-rule");
+const plugin_definition_1 = require("../../plugin-kit/plugin-definition");
+const SKIP_SLOTS = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "array",
+    "tuple",
+    "object",
+    "union",
+    "any",
+];
+exports.skipPlugin = (0, plugin_definition_1.definePlugin)()({
+    name: "skip",
+    method: "skip",
+    slots: SKIP_SLOTS,
+    build: (ctx, when) => (0, create_rule_1.gate)(ctx.code, (_value, ruleContext) => !when(ruleContext.root, ruleContext.item)),
+});

package/dist/plugins/skip/skip.mjs

@@ -0,0 +1,19 @@
+import { gate } from "../../plugin-kit/create-rule.mjs";
+import { definePlugin } from "../../plugin-kit/plugin-definition.mjs";
+const SKIP_SLOTS = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "array",
+    "tuple",
+    "object",
+    "union",
+    "any",
+];
+export const skipPlugin = /*#__PURE__*/ definePlugin()({
+    name: "skip",
+    method: "skip",
+    slots: SKIP_SLOTS,
+    build: (ctx, when) => gate(ctx.code, (_value, ruleContext) => !when(ruleContext.root, ruleContext.item)),
+});

package/dist/plugins/skip.d.ts

@@ -1,57 +1 @@
-import { ValidationOptions } from "../core/plugin/types";
-/**
- * @luq-plugin
- * @name skip
- * @category conditional
- * @description Completely skips validation for a field based on a dynamic condition
- * @allowedTypes ["string", "number", "boolean", "array", "object", "date", "union"]
- * @example
- * ```typescript
- * // Skip validation when not needed
- * const validator = Builder()
- *   .use(skipPlugin)
- *   .for<FormData>()
- *   .v("advancedOptions", b =>
- *     b.object
- *       .skip(values => !values.showAdvanced)
- *       .required()
- *   )
- *   .build();
- *
- * // Skip debug fields in production
- * builder.v("debugInfo", b =>
- *   b.string
- *     .skip(values => values.environment === 'production')
- *     .min(10)
- * )
- *
- * // Skip entire sections conditionally
- * builder.v("enterpriseSettings", b =>
- *   b.object
- *     .skip(values => values.plan !== 'enterprise')
- *     .recursively()
- * )
- * ```
- * @params
- * - condition: (allValues: TObject) => boolean - Function that returns true if field should be skipped
- * - options?: ValidationOptions - Optional configuration
- * @returns Validation function that skips field entirely when condition is true
- * @customError
- * ```typescript
- * This plugin does not generate errors - it removes fields from validation
- * ```
- * @since 0.1.0-alpha
- */
-export declare const skipPlugin: import("../index").TypedPlugin<"skip", "skip", <TObject>(condition: (allValues: TObject) => boolean, options?: ValidationOptions) => {
-    check: (value: any, allValues?: TObject) => boolean;
-    shouldSkipAllValidation: (value: any, allValues?: TObject) => boolean;
-    code: string;
-    getErrorMessage: () => string;
-    params: (ValidationOptions<{}> | ((allValues: TObject) => boolean))[];
-    metadata: {
-        type: string;
-        category: string;
-        skipCondition: (allValues: TObject) => boolean;
-        async: boolean;
-    };
-}, readonly ["string", "number", "boolean", "array", "object", "date", "union"], "validator", "conditional">;
+export * from "./skip/index";

package/dist/plugins/skip.js

@@ -1 +1,2 @@
-"use strict";var s=Object.defineProperty;var T=Object.getOwnPropertyDescriptor;var u=Object.getOwnPropertyNames;var d=Object.prototype.hasOwnProperty;var g=(e,n)=>{for(var t in n)s(e,t,{get:n[t],enumerable:!0})},y=(e,n,t,r)=>{if(n&&typeof n=="object"||typeof n=="function")for(let o of u(n))!d.call(e,o)&&o!==t&&s(e,o,{get:()=>n[o],enumerable:!(r=T(n,o))||r.enumerable});return e};var c=e=>y(s({},"__esModule",{value:!0}),e);var x={};g(x,{skipPlugin:()=>h});module.exports=c(x);var f=(e,n,t,r)=>{let i=(a=>(...l)=>{let m=a(...l);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:r}:m})(t);switch(e){case"conditional":return(a,...l)=>i(a,...l);case"fieldReference":return(a,...l)=>i(a,...l);case"multiFieldReference":return i;case"transform":return a=>i(a);case"arrayElement":return(a,...l)=>i(a,...l);case"context":return a=>i(a);default:return i}};function p(e){let{name:n,methodName:t,allowedTypes:r,category:o,impl:i}=e;return{name:n,methodName:t,allowedTypes:r,category:o,create:()=>f(o,t,i,n)}}var N=["string","number","boolean","array","object","date","union"],h=p({name:"skip",methodName:"skip",allowedTypes:N,category:"conditional",impl:(e,n)=>({check:(t,r)=>!0,shouldSkipAllValidation:(t,r)=>r?e(r):!1,code:"skip",getErrorMessage:()=>"Skip condition not met",params:[e,n],metadata:{type:"conditional",category:"skip",skipCondition:e,async:!1}})});0&&(module.exports={skipPlugin});
+"use strict";
+module.exports = require("./skip/index");

package/dist/plugins/skip.mjs

@@ -1 +1 @@
-var p=(t,i,o,a)=>{let n=(e=>(...r)=>{let l=e(...r);return l&&typeof l=="object"&&"check"in l?{...l,pluginName:a}:l})(o);switch(t){case"conditional":return(e,...r)=>n(e,...r);case"fieldReference":return(e,...r)=>n(e,...r);case"multiFieldReference":return n;case"transform":return e=>n(e);case"arrayElement":return(e,...r)=>n(e,...r);case"context":return e=>n(e);default:return n}};function s(t){let{name:i,methodName:o,allowedTypes:a,category:m,impl:n}=t;return{name:i,methodName:o,allowedTypes:a,category:m,create:()=>p(m,o,n,i)}}var T=["string","number","boolean","array","object","date","union"],g=s({name:"skip",methodName:"skip",allowedTypes:T,category:"conditional",impl:(t,i)=>({check:(o,a)=>!0,shouldSkipAllValidation:(o,a)=>a?t(a):!1,code:"skip",getErrorMessage:()=>"Skip condition not met",params:[t,i],metadata:{type:"conditional",category:"skip",skipCondition:t,async:!1}})});export{g as skipPlugin};
+export * from "./skip/index.mjs";

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

@@ -0,0 +1,2 @@
+export { stitchPlugin } from "./stitch";
+export type { StitchCheck, StitchExtra, StitchFieldValues, StitchFieldsOf, StitchOutcome, } from "./stitch";

package/dist/plugins/stitch/index.js

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

package/dist/plugins/stitch/index.mjs

@@ -0,0 +1 @@
+export { stitchPlugin } from "./stitch.mjs";

package/dist/plugins/stitch/stitch.d.ts

@@ -0,0 +1,30 @@
+import type { PickPaths } from "../../path/index";
+import type { FieldRefs, Unchanged } from "../../plugin-kit/marker.types";
+/** The bundle handed to the check, keyed by the path exactly as declared. */
+export type StitchFieldValues = Readonly<Record<string, unknown>>;
+/**
+ * PickPaths applied to a declared tuple: `StitchFieldsOf<Order, ["price",
+ * "quantity"]>` is `{ readonly price: number; readonly quantity: number }`.
+ * The chain method is not generic over its own arguments (the plugin contract
+ * frozen at step 7 gives every non-transform plugin the same shape), so this
+ * type is what a call site narrows the bundle TO with its own guard, which is
+ * the same alternative-2 move readExternalContext makes for async context.
+ */
+export type StitchFieldsOf<TRoot, TFields extends readonly string[]> = PickPaths<TRoot, TFields>;
+/** 1.x's `{ valid, message? }`, unchanged. */
+export interface StitchOutcome {
+    readonly valid: boolean;
+    readonly message?: string;
+}
+export type StitchCheck = (fieldValues: StitchFieldValues, value: unknown, root: unknown) => StitchOutcome;
+/** 1.x's messageFactory context for this plugin, minus the re-run. */
+export interface StitchExtra {
+    readonly fields: readonly string[];
+    readonly fieldValues: StitchFieldValues;
+    readonly message?: string;
+}
+export declare const stitchPlugin: import("../../plugin-kit/plugin-definition").PluginDefinition<"stitch", "stitch", readonly ["string", "number", "boolean", "date", "object", "array", "tuple", "union"], {
+    args: readonly [fields: FieldRefs, check: StitchCheck];
+    out: Unchanged;
+    context: StitchExtra;
+}>;

package/dist/plugins/stitch/stitch.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stitchPlugin = void 0;
+// ===========================================================================
+// L7  src/plugins/stitch/stitch.ts — THE ONE stitch.
+// 1.x shipped three implementations of this responsibility (stitch.ts,
+// stitch-typed.ts, stitchSimple.ts), all three claiming methodName "stitch".
+// This is their single successor: the positional shape of stitch.ts
+// (fields, check, options) with stitchSimple's untyped call still accepted,
+// because the declared paths are the only thing the type system needs to see.
+//
+// Two 1.x defects are NOT carried over:
+//   - the check function was run a SECOND time to build the message; here the
+//     outcome's message travels in the IssueDetail, so a user function with a
+//     cost or a side effect runs exactly once;
+//   - "no allValues -> fail" is gone: RuleContext.root is always present.
+// ===========================================================================
+const types_1 = require("../../types");
+const create_rule_1 = require("../../plugin-kit/create-rule");
+const plugin_definition_1 = require("../../plugin-kit/plugin-definition");
+const index_1 = require("../../path/index");
+const STITCH_SLOTS = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "object",
+    "array",
+    "tuple",
+    "union",
+];
+const NO_FIELD_VALUES = Object.freeze({});
+function collectFieldValues(declared, root) {
+    const collected = {};
+    for (const field of declared)
+        collected[field.path] = field.read(root);
+    return collected;
+}
+exports.stitchPlugin = (0, plugin_definition_1.definePlugin)()({
+    name: "stitch",
+    method: "stitch",
+    slots: STITCH_SLOTS,
+    build: (ctx, fields, runCheck) => {
+        const declared = fields.map((path) => ({
+            path,
+            read: (0, index_1.createValueReader)((0, index_1.parseFieldPath)(path)),
+        }));
+        const declaredPaths = declared.map((field) => field.path);
+        return (0, create_rule_1.check)({
+            code: ctx.code,
+            messageFactory: ctx.messageFactory,
+            severity: ctx.severity,
+            run: (value, runCtx) => {
+                const fieldValues = collectFieldValues(declared, runCtx.root);
+                const outcome = runCheck(fieldValues, value, runCtx.root);
+                return outcome.valid
+                    ? types_1.PASS
+                    : (0, types_1.fail)({ expected: fieldValues, actual: outcome.message });
+            },
+            describe: (detail, msgCtx) => (0, types_1.isString)(detail.actual)
+                ? detail.actual
+                : `Cross-field validation failed for ${msgCtx.path}`,
+            buildMessageContext: (detail) => ({
+                fields: declaredPaths,
+                fieldValues: (0, types_1.isPlainObject)(detail.expected)
+                    ? detail.expected
+                    : NO_FIELD_VALUES,
+                message: (0, types_1.isString)(detail.actual) ? detail.actual : undefined,
+            }),
+        });
+    },
+});

package/dist/plugins/stitch/stitch.mjs

@@ -0,0 +1,69 @@
+// ===========================================================================
+// L7  src/plugins/stitch/stitch.ts — THE ONE stitch.
+// 1.x shipped three implementations of this responsibility (stitch.ts,
+// stitch-typed.ts, stitchSimple.ts), all three claiming methodName "stitch".
+// This is their single successor: the positional shape of stitch.ts
+// (fields, check, options) with stitchSimple's untyped call still accepted,
+// because the declared paths are the only thing the type system needs to see.
+//
+// Two 1.x defects are NOT carried over:
+//   - the check function was run a SECOND time to build the message; here the
+//     outcome's message travels in the IssueDetail, so a user function with a
+//     cost or a side effect runs exactly once;
+//   - "no allValues -> fail" is gone: RuleContext.root is always present.
+// ===========================================================================
+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";
+import { createValueReader, parseFieldPath } from "../../path/index.mjs";
+const STITCH_SLOTS = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "object",
+    "array",
+    "tuple",
+    "union",
+];
+const NO_FIELD_VALUES = Object.freeze({});
+function collectFieldValues(declared, root) {
+    const collected = {};
+    for (const field of declared)
+        collected[field.path] = field.read(root);
+    return collected;
+}
+export const stitchPlugin = /*#__PURE__*/ definePlugin()({
+    name: "stitch",
+    method: "stitch",
+    slots: STITCH_SLOTS,
+    build: (ctx, fields, runCheck) => {
+        const declared = fields.map((path) => ({
+            path,
+            read: createValueReader(parseFieldPath(path)),
+        }));
+        const declaredPaths = declared.map((field) => field.path);
+        return check({
+            code: ctx.code,
+            messageFactory: ctx.messageFactory,
+            severity: ctx.severity,
+            run: (value, runCtx) => {
+                const fieldValues = collectFieldValues(declared, runCtx.root);
+                const outcome = runCheck(fieldValues, value, runCtx.root);
+                return outcome.valid
+                    ? PASS
+                    : fail({ expected: fieldValues, actual: outcome.message });
+            },
+            describe: (detail, msgCtx) => isString(detail.actual)
+                ? detail.actual
+                : `Cross-field validation failed for ${msgCtx.path}`,
+            buildMessageContext: (detail) => ({
+                fields: declaredPaths,
+                fieldValues: isPlainObject(detail.expected)
+                    ? detail.expected
+                    : NO_FIELD_VALUES,
+                message: isString(detail.actual) ? detail.actual : undefined,
+            }),
+        });
+    },
+});

package/dist/plugins/stitch.d.ts

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

package/dist/plugins/stitch.js

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

package/dist/plugins/stitch.mjs

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

package/dist/plugins/string-alphanumeric/index.d.ts

@@ -0,0 +1 @@
+export { stringAlphanumericPlugin } from "./string-alphanumeric";

package/dist/plugins/string-alphanumeric/index.js

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

package/dist/plugins/string-alphanumeric/index.mjs

@@ -0,0 +1 @@
+export { stringAlphanumericPlugin } from "./string-alphanumeric.mjs";

package/dist/plugins/string-alphanumeric/string-alphanumeric.d.ts

@@ -0,0 +1,8 @@
+import type { Unchanged } from "../../plugin-kit/marker.types";
+export declare const stringAlphanumericPlugin: import("../../plugin-kit/plugin-definition").PluginDefinition<"stringAlphanumeric", "alphanumeric", readonly ["string"], {
+    args: readonly [allowSpaces?: boolean];
+    out: Unchanged;
+    context: {
+        readonly allowSpaces: boolean;
+    };
+}>;

package/dist/plugins/string-alphanumeric/string-alphanumeric.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringAlphanumericPlugin = void 0;
+// ===========================================================================
+// L7  src/plugins/string-alphanumeric/string-alphanumeric.ts
+// `.alphanumeric(allowSpaces?)`. ASCII only, and the EMPTY STRING FAILS
+// (both patterns are `+`), exactly as in 1.x.
+//
+// The legacy code moved its ERROR CODE when allowSpaces was true
+// ("stringAlphanumeric_with_spaces"). An option value must not move the code,
+// so the code is always the plugin name and allowSpaces reaches a message
+// factory through the message context instead.
+// ===========================================================================
+const create_rule_1 = require("../../plugin-kit/create-rule");
+const plugin_definition_1 = require("../../plugin-kit/plugin-definition");
+const types_1 = require("../../types");
+const ALPHANUMERIC = /^[a-zA-Z0-9]+$/;
+const ALPHANUMERIC_WITH_SPACES = /^[a-zA-Z0-9\s]+$/;
+exports.stringAlphanumericPlugin = (0, plugin_definition_1.definePlugin)()({
+    name: "stringAlphanumeric",
+    method: "alphanumeric",
+    slots: ["string"],
+    build: (ctx, allowSpaces) => {
+        const spacesAllowed = allowSpaces === true;
+        const pattern = spacesAllowed ? ALPHANUMERIC_WITH_SPACES : ALPHANUMERIC;
+        return (0, create_rule_1.check)({
+            code: ctx.code,
+            messageFactory: ctx.messageFactory,
+            severity: ctx.severity,
+            run: (value) => !(0, types_1.isString)(value) || pattern.test(value)
+                ? types_1.PASS
+                : (0, types_1.fail)({ actual: value }),
+            describe: () => spacesAllowed
+                ? "String must contain only alphanumeric characters and spaces"
+                : "String must contain only alphanumeric characters",
+            buildMessageContext: () => ({ allowSpaces: spacesAllowed }),
+        });
+    },
+});

package/dist/plugins/string-alphanumeric/string-alphanumeric.mjs

@@ -0,0 +1,36 @@
+// ===========================================================================
+// L7  src/plugins/string-alphanumeric/string-alphanumeric.ts
+// `.alphanumeric(allowSpaces?)`. ASCII only, and the EMPTY STRING FAILS
+// (both patterns are `+`), exactly as in 1.x.
+//
+// The legacy code moved its ERROR CODE when allowSpaces was true
+// ("stringAlphanumeric_with_spaces"). An option value must not move the code,
+// so the code is always the plugin name and allowSpaces reaches a message
+// factory through the message context instead.
+// ===========================================================================
+import { check } from "../../plugin-kit/create-rule.mjs";
+import { definePlugin } from "../../plugin-kit/plugin-definition.mjs";
+import { PASS, fail, isString } from "../../types/index.mjs";
+const ALPHANUMERIC = /^[a-zA-Z0-9]+$/;
+const ALPHANUMERIC_WITH_SPACES = /^[a-zA-Z0-9\s]+$/;
+export const stringAlphanumericPlugin = /*#__PURE__*/ definePlugin()({
+    name: "stringAlphanumeric",
+    method: "alphanumeric",
+    slots: ["string"],
+    build: (ctx, allowSpaces) => {
+        const spacesAllowed = allowSpaces === true;
+        const pattern = spacesAllowed ? ALPHANUMERIC_WITH_SPACES : ALPHANUMERIC;
+        return check({
+            code: ctx.code,
+            messageFactory: ctx.messageFactory,
+            severity: ctx.severity,
+            run: (value) => !isString(value) || pattern.test(value)
+                ? PASS
+                : fail({ actual: value }),
+            describe: () => spacesAllowed
+                ? "String must contain only alphanumeric characters and spaces"
+                : "String must contain only alphanumeric characters",
+            buildMessageContext: () => ({ allowSpaces: spacesAllowed }),
+        });
+    },
+});

package/dist/plugins/string-base64/index.d.ts

@@ -0,0 +1 @@
+export { stringBase64Plugin } from "./string-base64";

package/dist/plugins/string-base64/index.js

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

package/dist/plugins/string-base64/index.mjs

@@ -0,0 +1 @@
+export { stringBase64Plugin } from "./string-base64.mjs";

package/dist/plugins/string-base64/string-base64.d.ts

@@ -0,0 +1,12 @@
+import type { Unchanged } from "../../plugin-kit/marker.types";
+export interface Base64FormatOptions {
+    /** Selects the "-_" alphabet in place of "+/". */
+    readonly urlSafe?: boolean;
+}
+export declare const stringBase64Plugin: import("../../plugin-kit/plugin-definition").PluginDefinition<"stringBase64", "base64", readonly ["string"], {
+    args: readonly [options?: Base64FormatOptions];
+    out: Unchanged;
+    context: {
+        readonly urlSafe: boolean;
+    };
+}>;

package/dist/plugins/string-base64/string-base64.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringBase64Plugin = void 0;
+// ===========================================================================
+// L7  src/plugins/string-base64/string-base64.ts
+// `.base64(options?)`. Recognition only — nothing here decodes, so there is no
+// Buffer/atob dependency and no environment-specific answer. The one place
+// that owns base64 as an ENCODING is string-content-encoding.
+//
+// 1.x semantics kept verbatim: the empty string is valid, the length must be a
+// multiple of 4, and padding is required in urlSafe mode too.
+// ===========================================================================
+const create_rule_1 = require("../../plugin-kit/create-rule");
+const plugin_definition_1 = require("../../plugin-kit/plugin-definition");
+const types_1 = require("../../types");
+const STANDARD = /^[A-Za-z0-9+/]*={0,2}$/;
+const URL_SAFE = /^[A-Za-z0-9\-_]*={0,2}$/;
+exports.stringBase64Plugin = (0, plugin_definition_1.definePlugin)()({
+    name: "stringBase64",
+    method: "base64",
+    slots: ["string"],
+    build: (ctx, options) => {
+        const urlSafe = options?.urlSafe === true;
+        const pattern = urlSafe ? URL_SAFE : STANDARD;
+        return (0, create_rule_1.check)({
+            code: ctx.code,
+            messageFactory: ctx.messageFactory,
+            severity: ctx.severity,
+            run: (value) => {
+                if (!(0, types_1.isString)(value) || value.length === 0)
+                    return types_1.PASS;
+                return value.length % 4 === 0 && pattern.test(value)
+                    ? types_1.PASS
+                    : (0, types_1.fail)({ actual: value });
+            },
+            describe: () => "Value must be a valid base64 encoded string",
+            buildMessageContext: () => ({ urlSafe }),
+        });
+    },
+});