@warlock.js/seal 3.0.14

package/esm/rules/conditional/required-with-rules.d.ts

@@ -0,0 +1,26 @@
+import type { SchemaRule } from "../../types";
+/**
+ * Required with rule - field is required if another field is present
+ * Supports both global and sibling scope
+ */
+export declare const requiredWithRule: SchemaRule<{
+    field: string;
+    scope?: "global" | "sibling";
+}>;
+/**
+ * Required with all rule - field is required if all specified fields are present
+ * Supports both global and sibling scope
+ */
+export declare const requiredWithAllRule: SchemaRule<{
+    fields: string[];
+    scope?: "global" | "sibling";
+}>;
+/**
+ * Required with any rule - field is required if any of the specified fields is present
+ * Supports both global and sibling scope
+ */
+export declare const requiredWithAnyRule: SchemaRule<{
+    fields: string[];
+    scope?: "global" | "sibling";
+}>;
+//# sourceMappingURL=required-with-rules.d.ts.map

package/esm/rules/conditional/required-with-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"required-with-rules.d.ts","sourceRoot":"","sources":["../../../src/rules/conditional/required-with-rules.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,UAAU,CAAC;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;CAC9B,CAgBA,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,UAAU,CAAC;IAC3C,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;CAC9B,CAoBA,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,UAAU,CAAC;IAC3C,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;CAC9B,CAqBA,CAAC"}

package/esm/rules/conditional/required-with-rules.js

@@ -0,0 +1,63 @@
+import {get}from'@mongez/reinforcements';import {isEmpty}from'@mongez/supportive-is';import {getFieldValue}from'../../helpers/get-field-value.js';import {invalidRule,VALID_RULE}from'../../helpers/validation-helpers.js';/**
+ * Required with rule - field is required if another field is present
+ * Supports both global and sibling scope
+ */
+const requiredWithRule = {
+    name: "requiredWith",
+    description: "The field is required if another field is present",
+    sortOrder: -2,
+    requiresValue: false,
+    defaultErrorMessage: "The :input is required",
+    async validate(value, context) {
+        const fieldValue = getFieldValue(this, context);
+        // Field is required if the other field is present
+        if (isEmpty(value) && fieldValue !== undefined) {
+            return invalidRule(this, context);
+        }
+        return VALID_RULE;
+    },
+};
+/**
+ * Required with all rule - field is required if all specified fields are present
+ * Supports both global and sibling scope
+ */
+const requiredWithAllRule = {
+    name: "requiredWithAll",
+    description: "The field is required if all specified fields are present",
+    sortOrder: -2,
+    requiresValue: false,
+    defaultErrorMessage: "The :input is required",
+    async validate(value, context) {
+        const { fields, scope = "global" } = this.context.options;
+        const source = scope === "sibling" ? context.parent : context.allValues;
+        // Check if all fields are present
+        const allPresent = fields.every(field => get(source, field) !== undefined);
+        // Field is required if all other fields are present
+        if (isEmpty(value) && allPresent) {
+            return invalidRule(this, context);
+        }
+        return VALID_RULE;
+    },
+};
+/**
+ * Required with any rule - field is required if any of the specified fields is present
+ * Supports both global and sibling scope
+ */
+const requiredWithAnyRule = {
+    name: "requiredWithAny",
+    description: "The field is required if any of the specified fields is present",
+    sortOrder: -2,
+    requiresValue: false,
+    defaultErrorMessage: "The :input is required",
+    async validate(value, context) {
+        const { fields, scope = "global" } = this.context.options;
+        const source = scope === "sibling" ? context.parent : context.allValues;
+        // Check if any field is present
+        const anyPresent = fields.some(field => get(source, field) !== undefined);
+        // Field is required if any other field is present
+        if (isEmpty(value) && anyPresent) {
+            return invalidRule(this, context);
+        }
+        return VALID_RULE;
+    },
+};export{requiredWithAllRule,requiredWithAnyRule,requiredWithRule};//# sourceMappingURL=required-with-rules.js.map

package/esm/rules/conditional/required-with-rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"required-with-rules.js","sources":["../../../src/rules/conditional/required-with-rules.ts"],"sourcesContent":[null],"names":[],"mappings":"2NAKA;;;AAGG;AACU,MAAA,gBAAgB,GAGxB;AACH,IAAA,IAAI,EAAE,cAAc;AACpB,IAAA,WAAW,EAAE,mDAAmD;IAChE,SAAS,EAAE,CAAC,CAAC;AACb,IAAA,aAAa,EAAE,KAAK;AACpB,IAAA,mBAAmB,EAAE,wBAAwB;AAC7C,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;QAChC,MAAM,UAAU,GAAG,aAAa,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;;QAGhD,IAAI,OAAO,CAAC,KAAK,CAAC,IAAI,UAAU,KAAK,SAAS,EAAE;AAC9C,YAAA,OAAO,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACnC,SAAA;AAED,QAAA,OAAO,UAAU,CAAC;KACnB;EACD;AAEF;;;AAGG;AACU,MAAA,mBAAmB,GAG3B;AACH,IAAA,IAAI,EAAE,iBAAiB;AACvB,IAAA,WAAW,EAAE,2DAA2D;IACxE,SAAS,EAAE,CAAC,CAAC;AACb,IAAA,aAAa,EAAE,KAAK;AACpB,IAAA,mBAAmB,EAAE,wBAAwB;AAC7C,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;AAChC,QAAA,MAAM,EAAE,MAAM,EAAE,KAAK,GAAG,QAAQ,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC;AAC1D,QAAA,MAAM,MAAM,GAAG,KAAK,KAAK,SAAS,GAAG,OAAO,CAAC,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;;AAGxE,QAAA,MAAM,UAAU,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,IAAI,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,SAAS,CAAC,CAAC;;AAG3E,QAAA,IAAI,OAAO,CAAC,KAAK,CAAC,IAAI,UAAU,EAAE;AAChC,YAAA,OAAO,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACnC,SAAA;AAED,QAAA,OAAO,UAAU,CAAC;KACnB;EACD;AAEF;;;AAGG;AACU,MAAA,mBAAmB,GAG3B;AACH,IAAA,IAAI,EAAE,iBAAiB;AACvB,IAAA,WAAW,EACT,iEAAiE;IACnE,SAAS,EAAE,CAAC,CAAC;AACb,IAAA,aAAa,EAAE,KAAK;AACpB,IAAA,mBAAmB,EAAE,wBAAwB;AAC7C,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;AAChC,QAAA,MAAM,EAAE,MAAM,EAAE,KAAK,GAAG,QAAQ,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC;AAC1D,QAAA,MAAM,MAAM,GAAG,KAAK,KAAK,SAAS,GAAG,OAAO,CAAC,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;;AAGxE,QAAA,MAAM,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,IAAI,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,SAAS,CAAC,CAAC;;AAG1E,QAAA,IAAI,OAAO,CAAC,KAAK,CAAC,IAAI,UAAU,EAAE;AAChC,YAAA,OAAO,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACnC,SAAA;AAED,QAAA,OAAO,UAAU,CAAC;KACnB;"}

package/esm/rules/conditional/required-without-rules.d.ts

@@ -0,0 +1,26 @@
+import type { SchemaRule } from "../../types";
+/**
+ * Required without rule - field is required if another field is missing
+ * Supports both global and sibling scope
+ */
+export declare const requiredWithoutRule: SchemaRule<{
+    field: string;
+    scope?: "global" | "sibling";
+}>;
+/**
+ * Required without all rule - field is required if all specified fields are missing
+ * Supports both global and sibling scope
+ */
+export declare const requiredWithoutAllRule: SchemaRule<{
+    fields: string[];
+    scope?: "global" | "sibling";
+}>;
+/**
+ * Required without any rule - field is required if any of the specified fields is missing
+ * Supports both global and sibling scope
+ */
+export declare const requiredWithoutAnyRule: SchemaRule<{
+    fields: string[];
+    scope?: "global" | "sibling";
+}>;
+//# sourceMappingURL=required-without-rules.d.ts.map

package/esm/rules/conditional/required-without-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"required-without-rules.d.ts","sourceRoot":"","sources":["../../../src/rules/conditional/required-without-rules.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,UAAU,CAAC;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;CAC9B,CAgBA,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAE,UAAU,CAAC;IAC9C,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;CAC9B,CAoBA,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAE,UAAU,CAAC;IAC9C,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;CAC9B,CAqBA,CAAC"}

package/esm/rules/conditional/required-without-rules.js

@@ -0,0 +1,63 @@
+import {get}from'@mongez/reinforcements';import {isEmpty}from'@mongez/supportive-is';import {getFieldValue}from'../../helpers/get-field-value.js';import {invalidRule,VALID_RULE}from'../../helpers/validation-helpers.js';/**
+ * Required without rule - field is required if another field is missing
+ * Supports both global and sibling scope
+ */
+const requiredWithoutRule = {
+    name: "requiredWithout",
+    description: "The field is required if another field is missing",
+    sortOrder: -2,
+    requiresValue: false,
+    defaultErrorMessage: "The :input is required",
+    async validate(value, context) {
+        const fieldValue = getFieldValue(this, context);
+        // Field is required if the other field is missing
+        if (isEmpty(value) && fieldValue === undefined) {
+            return invalidRule(this, context);
+        }
+        return VALID_RULE;
+    },
+};
+/**
+ * Required without all rule - field is required if all specified fields are missing
+ * Supports both global and sibling scope
+ */
+const requiredWithoutAllRule = {
+    name: "requiredWithoutAll",
+    description: "The field is required if all specified fields are missing",
+    sortOrder: -2,
+    requiresValue: false,
+    defaultErrorMessage: "The :input is required",
+    async validate(value, context) {
+        const { fields, scope = "global" } = this.context.options;
+        const source = scope === "sibling" ? context.parent : context.allValues;
+        // Check if all fields are missing
+        const allMissing = fields.every(field => get(source, field) === undefined);
+        // Field is required if all other fields are missing
+        if (isEmpty(value) && allMissing) {
+            return invalidRule(this, context);
+        }
+        return VALID_RULE;
+    },
+};
+/**
+ * Required without any rule - field is required if any of the specified fields is missing
+ * Supports both global and sibling scope
+ */
+const requiredWithoutAnyRule = {
+    name: "requiredWithoutAny",
+    description: "The field is required if any of the specified fields is missing",
+    sortOrder: -2,
+    requiresValue: false,
+    defaultErrorMessage: "The :input is required",
+    async validate(value, context) {
+        const { fields, scope = "global" } = this.context.options;
+        const source = scope === "sibling" ? context.parent : context.allValues;
+        // Check if any field is missing
+        const anyMissing = fields.some(field => get(source, field) === undefined);
+        // Field is required if any other field is missing
+        if (isEmpty(value) && anyMissing) {
+            return invalidRule(this, context);
+        }
+        return VALID_RULE;
+    },
+};export{requiredWithoutAllRule,requiredWithoutAnyRule,requiredWithoutRule};//# sourceMappingURL=required-without-rules.js.map

package/esm/rules/conditional/required-without-rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"required-without-rules.js","sources":["../../../src/rules/conditional/required-without-rules.ts"],"sourcesContent":[null],"names":[],"mappings":"2NAKA;;;AAGG;AACU,MAAA,mBAAmB,GAG3B;AACH,IAAA,IAAI,EAAE,iBAAiB;AACvB,IAAA,WAAW,EAAE,mDAAmD;IAChE,SAAS,EAAE,CAAC,CAAC;AACb,IAAA,aAAa,EAAE,KAAK;AACpB,IAAA,mBAAmB,EAAE,wBAAwB;AAC7C,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;QAChC,MAAM,UAAU,GAAG,aAAa,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;;QAGhD,IAAI,OAAO,CAAC,KAAK,CAAC,IAAI,UAAU,KAAK,SAAS,EAAE;AAC9C,YAAA,OAAO,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACnC,SAAA;AAED,QAAA,OAAO,UAAU,CAAC;KACnB;EACD;AAEF;;;AAGG;AACU,MAAA,sBAAsB,GAG9B;AACH,IAAA,IAAI,EAAE,oBAAoB;AAC1B,IAAA,WAAW,EAAE,2DAA2D;IACxE,SAAS,EAAE,CAAC,CAAC;AACb,IAAA,aAAa,EAAE,KAAK;AACpB,IAAA,mBAAmB,EAAE,wBAAwB;AAC7C,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;AAChC,QAAA,MAAM,EAAE,MAAM,EAAE,KAAK,GAAG,QAAQ,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC;AAC1D,QAAA,MAAM,MAAM,GAAG,KAAK,KAAK,SAAS,GAAG,OAAO,CAAC,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;;AAGxE,QAAA,MAAM,UAAU,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,IAAI,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,SAAS,CAAC,CAAC;;AAG3E,QAAA,IAAI,OAAO,CAAC,KAAK,CAAC,IAAI,UAAU,EAAE;AAChC,YAAA,OAAO,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACnC,SAAA;AAED,QAAA,OAAO,UAAU,CAAC;KACnB;EACD;AAEF;;;AAGG;AACU,MAAA,sBAAsB,GAG9B;AACH,IAAA,IAAI,EAAE,oBAAoB;AAC1B,IAAA,WAAW,EACT,iEAAiE;IACnE,SAAS,EAAE,CAAC,CAAC;AACb,IAAA,aAAa,EAAE,KAAK;AACpB,IAAA,mBAAmB,EAAE,wBAAwB;AAC7C,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;AAChC,QAAA,MAAM,EAAE,MAAM,EAAE,KAAK,GAAG,QAAQ,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC;AAC1D,QAAA,MAAM,MAAM,GAAG,KAAK,KAAK,SAAS,GAAG,OAAO,CAAC,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;;AAGxE,QAAA,MAAM,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,IAAI,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,SAAS,CAAC,CAAC;;AAG1E,QAAA,IAAI,OAAO,CAAC,KAAK,CAAC,IAAI,UAAU,EAAE;AAChC,YAAA,OAAO,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACnC,SAAA;AAED,QAAA,OAAO,UAAU,CAAC;KACnB;"}

package/esm/rules/core/equal.d.ts

@@ -0,0 +1,8 @@
+import type { SchemaRule } from "../../types";
+/**
+ * Equal rule - value must be equal to a specific value
+ */
+export declare const equalRule: SchemaRule<{
+    value: any;
+}>;
+//# sourceMappingURL=equal.d.ts.map

package/esm/rules/core/equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equal.d.ts","sourceRoot":"","sources":["../../../src/rules/core/equal.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,UAAU,CAAC;IAAE,KAAK,EAAE,GAAG,CAAA;CAAE,CAShD,CAAC"}

package/esm/rules/core/equal.js

@@ -0,0 +1,13 @@
+import'@mongez/reinforcements';import {invalidRule,VALID_RULE}from'../../helpers/validation-helpers.js';/**
+ * Equal rule - value must be equal to a specific value
+ */
+const equalRule = {
+    name: "equal",
+    defaultErrorMessage: "The :input must be equal to :value",
+    async validate(value, context) {
+        if (value !== this.context.options.value) {
+            return invalidRule(this, context);
+        }
+        return VALID_RULE;
+    },
+};export{equalRule};//# sourceMappingURL=equal.js.map

package/esm/rules/core/equal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"equal.js","sources":["../../../src/rules/core/equal.ts"],"sourcesContent":[null],"names":[],"mappings":"wGAGA;;AAEG;AACU,MAAA,SAAS,GAA+B;AACnD,IAAA,IAAI,EAAE,OAAO;AACb,IAAA,mBAAmB,EAAE,oCAAoC;AACzD,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;QAChC,IAAI,KAAK,KAAK,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE;AACxC,YAAA,OAAO,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACnC,SAAA;AACD,QAAA,OAAO,UAAU,CAAC;KACnB;"}

package/esm/rules/core/forbidden.d.ts

@@ -0,0 +1,6 @@
+import type { SchemaRule } from "../../types";
+/**
+ * Forbidden rule - value must not be present
+ */
+export declare const forbiddenRule: SchemaRule;
+//# sourceMappingURL=forbidden.d.ts.map

package/esm/rules/core/forbidden.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forbidden.d.ts","sourceRoot":"","sources":["../../../src/rules/core/forbidden.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,UAS3B,CAAC"}

package/esm/rules/core/forbidden.js

@@ -0,0 +1,13 @@
+import {isEmpty}from'@mongez/supportive-is';import'@mongez/reinforcements';import {invalidRule,VALID_RULE}from'../../helpers/validation-helpers.js';/**
+ * Forbidden rule - value must not be present
+ */
+const forbiddenRule = {
+    name: "forbidden",
+    defaultErrorMessage: "The :input is forbidden",
+    async validate(value, context) {
+        if (!isEmpty(value)) {
+            return invalidRule(this, context);
+        }
+        return VALID_RULE;
+    },
+};export{forbiddenRule};//# sourceMappingURL=forbidden.js.map

package/esm/rules/core/forbidden.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"forbidden.js","sources":["../../../src/rules/core/forbidden.ts"],"sourcesContent":[null],"names":[],"mappings":"oJAIA;;AAEG;AACU,MAAA,aAAa,GAAe;AACvC,IAAA,IAAI,EAAE,WAAW;AACjB,IAAA,mBAAmB,EAAE,yBAAyB;AAC9C,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;AAChC,QAAA,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;AACnB,YAAA,OAAO,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACnC,SAAA;AACD,QAAA,OAAO,UAAU,CAAC;KACnB;"}

package/esm/rules/core/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./equal";
+export * from "./forbidden";
+export * from "./required";
+export * from "./when";
+//# sourceMappingURL=index.d.ts.map

package/esm/rules/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/rules/core/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,QAAQ,CAAC"}

package/esm/rules/core/required.d.ts

@@ -0,0 +1,11 @@
+import type { SchemaRule } from "../../types";
+/**
+ * Required rule - value must be present and not empty
+ */
+export declare const requiredRule: SchemaRule;
+/**
+ * Present rule - key must exist in the data, but value can be anything
+ * (empty string, null, undefined are all valid as long as the key exists)
+ */
+export declare const presentRule: SchemaRule;
+//# sourceMappingURL=required.d.ts.map

package/esm/rules/core/required.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"required.d.ts","sourceRoot":"","sources":["../../../src/rules/core/required.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,UAW1B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE,UAYzB,CAAC"}

package/esm/rules/core/required.js

@@ -0,0 +1,31 @@
+import {isEmpty}from'@mongez/supportive-is';import'@mongez/reinforcements';import {invalidRule,VALID_RULE}from'../../helpers/validation-helpers.js';/**
+ * Required rule - value must be present and not empty
+ */
+const requiredRule = {
+    name: "required",
+    defaultErrorMessage: "The :input is required",
+    requiresValue: false,
+    sortOrder: -2,
+    async validate(value, context) {
+        if (isEmpty(value)) {
+            return invalidRule(this, context);
+        }
+        return VALID_RULE;
+    },
+};
+/**
+ * Present rule - key must exist in the data, but value can be anything
+ * (empty string, null, undefined are all valid as long as the key exists)
+ */
+const presentRule = {
+    name: "present",
+    defaultErrorMessage: "The :input field is required",
+    requiresValue: false,
+    sortOrder: -2,
+    async validate(value, context) {
+        if (value === undefined) {
+            return invalidRule(this, context);
+        }
+        return VALID_RULE;
+    },
+};export{presentRule,requiredRule};//# sourceMappingURL=required.js.map

package/esm/rules/core/required.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"required.js","sources":["../../../src/rules/core/required.ts"],"sourcesContent":[null],"names":[],"mappings":"oJAIA;;AAEG;AACU,MAAA,YAAY,GAAe;AACtC,IAAA,IAAI,EAAE,UAAU;AAChB,IAAA,mBAAmB,EAAE,wBAAwB;AAC7C,IAAA,aAAa,EAAE,KAAK;IACpB,SAAS,EAAE,CAAC,CAAC;AACb,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;AAChC,QAAA,IAAI,OAAO,CAAC,KAAK,CAAC,EAAE;AAClB,YAAA,OAAO,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACnC,SAAA;AACD,QAAA,OAAO,UAAU,CAAC;KACnB;EACD;AAEF;;;AAGG;AACU,MAAA,WAAW,GAAe;AACrC,IAAA,IAAI,EAAE,SAAS;AACf,IAAA,mBAAmB,EAAE,8BAA8B;AACnD,IAAA,aAAa,EAAE,KAAK;IACpB,SAAS,EAAE,CAAC,CAAC;AACb,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;QAChC,IAAI,KAAK,KAAK,SAAS,EAAE;AACvB,YAAA,OAAO,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACnC,SAAA;AAED,QAAA,OAAO,UAAU,CAAC;KACnB;"}

package/esm/rules/core/when.d.ts

@@ -0,0 +1,6 @@
+import type { SchemaRule, WhenRuleOptions } from "../../types";
+/**
+ * When rule - conditional validation based on another field value
+ */
+export declare const whenRule: SchemaRule<WhenRuleOptions>;
+//# sourceMappingURL=when.d.ts.map

package/esm/rules/core/when.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"when.d.ts","sourceRoot":"","sources":["../../../src/rules/core/when.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE/D;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,UAAU,CAAC,eAAe,CA6ChD,CAAC"}

package/esm/rules/core/when.js

@@ -0,0 +1,40 @@
+import {get}from'@mongez/reinforcements';import {VALID_RULE,invalidRule}from'../../helpers/validation-helpers.js';/**
+ * When rule - conditional validation based on another field value
+ */
+const whenRule = {
+    name: "when",
+    description: "Apply conditional validation based on another field value",
+    async validate(value, context) {
+        const fieldToCheck = this.context.options.field;
+        const conditions = this.context.options.is;
+        const otherwise = this.context.options.otherwise;
+        const scope = this.context.options.scope || "global";
+        const fieldValue = scope === "global"
+            ? get(context.allValues, fieldToCheck)
+            : get(context.parent, fieldToCheck);
+        // Convert field value to string for key lookup
+        // This handles boolean, number, and string field values
+        const fieldValueKey = String(fieldValue);
+        if (conditions[fieldValueKey]) {
+            const result = await conditions[fieldValueKey].validate(value, context);
+            if (result.isValid) {
+                return VALID_RULE;
+            }
+            // Safe error access
+            this.context.errorMessage =
+                result.errors?.[0]?.error || "Validation failed";
+            return invalidRule(this, context);
+        }
+        if (otherwise) {
+            const result = await otherwise.validate(value, context);
+            if (result.isValid) {
+                return VALID_RULE;
+            }
+            // Safe error access
+            this.context.errorMessage =
+                result.errors?.[0]?.error || "Validation failed";
+            return invalidRule(this, context);
+        }
+        return VALID_RULE;
+    },
+};export{whenRule};//# sourceMappingURL=when.js.map

package/esm/rules/core/when.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"when.js","sources":["../../../src/rules/core/when.ts"],"sourcesContent":[null],"names":[],"mappings":"kHAIA;;AAEG;AACU,MAAA,QAAQ,GAAgC;AACnD,IAAA,IAAI,EAAE,MAAM;AACZ,IAAA,WAAW,EAAE,2DAA2D;AACxE,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;QAChC,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC;QAChD,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QAC3C,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC;QACjD,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,IAAI,QAAQ,CAAC;AAErD,QAAA,MAAM,UAAU,GACd,KAAK,KAAK,QAAQ;cACd,GAAG,CAAC,OAAO,CAAC,SAAS,EAAE,YAAY,CAAC;cACpC,GAAG,CAAC,OAAO,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;;;AAIxC,QAAA,MAAM,aAAa,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;AAEzC,QAAA,IAAI,UAAU,CAAC,aAAa,CAAC,EAAE;AAC7B,YAAA,MAAM,MAAM,GAAG,MAAM,UAAU,CAAC,aAAa,CAAC,CAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;YACxE,IAAI,MAAM,CAAC,OAAO,EAAE;AAClB,gBAAA,OAAO,UAAU,CAAC;AACnB,aAAA;;YAGD,IAAI,CAAC,OAAO,CAAC,YAAY;gBACvB,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE,KAAK,IAAI,mBAAmB,CAAC;AACnD,YAAA,OAAO,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACnC,SAAA;AAED,QAAA,IAAI,SAAS,EAAE;YACb,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;YAExD,IAAI,MAAM,CAAC,OAAO,EAAE;AAClB,gBAAA,OAAO,UAAU,CAAC;AACnB,aAAA;;YAGD,IAAI,CAAC,OAAO,CAAC,YAAY;gBACvB,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE,KAAK,IAAI,mBAAmB,CAAC;AACnD,YAAA,OAAO,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACnC,SAAA;AAED,QAAA,OAAO,UAAU,CAAC;KACnB;"}

package/esm/rules/date/date-comparison-rules.d.ts

@@ -0,0 +1,25 @@
+import type { SchemaRule } from "../../types";
+/**
+ * Between dates rule - date must be between start and end dates
+ */
+export declare const betweenDatesRule: SchemaRule<{
+    startDate: Date;
+    endDate: Date;
+}>;
+/**
+ * Today rule - date must be exactly today
+ */
+export declare const todayRule: SchemaRule;
+/**
+ * Past rule - date must be in the past
+ */
+export declare const pastRule: SchemaRule;
+/**
+ * Future rule - date must be in the future
+ */
+export declare const futureRule: SchemaRule;
+/**
+ * After today rule - date must be after today (not including today)
+ */
+export declare const afterTodayRule: SchemaRule;
+//# sourceMappingURL=date-comparison-rules.d.ts.map

package/esm/rules/date/date-comparison-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-comparison-rules.d.ts","sourceRoot":"","sources":["../../../src/rules/date/date-comparison-rules.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,UAAU,CAAC;IACxC,SAAS,EAAE,IAAI,CAAC;IAChB,OAAO,EAAE,IAAI,CAAC;CACf,CAYA,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,UAcvB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,UAYtB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,UAYxB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,UAc5B,CAAC"}

package/esm/rules/date/date-comparison-rules.js

@@ -0,0 +1,78 @@
+import'@mongez/reinforcements';import {VALID_RULE,invalidRule}from'../../helpers/validation-helpers.js';/**
+ * Between dates rule - date must be between start and end dates
+ */
+const betweenDatesRule = {
+    name: "betweenDates",
+    defaultErrorMessage: "The :input must be between :startDate and :endDate",
+    async validate(value, context) {
+        const { startDate, endDate } = this.context.options;
+        const inputDate = new Date(value);
+        if (inputDate >= startDate && inputDate <= endDate) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+/**
+ * Today rule - date must be exactly today
+ */
+const todayRule = {
+    name: "today",
+    defaultErrorMessage: "The :input must be today",
+    async validate(value, context) {
+        const today = new Date();
+        today.setHours(0, 0, 0, 0);
+        const inputDate = new Date(value);
+        inputDate.setHours(0, 0, 0, 0);
+        if (inputDate.getTime() === today.getTime()) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+/**
+ * Past rule - date must be in the past
+ */
+const pastRule = {
+    name: "past",
+    defaultErrorMessage: "The :input must be in the past",
+    async validate(value, context) {
+        const now = new Date();
+        const inputDate = new Date(value);
+        if (inputDate < now) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+/**
+ * Future rule - date must be in the future
+ */
+const futureRule = {
+    name: "future",
+    defaultErrorMessage: "The :input must be in the future",
+    async validate(value, context) {
+        const now = new Date();
+        if (value > now) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+/**
+ * After today rule - date must be after today (not including today)
+ */
+const afterTodayRule = {
+    name: "afterToday",
+    defaultErrorMessage: "The :input must be after today",
+    async validate(value, context) {
+        const today = new Date();
+        today.setHours(0, 0, 0, 0);
+        const inputDate = new Date(value);
+        inputDate.setHours(0, 0, 0, 0);
+        if (inputDate > today) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};export{afterTodayRule,betweenDatesRule,futureRule,pastRule,todayRule};//# sourceMappingURL=date-comparison-rules.js.map

package/esm/rules/date/date-comparison-rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-comparison-rules.js","sources":["../../../src/rules/date/date-comparison-rules.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/esm/rules/date/date-day-rules.d.ts

@@ -0,0 +1,21 @@
+import type { SchemaRule } from "../../types";
+import type { WeekDay } from "../../types/date-types";
+/**
+ * Weekend rule - date must be Saturday or Sunday
+ */
+export declare const weekendRule: SchemaRule;
+/**
+ * Weekday rule - date must be Monday through Friday
+ */
+export declare const weekdayRule: SchemaRule;
+/**
+ * Weekdays rule - date must be one of specified weekdays
+ */
+export declare const weekdaysRule: SchemaRule<{
+    days: WeekDay[];
+}>;
+/**
+ * Business day rule - date must be Monday-Friday (no weekends)
+ */
+export declare const businessDayRule: SchemaRule;
+//# sourceMappingURL=date-day-rules.d.ts.map

package/esm/rules/date/date-day-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-day-rules.d.ts","sourceRoot":"","sources":["../../../src/rules/date/date-day-rules.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAGtD;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,UAazB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,UAazB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,UAAU,CAAC;IAAE,IAAI,EAAE,OAAO,EAAE,CAAA;CAAE,CAexD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,UAa7B,CAAC"}

package/esm/rules/date/date-day-rules.js

@@ -0,0 +1,65 @@
+import'@mongez/reinforcements';import {VALID_RULE,invalidRule}from'../../helpers/validation-helpers.js';import {WEEK_DAYS}from'../../types/date-types.js';/**
+ * Weekend rule - date must be Saturday or Sunday
+ */
+const weekendRule = {
+    name: "weekend",
+    defaultErrorMessage: "The :input must be a weekend (Saturday or Sunday)",
+    async validate(value, context) {
+        const inputDate = new Date(value);
+        const dayOfWeek = inputDate.getDay();
+        // 0 = Sunday, 6 = Saturday
+        if (dayOfWeek === 0 || dayOfWeek === 6) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+/**
+ * Weekday rule - date must be Monday through Friday
+ */
+const weekdayRule = {
+    name: "weekday",
+    defaultErrorMessage: "The :input must be a weekday (Monday-Friday)",
+    async validate(value, context) {
+        const inputDate = new Date(value);
+        const dayOfWeek = inputDate.getDay();
+        // 1-5 = Monday-Friday
+        if (dayOfWeek >= 1 && dayOfWeek <= 5) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+/**
+ * Weekdays rule - date must be one of specified weekdays
+ */
+const weekdaysRule = {
+    name: "weekdays",
+    defaultErrorMessage: "The :input must be one of: :days",
+    async validate(value, context) {
+        const inputDate = new Date(value);
+        const dayOfWeek = inputDate.getDay();
+        const { days } = this.context.options;
+        const allowedDays = days.map(day => WEEK_DAYS[day]);
+        if (allowedDays.includes(dayOfWeek)) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+/**
+ * Business day rule - date must be Monday-Friday (no weekends)
+ */
+const businessDayRule = {
+    name: "businessDay",
+    defaultErrorMessage: "The :input must be a business day",
+    async validate(value, context) {
+        const inputDate = new Date(value);
+        const dayOfWeek = inputDate.getDay();
+        // 1-5 = Monday-Friday
+        if (dayOfWeek >= 1 && dayOfWeek <= 5) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};export{businessDayRule,weekdayRule,weekdaysRule,weekendRule};//# sourceMappingURL=date-day-rules.js.map

package/esm/rules/date/date-day-rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-day-rules.js","sources":["../../../src/rules/date/date-day-rules.ts"],"sourcesContent":[null],"names":[],"mappings":"0JAKA;;AAEG;AACU,MAAA,WAAW,GAAe;AACrC,IAAA,IAAI,EAAE,SAAS;AACf,IAAA,mBAAmB,EAAE,mDAAmD;AACxE,IAAA,MAAM,QAAQ,CAAC,KAAW,EAAE,OAAO,EAAA;AACjC,QAAA,MAAM,SAAS,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC;AAClC,QAAA,MAAM,SAAS,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC;;AAGrC,QAAA,IAAI,SAAS,KAAK,CAAC,IAAI,SAAS,KAAK,CAAC,EAAE;AACtC,YAAA,OAAO,UAAU,CAAC;AACnB,SAAA;AACD,QAAA,OAAO,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;KACnC;EACD;AAEF;;AAEG;AACU,MAAA,WAAW,GAAe;AACrC,IAAA,IAAI,EAAE,SAAS;AACf,IAAA,mBAAmB,EAAE,8CAA8C;AACnE,IAAA,MAAM,QAAQ,CAAC,KAAW,EAAE,OAAO,EAAA;AACjC,QAAA,MAAM,SAAS,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC;AAClC,QAAA,MAAM,SAAS,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC;;AAGrC,QAAA,IAAI,SAAS,IAAI,CAAC,IAAI,SAAS,IAAI,CAAC,EAAE;AACpC,YAAA,OAAO,UAAU,CAAC;AACnB,SAAA;AACD,QAAA,OAAO,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;KACnC;EACD;AAEF;;AAEG;AACU,MAAA,YAAY,GAAoC;AAC3D,IAAA,IAAI,EAAE,UAAU;AAChB,IAAA,mBAAmB,EAAE,kCAAkC;AACvD,IAAA,MAAM,QAAQ,CAAC,KAAW,EAAE,OAAO,EAAA;AACjC,QAAA,MAAM,SAAS,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC;AAClC,QAAA,MAAM,SAAS,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC;QACrC,MAAM,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC;AAEtC,QAAA,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC;AAEpD,QAAA,IAAI,WAAW,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE;AACnC,YAAA,OAAO,UAAU,CAAC;AACnB,SAAA;AACD,QAAA,OAAO,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;KACnC;EACD;AAEF;;AAEG;AACU,MAAA,eAAe,GAAe;AACzC,IAAA,IAAI,EAAE,aAAa;AACnB,IAAA,mBAAmB,EAAE,mCAAmC;AACxD,IAAA,MAAM,QAAQ,CAAC,KAAW,EAAE,OAAO,EAAA;AACjC,QAAA,MAAM,SAAS,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC;AAClC,QAAA,MAAM,SAAS,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC;;AAGrC,QAAA,IAAI,SAAS,IAAI,CAAC,IAAI,SAAS,IAAI,CAAC,EAAE;AACpC,YAAA,OAAO,UAAU,CAAC;AACnB,SAAA;AACD,QAAA,OAAO,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;KACnC;"}

package/esm/rules/date/date-field-comparison-rules.d.ts

@@ -0,0 +1,28 @@
+import type { SchemaRule } from "../../types";
+/**
+ * Before field rule - date must be < given date or field
+ * Smart detection: date value or field name
+ * Supports both global and sibling scope
+ */
+export declare const beforeFieldRule: SchemaRule<{
+    dateOrField: Date | string | number;
+    scope?: "global" | "sibling";
+}>;
+/**
+ * After field rule - date must be > given date or field
+ * Smart detection: date value or field name
+ * Supports both global and sibling scope
+ */
+export declare const afterFieldRule: SchemaRule<{
+    dateOrField: Date | string | number;
+    scope?: "global" | "sibling";
+}>;
+/**
+ * Same as field rule - date must be the same as another field's date
+ * Supports both global and sibling scope
+ */
+export declare const sameAsFieldDateRule: SchemaRule<{
+    field: string;
+    scope?: "global" | "sibling";
+}>;
+//# sourceMappingURL=date-field-comparison-rules.d.ts.map

package/esm/rules/date/date-field-comparison-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-field-comparison-rules.d.ts","sourceRoot":"","sources":["../../../src/rules/date/date-field-comparison-rules.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,UAAU,CAAC;IACvC,WAAW,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,CAAC;IACpC,KAAK,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;CAC9B,CA8BA,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,UAAU,CAAC;IACtC,WAAW,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,CAAC;IACpC,KAAK,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;CAC9B,CA8BA,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,UAAU,CAAC;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;CAC9B,CAwBA,CAAC"}