@warlock.js/seal 4.0.48 → 4.0.59

package/cjs/rules/conditional/present-if-rules.js

@@ -0,0 +1,98 @@
+'use strict';var getFieldValue=require('../../helpers/get-field-value.js'),validationHelpers=require('../../helpers/validation-helpers.js'),isEmptyValue=require('../../helpers/is-empty-value.js');/**
+ * Present if rule - field must be present if another field equals a specific value
+ * Supports both global and sibling scope
+ */
+const presentIfRule = {
+    name: "presentIf",
+    description: "The field must be present if another field equals a specific value",
+    sortOrder: -2,
+    requiresValue: false,
+    defaultErrorMessage: "The :input field must be present",
+    async validate(value, context) {
+        const { value: expectedValue } = this.context.options;
+        const fieldValue = getFieldValue.getFieldValue(this, context);
+        // Field must be present if the other field equals the expected value
+        if (value === undefined && fieldValue === expectedValue) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        return validationHelpers.VALID_RULE;
+    },
+};
+/**
+ * Present if empty rule - field must be present if another field is empty
+ * Supports both global and sibling scope
+ */
+const presentIfEmptyRule = {
+    name: "presentIfEmpty",
+    description: "The field must be present if another field is empty",
+    sortOrder: -2,
+    requiresValue: false,
+    defaultErrorMessage: "The :input field must be present",
+    async validate(value, context) {
+        const fieldValue = getFieldValue.getFieldValue(this, context);
+        // Field must be present if the other field is empty
+        if (value === undefined && isEmptyValue.isEmptyValue(fieldValue)) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        return validationHelpers.VALID_RULE;
+    },
+};
+/**
+ * Present if not empty rule - field must be present if another field is not empty
+ * Supports both global and sibling scope
+ */
+const presentIfNotEmptyRule = {
+    name: "presentIfNotEmpty",
+    description: "The field must be present if another field is not empty",
+    sortOrder: -2,
+    requiresValue: false,
+    defaultErrorMessage: "The :input field must be present",
+    async validate(value, context) {
+        const fieldValue = getFieldValue.getFieldValue(this, context);
+        // Field must be present if the other field is not empty
+        if (value === undefined && !isEmptyValue.isEmptyValue(fieldValue)) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        return validationHelpers.VALID_RULE;
+    },
+};
+/**
+ * Present if in rule - field must be present if another field's value is in the given array
+ * Supports both global and sibling scope
+ */
+const presentIfInRule = {
+    name: "presentIfIn",
+    description: "The field must be present if another field's value is in the given array",
+    sortOrder: -2,
+    requiresValue: false,
+    defaultErrorMessage: "The :input field must be present",
+    async validate(value, context) {
+        const { values } = this.context.options;
+        const fieldValue = getFieldValue.getFieldValue(this, context);
+        // Field must be present if the other field's value is in the array
+        if (value === undefined && values.includes(fieldValue)) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        return validationHelpers.VALID_RULE;
+    },
+};
+/**
+ * Present if not in rule - field must be present if another field's value is NOT in the given array
+ * Supports both global and sibling scope
+ */
+const presentIfNotInRule = {
+    name: "presentIfNotIn",
+    description: "The field must be present if another field's value is NOT in the given array",
+    sortOrder: -2,
+    requiresValue: false,
+    defaultErrorMessage: "The :input field must be present",
+    async validate(value, context) {
+        const { values } = this.context.options;
+        const fieldValue = getFieldValue.getFieldValue(this, context);
+        // Field must be present if the other field's value is NOT in the array
+        if (value === undefined && !values.includes(fieldValue)) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        return validationHelpers.VALID_RULE;
+    },
+};exports.presentIfEmptyRule=presentIfEmptyRule;exports.presentIfInRule=presentIfInRule;exports.presentIfNotEmptyRule=presentIfNotEmptyRule;exports.presentIfNotInRule=presentIfNotInRule;exports.presentIfRule=presentIfRule;//# sourceMappingURL=present-if-rules.js.map

package/cjs/rules/conditional/present-if-rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"present-if-rules.js","sources":["../../../src/rules/conditional/present-if-rules.ts"],"sourcesContent":[null],"names":["getFieldValue","invalidRule","VALID_RULE","isEmptyValue"],"mappings":"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"}

package/cjs/rules/conditional/present-unless-rules.d.ts

@@ -0,0 +1,11 @@
+import type { SchemaRule } from "../../types";
+/**
+ * Present unless rule - field must be present unless another field equals a specific value
+ * Supports both global and sibling scope
+ */
+export declare const presentUnlessRule: SchemaRule<{
+    field: string;
+    value: any;
+    scope?: "global" | "sibling";
+}>;
+//# sourceMappingURL=present-unless-rules.d.ts.map

package/cjs/rules/conditional/present-unless-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"present-unless-rules.d.ts","sourceRoot":"","sources":["../../../src/rules/conditional/present-unless-rules.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;GAGG;AACH,eAAO,MAAM,iBAAiB,EAAE,UAAU,CAAC;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,GAAG,CAAC;IACX,KAAK,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;CAC9B,CAkBA,CAAC"}

package/cjs/rules/conditional/present-unless-rules.js

@@ -0,0 +1,20 @@
+'use strict';var getFieldValue=require('../../helpers/get-field-value.js'),validationHelpers=require('../../helpers/validation-helpers.js');/**
+ * Present unless rule - field must be present unless another field equals a specific value
+ * Supports both global and sibling scope
+ */
+const presentUnlessRule = {
+    name: "presentUnless",
+    description: "The field must be present unless another field equals a specific value",
+    sortOrder: -2,
+    requiresValue: false,
+    defaultErrorMessage: "The :input field must be present",
+    async validate(value, context) {
+        const { value: expectedValue } = this.context.options;
+        const fieldValue = getFieldValue.getFieldValue(this, context);
+        // Field must be present unless the other field equals the expected value
+        if (value === undefined && fieldValue !== expectedValue) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        return validationHelpers.VALID_RULE;
+    },
+};exports.presentUnlessRule=presentUnlessRule;//# sourceMappingURL=present-unless-rules.js.map

package/cjs/rules/conditional/present-unless-rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"present-unless-rules.js","sources":["../../../src/rules/conditional/present-unless-rules.ts"],"sourcesContent":[null],"names":["getFieldValue","invalidRule","VALID_RULE"],"mappings":"4IAGA;;;AAGG;AACU,MAAA,iBAAiB,GAIzB;AACH,IAAA,IAAI,EAAE,eAAe;AACrB,IAAA,WAAW,EACT,wEAAwE;IAC1E,SAAS,EAAE,CAAC,CAAC;AACb,IAAA,aAAa,EAAE,KAAK;AACpB,IAAA,mBAAmB,EAAE,kCAAkC;AACvD,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;QAChC,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC;QACtD,MAAM,UAAU,GAAGA,2BAAa,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;;AAGhD,QAAA,IAAI,KAAK,KAAK,SAAS,IAAI,UAAU,KAAK,aAAa,EAAE;AACvD,YAAA,OAAOC,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACnC,SAAA;AAED,QAAA,OAAOC,4BAAU,CAAC;KACnB;"}

package/cjs/rules/conditional/present-with-rules.d.ts

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

package/cjs/rules/conditional/present-with-rules.d.ts.map

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

package/cjs/rules/conditional/present-with-rules.js

@@ -0,0 +1,63 @@
+'use strict';var reinforcements=require('@mongez/reinforcements'),getFieldValue=require('../../helpers/get-field-value.js'),validationHelpers=require('../../helpers/validation-helpers.js');/**
+ * Present with rule - field must be present if another field is present
+ * Supports both global and sibling scope
+ */
+const presentWithRule = {
+    name: "presentWith",
+    description: "The field must be present if another field is present",
+    sortOrder: -2,
+    requiresValue: false,
+    defaultErrorMessage: "The :input field must be present",
+    async validate(value, context) {
+        const fieldValue = getFieldValue.getFieldValue(this, context);
+        // The field must be present if the other field is present
+        if (value === undefined && fieldValue !== undefined) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        return validationHelpers.VALID_RULE;
+    },
+};
+/**
+ * Present with all rule - field must be present if all specified fields are present
+ * Supports both global and sibling scope
+ */
+const presentWithAllRule = {
+    name: "presentWithAll",
+    description: "The field must be present if all specified fields are present",
+    sortOrder: -2,
+    requiresValue: false,
+    defaultErrorMessage: "The :input field must be present",
+    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 => reinforcements.get(source, field) !== undefined);
+        // Field must be present if all other fields are present
+        if (value === undefined && allPresent) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        return validationHelpers.VALID_RULE;
+    },
+};
+/**
+ * Present with any rule - field must be present if any of the specified fields is present
+ * Supports both global and sibling scope
+ */
+const presentWithAnyRule = {
+    name: "presentWithAny",
+    description: "The field must be present if any of the specified fields is present",
+    sortOrder: -2,
+    requiresValue: false,
+    defaultErrorMessage: "The :input field must be present",
+    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 => reinforcements.get(source, field) !== undefined);
+        // Field must be present if any other field is present
+        if (value === undefined && anyPresent) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        return validationHelpers.VALID_RULE;
+    },
+};exports.presentWithAllRule=presentWithAllRule;exports.presentWithAnyRule=presentWithAnyRule;exports.presentWithRule=presentWithRule;//# sourceMappingURL=present-with-rules.js.map

package/cjs/rules/conditional/present-with-rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"present-with-rules.js","sources":["../../../src/rules/conditional/present-with-rules.ts"],"sourcesContent":[null],"names":["getFieldValue","invalidRule","VALID_RULE","get"],"mappings":"6LAIA;;;AAGG;AACU,MAAA,eAAe,GAGvB;AACH,IAAA,IAAI,EAAE,aAAa;AACnB,IAAA,WAAW,EAAE,uDAAuD;IACpE,SAAS,EAAE,CAAC,CAAC;AACb,IAAA,aAAa,EAAE,KAAK;AACpB,IAAA,mBAAmB,EAAE,kCAAkC;AACvD,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;QAChC,MAAM,UAAU,GAAGA,2BAAa,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;;AAGhD,QAAA,IAAI,KAAK,KAAK,SAAS,IAAI,UAAU,KAAK,SAAS,EAAE;AACnD,YAAA,OAAOC,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACnC,SAAA;AAED,QAAA,OAAOC,4BAAU,CAAC;KACnB;EACD;AAEF;;;AAGG;AACU,MAAA,kBAAkB,GAG1B;AACH,IAAA,IAAI,EAAE,gBAAgB;AACtB,IAAA,WAAW,EAAE,+DAA+D;IAC5E,SAAS,EAAE,CAAC,CAAC;AACb,IAAA,aAAa,EAAE,KAAK;AACpB,IAAA,mBAAmB,EAAE,kCAAkC;AACvD,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,IAAIC,kBAAG,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,SAAS,CAAC,CAAC;;AAG3E,QAAA,IAAI,KAAK,KAAK,SAAS,IAAI,UAAU,EAAE;AACrC,YAAA,OAAOF,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACnC,SAAA;AAED,QAAA,OAAOC,4BAAU,CAAC;KACnB;EACD;AAEF;;;AAGG;AACU,MAAA,kBAAkB,GAG1B;AACH,IAAA,IAAI,EAAE,gBAAgB;AACtB,IAAA,WAAW,EACT,qEAAqE;IACvE,SAAS,EAAE,CAAC,CAAC;AACb,IAAA,aAAa,EAAE,KAAK;AACpB,IAAA,mBAAmB,EAAE,kCAAkC;AACvD,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,IAAIC,kBAAG,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,SAAS,CAAC,CAAC;;AAG1E,QAAA,IAAI,KAAK,KAAK,SAAS,IAAI,UAAU,EAAE;AACrC,YAAA,OAAOF,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACnC,SAAA;AAED,QAAA,OAAOC,4BAAU,CAAC;KACnB;"}

package/cjs/rules/conditional/present-without-rules.d.ts

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

package/cjs/rules/conditional/present-without-rules.d.ts.map

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

package/cjs/rules/conditional/present-without-rules.js

@@ -0,0 +1,63 @@
+'use strict';var reinforcements=require('@mongez/reinforcements'),getFieldValue=require('../../helpers/get-field-value.js'),validationHelpers=require('../../helpers/validation-helpers.js');/**
+ * Present without rule - field must be present if another field is missing
+ * Supports both global and sibling scope
+ */
+const presentWithoutRule = {
+    name: "presentWithout",
+    description: "The field must be present if another field is missing",
+    sortOrder: -2,
+    requiresValue: false,
+    defaultErrorMessage: "The :input field must be present",
+    async validate(value, context) {
+        const fieldValue = getFieldValue.getFieldValue(this, context);
+        // Field must be present if the other field is missing
+        if (value === undefined && fieldValue === undefined) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        return validationHelpers.VALID_RULE;
+    },
+};
+/**
+ * Present without all rule - field must be present if all specified fields are missing
+ * Supports both global and sibling scope
+ */
+const presentWithoutAllRule = {
+    name: "presentWithoutAll",
+    description: "The field must be present if all specified fields are missing",
+    sortOrder: -2,
+    requiresValue: false,
+    defaultErrorMessage: "The :input field must be present",
+    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 => reinforcements.get(source, field) === undefined);
+        // Field must be present if all other fields are missing
+        if (value === undefined && allMissing) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        return validationHelpers.VALID_RULE;
+    },
+};
+/**
+ * Present without any rule - field must be present if any of the specified fields is missing
+ * Supports both global and sibling scope
+ */
+const presentWithoutAnyRule = {
+    name: "presentWithoutAny",
+    description: "The field must be present if any of the specified fields is missing",
+    sortOrder: -2,
+    requiresValue: false,
+    defaultErrorMessage: "The :input field must be present",
+    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 => reinforcements.get(source, field) === undefined);
+        // Field must be present if any other field is missing
+        if (value === undefined && anyMissing) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        return validationHelpers.VALID_RULE;
+    },
+};exports.presentWithoutAllRule=presentWithoutAllRule;exports.presentWithoutAnyRule=presentWithoutAnyRule;exports.presentWithoutRule=presentWithoutRule;//# sourceMappingURL=present-without-rules.js.map

package/cjs/rules/conditional/present-without-rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"present-without-rules.js","sources":["../../../src/rules/conditional/present-without-rules.ts"],"sourcesContent":[null],"names":["getFieldValue","invalidRule","VALID_RULE","get"],"mappings":"6LAIA;;;AAGG;AACU,MAAA,kBAAkB,GAG1B;AACH,IAAA,IAAI,EAAE,gBAAgB;AACtB,IAAA,WAAW,EAAE,uDAAuD;IACpE,SAAS,EAAE,CAAC,CAAC;AACb,IAAA,aAAa,EAAE,KAAK;AACpB,IAAA,mBAAmB,EAAE,kCAAkC;AACvD,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;QAChC,MAAM,UAAU,GAAGA,2BAAa,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;;AAGhD,QAAA,IAAI,KAAK,KAAK,SAAS,IAAI,UAAU,KAAK,SAAS,EAAE;AACnD,YAAA,OAAOC,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACnC,SAAA;AAED,QAAA,OAAOC,4BAAU,CAAC;KACnB;EACD;AAEF;;;AAGG;AACU,MAAA,qBAAqB,GAG7B;AACH,IAAA,IAAI,EAAE,mBAAmB;AACzB,IAAA,WAAW,EAAE,+DAA+D;IAC5E,SAAS,EAAE,CAAC,CAAC;AACb,IAAA,aAAa,EAAE,KAAK;AACpB,IAAA,mBAAmB,EAAE,kCAAkC;AACvD,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,IAAIC,kBAAG,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,SAAS,CAAC,CAAC;;AAG3E,QAAA,IAAI,KAAK,KAAK,SAAS,IAAI,UAAU,EAAE;AACrC,YAAA,OAAOF,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACnC,SAAA;AAED,QAAA,OAAOC,4BAAU,CAAC;KACnB;EACD;AAEF;;;AAGG;AACU,MAAA,qBAAqB,GAG7B;AACH,IAAA,IAAI,EAAE,mBAAmB;AACzB,IAAA,WAAW,EACT,qEAAqE;IACvE,SAAS,EAAE,CAAC,CAAC;AACb,IAAA,aAAa,EAAE,KAAK;AACpB,IAAA,mBAAmB,EAAE,kCAAkC;AACvD,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,IAAIC,kBAAG,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,SAAS,CAAC,CAAC;;AAG1E,QAAA,IAAI,KAAK,KAAK,SAAS,IAAI,UAAU,EAAE;AACrC,YAAA,OAAOF,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACnC,SAAA;AAED,QAAA,OAAOC,4BAAU,CAAC;KACnB;"}

package/cjs/rules/conditional/required-if-rules.d.ts

@@ -0,0 +1,45 @@
+import type { SchemaRule } from "../../types";
+/**
+ * Required if rule - field is required if another field equals a specific value
+ * Supports both global and sibling scope
+ */
+export declare const requiredIfRule: SchemaRule<{
+    field: string;
+    value: any;
+    scope?: "global" | "sibling";
+}>;
+/**
+ * Required if empty rule - field is required if another field is empty
+ * Supports both global and sibling scope
+ */
+export declare const requiredIfEmptyRule: SchemaRule<{
+    field: string;
+    scope?: "global" | "sibling";
+}>;
+/**
+ * Required if not empty rule - field is required if another field is not empty
+ * Supports both global and sibling scope
+ */
+export declare const requiredIfNotEmptyRule: SchemaRule<{
+    field: string;
+    scope?: "global" | "sibling";
+}>;
+/**
+ * Required if in rule - field is required if another field's value is in the given array
+ * Supports both global and sibling scope
+ */
+export declare const requiredIfInRule: SchemaRule<{
+    field: string;
+    values: any[];
+    scope?: "global" | "sibling";
+}>;
+/**
+ * Required if not in rule - field is required if another field's value is NOT in the given array
+ * Supports both global and sibling scope
+ */
+export declare const requiredIfNotInRule: SchemaRule<{
+    field: string;
+    values: any[];
+    scope?: "global" | "sibling";
+}>;
+//# sourceMappingURL=required-if-rules.d.ts.map

package/cjs/rules/conditional/required-if-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"required-if-rules.d.ts","sourceRoot":"","sources":["../../../src/rules/conditional/required-if-rules.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,UAAU,CAAC;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,GAAG,CAAC;IACX,KAAK,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;CAC9B,CAiBA,CAAC;AAEF;;;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,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;CAC9B,CAgBA,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,UAAU,CAAC;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,GAAG,EAAE,CAAC;IACd,KAAK,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;CAC9B,CAiBA,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,UAAU,CAAC;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,GAAG,EAAE,CAAC;IACd,KAAK,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;CAC9B,CAiBA,CAAC"}

package/cjs/rules/conditional/required-if-rules.js

@@ -0,0 +1,98 @@
+'use strict';var getFieldValue=require('../../helpers/get-field-value.js'),validationHelpers=require('../../helpers/validation-helpers.js'),isEmptyValue=require('../../helpers/is-empty-value.js');/**
+ * Required if rule - field is required if another field equals a specific value
+ * Supports both global and sibling scope
+ */
+const requiredIfRule = {
+    name: "requiredIf",
+    description: "The field is required if another field equals a specific value",
+    sortOrder: -2,
+    requiresValue: false,
+    defaultErrorMessage: "The :input is required",
+    async validate(value, context) {
+        const { value: expectedValue } = this.context.options;
+        const fieldValue = getFieldValue.getFieldValue(this, context);
+        // Field is required if the other field equals the expected value
+        if (isEmptyValue.isEmptyValue(value) && fieldValue === expectedValue) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        return validationHelpers.VALID_RULE;
+    },
+};
+/**
+ * Required if empty rule - field is required if another field is empty
+ * Supports both global and sibling scope
+ */
+const requiredIfEmptyRule = {
+    name: "requiredIfEmpty",
+    description: "The field is required if another field is empty",
+    sortOrder: -2,
+    requiresValue: false,
+    defaultErrorMessage: "The :input is required",
+    async validate(value, context) {
+        const fieldValue = getFieldValue.getFieldValue(this, context);
+        // Field is required if the other field is empty
+        if (isEmptyValue.isEmptyValue(value) && isEmptyValue.isEmptyValue(fieldValue)) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        return validationHelpers.VALID_RULE;
+    },
+};
+/**
+ * Required if not empty rule - field is required if another field is not empty
+ * Supports both global and sibling scope
+ */
+const requiredIfNotEmptyRule = {
+    name: "requiredIfNotEmpty",
+    description: "The field is required if another field is not empty",
+    sortOrder: -2,
+    requiresValue: false,
+    defaultErrorMessage: "The :input is required",
+    async validate(value, context) {
+        const fieldValue = getFieldValue.getFieldValue(this, context);
+        // Field is required if the other field is not empty
+        if (isEmptyValue.isEmptyValue(value) && !isEmptyValue.isEmptyValue(fieldValue)) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        return validationHelpers.VALID_RULE;
+    },
+};
+/**
+ * Required if in rule - field is required if another field's value is in the given array
+ * Supports both global and sibling scope
+ */
+const requiredIfInRule = {
+    name: "requiredIfIn",
+    description: "The field is required if another field's value is in the given array",
+    sortOrder: -2,
+    requiresValue: false,
+    defaultErrorMessage: "The :input is required",
+    async validate(value, context) {
+        const { values } = this.context.options;
+        const fieldValue = getFieldValue.getFieldValue(this, context);
+        // Field is required if the other field's value is in the array
+        if (isEmptyValue.isEmptyValue(value) && values.includes(fieldValue)) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        return validationHelpers.VALID_RULE;
+    },
+};
+/**
+ * Required if not in rule - field is required if another field's value is NOT in the given array
+ * Supports both global and sibling scope
+ */
+const requiredIfNotInRule = {
+    name: "requiredIfNotIn",
+    description: "The field is required if another field's value is NOT in the given array",
+    sortOrder: -2,
+    requiresValue: false,
+    defaultErrorMessage: "The :input is required",
+    async validate(value, context) {
+        const { values } = this.context.options;
+        const fieldValue = getFieldValue.getFieldValue(this, context);
+        // Field is required if the other field's value is NOT in the array
+        if (isEmptyValue.isEmptyValue(value) && !values.includes(fieldValue)) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        return validationHelpers.VALID_RULE;
+    },
+};exports.requiredIfEmptyRule=requiredIfEmptyRule;exports.requiredIfInRule=requiredIfInRule;exports.requiredIfNotEmptyRule=requiredIfNotEmptyRule;exports.requiredIfNotInRule=requiredIfNotInRule;exports.requiredIfRule=requiredIfRule;//# sourceMappingURL=required-if-rules.js.map

package/cjs/rules/conditional/required-if-rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"required-if-rules.js","sources":["../../../src/rules/conditional/required-if-rules.ts"],"sourcesContent":[null],"names":["getFieldValue","isEmptyValue","invalidRule","VALID_RULE"],"mappings":"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"}

package/cjs/rules/conditional/required-unless-rules.d.ts

@@ -0,0 +1,11 @@
+import type { SchemaRule } from "../../types";
+/**
+ * Required unless rule - field is required unless another field equals a specific value
+ * Supports both global and sibling scope
+ */
+export declare const requiredUnlessRule: SchemaRule<{
+    field: string;
+    value: any;
+    scope?: "global" | "sibling";
+}>;
+//# sourceMappingURL=required-unless-rules.d.ts.map

package/cjs/rules/conditional/required-unless-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"required-unless-rules.d.ts","sourceRoot":"","sources":["../../../src/rules/conditional/required-unless-rules.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAG9C;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,UAAU,CAAC;IAC1C,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,GAAG,CAAC;IACX,KAAK,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;CAC9B,CAiBA,CAAC"}

package/cjs/rules/conditional/required-unless-rules.js

@@ -0,0 +1,20 @@
+'use strict';var getFieldValue=require('../../helpers/get-field-value.js'),validationHelpers=require('../../helpers/validation-helpers.js'),isEmptyValue=require('../../helpers/is-empty-value.js');/**
+ * Required unless rule - field is required unless another field equals a specific value
+ * Supports both global and sibling scope
+ */
+const requiredUnlessRule = {
+    name: "requiredUnless",
+    description: "The field is required unless another field equals a specific value",
+    sortOrder: -2,
+    requiresValue: false,
+    defaultErrorMessage: "The :input is required",
+    async validate(value, context) {
+        const { value: expectedValue } = this.context.options;
+        const fieldValue = getFieldValue.getFieldValue(this, context);
+        // Field is required unless the other field equals the expected value
+        if (isEmptyValue.isEmptyValue(value) && fieldValue !== expectedValue) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        return validationHelpers.VALID_RULE;
+    },
+};exports.requiredUnlessRule=requiredUnlessRule;//# sourceMappingURL=required-unless-rules.js.map

package/cjs/rules/conditional/required-unless-rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"required-unless-rules.js","sources":["../../../src/rules/conditional/required-unless-rules.ts"],"sourcesContent":[null],"names":["getFieldValue","isEmptyValue","invalidRule","VALID_RULE"],"mappings":"oMAIA;;;AAGG;AACU,MAAA,kBAAkB,GAI1B;AACH,IAAA,IAAI,EAAE,gBAAgB;AACtB,IAAA,WAAW,EAAE,oEAAoE;IACjF,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,EAAE,KAAK,EAAE,aAAa,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC;QACtD,MAAM,UAAU,GAAGA,2BAAa,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;;QAGhD,IAAIC,yBAAY,CAAC,KAAK,CAAC,IAAI,UAAU,KAAK,aAAa,EAAE;AACvD,YAAA,OAAOC,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACnC,SAAA;AAED,QAAA,OAAOC,4BAAU,CAAC;KACnB;"}

package/cjs/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/cjs/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,CAoBA,CAAC"}