@warlock.js/seal 4.0.48 → 4.0.59

package/cjs/rules/scalar/accepted-rule.js

@@ -0,0 +1,110 @@
+'use strict';var getFieldValue=require('../../helpers/get-field-value.js'),validationHelpers=require('../../helpers/validation-helpers.js'),isEmptyValue=require('../../helpers/is-empty-value.js');const isAcceptedValue = (value) => {
+    return ["1", "true", "yes", "y", "on", 1, true, "Yes", "Y", "On"].includes(value);
+};
+/**
+ * Validate value as accepted if it equals:
+ * 1 | "1" | true | "true" | "yes" | "y" | "on"
+ */
+const acceptedRule = {
+    name: "accepted",
+    defaultErrorMessage: "The :input must be accepted",
+    description: "The value must be accepted if it equals: 1 | '1' | true | 'true' | 'yes' | 'y' | 'on' | 1 | true | 'Yes' | 'Y' | 'On'",
+    async validate(value, context) {
+        if (isAcceptedValue(value)) {
+            return validationHelpers.VALID_RULE;
+        }
+        return validationHelpers.invalidRule(this, context);
+    },
+};
+/**
+ * Accepted value if another field's value equals to a specific value
+ */
+const acceptedIfRule = {
+    name: "acceptedIf",
+    description: "The field must be accepted if another field's value equals to a specific value",
+    defaultErrorMessage: "The :input must be accepted",
+    async validate(value, context) {
+        const fieldValue = getFieldValue.getFieldValue(this, context);
+        const { value: expectedValue } = this.context.options;
+        if (fieldValue !== expectedValue) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        if (!isAcceptedValue(value)) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        return validationHelpers.VALID_RULE;
+    },
+};
+/**
+ * Accepted if another field is not equal to the given value
+ */
+const acceptedUnlessRule = {
+    name: "acceptedUnless",
+    description: "The field must be accepted if another field's value is not equal to a specific value",
+    defaultErrorMessage: "The :input must be accepted",
+    async validate(value, context) {
+        const fieldValue = getFieldValue.getFieldValue(this, context);
+        const { value: expectedValue } = this.context.options;
+        if (fieldValue === expectedValue) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        if (!isAcceptedValue(value)) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        return validationHelpers.VALID_RULE;
+    },
+};
+/**
+ * Accepted if another field is required
+ */
+const acceptedIfRequiredRule = {
+    name: "acceptedIfRequired",
+    description: "The field must be accepted if another field is required",
+    defaultErrorMessage: "The :input must be accepted",
+    async validate(value, context) {
+        const fieldValue = getFieldValue.getFieldValue(this, context);
+        if (isEmptyValue.isEmptyValue(fieldValue)) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        if (!isAcceptedValue(value)) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        return validationHelpers.VALID_RULE;
+    },
+};
+/**
+ * Accepted if another field is present
+ */
+const acceptedIfPresentRule = {
+    name: "acceptedIfPresent",
+    description: "The field must be accepted if another field is present",
+    defaultErrorMessage: "The :input must be accepted",
+    async validate(value, context) {
+        const fieldValue = getFieldValue.getFieldValue(this, context);
+        if (fieldValue === undefined) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        if (!isAcceptedValue(value)) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        return validationHelpers.VALID_RULE;
+    },
+};
+/**
+ * Accepted if another field is missing
+ */
+const acceptedWithoutRule = {
+    name: "acceptedWithout",
+    description: "The field must be accepted if another field is missing",
+    defaultErrorMessage: "The :input must be accepted",
+    async validate(value, context) {
+        const fieldValue = getFieldValue.getFieldValue(this, context);
+        if (fieldValue !== undefined) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        if (!isAcceptedValue(value)) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        return validationHelpers.VALID_RULE;
+    },
+};exports.acceptedIfPresentRule=acceptedIfPresentRule;exports.acceptedIfRequiredRule=acceptedIfRequiredRule;exports.acceptedIfRule=acceptedIfRule;exports.acceptedRule=acceptedRule;exports.acceptedUnlessRule=acceptedUnlessRule;exports.acceptedWithoutRule=acceptedWithoutRule;//# sourceMappingURL=accepted-rule.js.map

package/cjs/rules/scalar/accepted-rule.js.map

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

package/cjs/rules/scalar/declined-rule.d.ts

@@ -0,0 +1,39 @@
+import type { SchemaRule } from "../../types";
+/**
+ * Validate value as declined if it equals:
+ * 0 | "0" | false | "false" | "no" | "n" | "off" | 0 | false | "No" | "N" | "Off"
+ */
+export declare const declinedRule: SchemaRule;
+/**
+ * Declined value if another field's value equals to a specific value
+ */
+export declare const declinedIfRule: SchemaRule<{
+    field: string;
+    value: any;
+}>;
+/**
+ * Declined if another field is not equal to the given value
+ */
+export declare const declinedUnlessRule: SchemaRule<{
+    field: string;
+    value: any;
+}>;
+/**
+ * Declined if another field is required
+ */
+export declare const declinedIfRequiredRule: SchemaRule<{
+    field: string;
+}>;
+/**
+ * Declined if another field is present
+ */
+export declare const declinedIfPresentRule: SchemaRule<{
+    field: string;
+}>;
+/**
+ * Declined if another field is missing
+ */
+export declare const declinedWithoutRule: SchemaRule<{
+    field: string;
+}>;
+//# sourceMappingURL=declined-rule.d.ts.map

package/cjs/rules/scalar/declined-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"declined-rule.d.ts","sourceRoot":"","sources":["../../../src/rules/scalar/declined-rule.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAM9C;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAE,UAY1B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,UAAU,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,GAAG,CAAA;CAAE,CAiBpE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,UAAU,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,GAAG,CAAA;CAAE,CAkBxE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,sBAAsB,EAAE,UAAU,CAAC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAgBhE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,qBAAqB,EAAE,UAAU,CAAC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAgB/D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,UAAU,CAAC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAgB7D,CAAC"}

package/cjs/rules/scalar/declined-rule.js

@@ -0,0 +1,110 @@
+'use strict';var getFieldValue=require('../../helpers/get-field-value.js'),validationHelpers=require('../../helpers/validation-helpers.js'),isEmptyValue=require('../../helpers/is-empty-value.js');const isDeclinedValue = (value) => {
+    return ["0", "false", "no", "n", "off", 0, false, "No", "N", "Off"].includes(value);
+};
+/**
+ * Validate value as declined if it equals:
+ * 0 | "0" | false | "false" | "no" | "n" | "off" | 0 | false | "No" | "N" | "Off"
+ */
+const declinedRule = {
+    name: "declined",
+    defaultErrorMessage: "The :input must be declined",
+    description: "The value must be declined if it equals: 0 | '0' | false | 'false' | 'no' | 'n' | 'off' | 0 | false | 'No' | 'N' | 'Off'",
+    async validate(value, context) {
+        if (isDeclinedValue(value)) {
+            return validationHelpers.VALID_RULE;
+        }
+        return validationHelpers.invalidRule(this, context);
+    },
+};
+/**
+ * Declined value if another field's value equals to a specific value
+ */
+const declinedIfRule = {
+    name: "declinedIf",
+    description: "The field must be declined if another field's value equals to a specific value",
+    defaultErrorMessage: "The :input must be declined",
+    async validate(value, context) {
+        const fieldValue = getFieldValue.getFieldValue(this, context);
+        const { value: expectedValue } = this.context.options;
+        if (fieldValue !== expectedValue) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        if (!isDeclinedValue(value)) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        return validationHelpers.VALID_RULE;
+    },
+};
+/**
+ * Declined if another field is not equal to the given value
+ */
+const declinedUnlessRule = {
+    name: "declinedUnless",
+    description: "The field must be declined if another field's value is not equal to a specific value",
+    defaultErrorMessage: "The :input must be declined",
+    async validate(value, context) {
+        const fieldValue = getFieldValue.getFieldValue(this, context);
+        const { value: expectedValue } = this.context.options;
+        if (fieldValue === expectedValue) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        if (!isDeclinedValue(value)) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        return validationHelpers.VALID_RULE;
+    },
+};
+/**
+ * Declined if another field is required
+ */
+const declinedIfRequiredRule = {
+    name: "declinedIfRequired",
+    description: "The field must be declined if another field is required",
+    defaultErrorMessage: "The :input must be declined",
+    async validate(value, context) {
+        const fieldValue = getFieldValue.getFieldValue(this, context);
+        if (isEmptyValue.isEmptyValue(fieldValue)) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        if (!isDeclinedValue(value)) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        return validationHelpers.VALID_RULE;
+    },
+};
+/**
+ * Declined if another field is present
+ */
+const declinedIfPresentRule = {
+    name: "declinedIfPresent",
+    description: "The field must be declined if another field is present",
+    defaultErrorMessage: "The :input must be declined",
+    async validate(value, context) {
+        const fieldValue = getFieldValue.getFieldValue(this, context);
+        if (fieldValue === undefined) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        if (!isDeclinedValue(value)) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        return validationHelpers.VALID_RULE;
+    },
+};
+/**
+ * Declined if another field is missing
+ */
+const declinedWithoutRule = {
+    name: "declinedWithout",
+    description: "The field must be declined if another field is missing",
+    defaultErrorMessage: "The :input must be declined",
+    async validate(value, context) {
+        const fieldValue = getFieldValue.getFieldValue(this, context);
+        if (fieldValue !== undefined) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        if (!isDeclinedValue(value)) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        return validationHelpers.VALID_RULE;
+    },
+};exports.declinedIfPresentRule=declinedIfPresentRule;exports.declinedIfRequiredRule=declinedIfRequiredRule;exports.declinedIfRule=declinedIfRule;exports.declinedRule=declinedRule;exports.declinedUnlessRule=declinedUnlessRule;exports.declinedWithoutRule=declinedWithoutRule;//# sourceMappingURL=declined-rule.js.map

package/cjs/rules/scalar/declined-rule.js.map

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

package/cjs/rules/scalar/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./accepted-rule";
+export * from "./declined-rule";
+//# sourceMappingURL=index.d.ts.map

package/cjs/rules/scalar/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/rules/scalar/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC"}

package/cjs/rules/string/alpha.d.ts

@@ -0,0 +1,14 @@
+import type { SchemaRule } from "../../types";
+/**
+ * Alpha rule - allows only alphabetic characters
+ */
+export declare const alphaRule: SchemaRule;
+/**
+ * AlphaNumeric rule - allows only alphanumeric characters
+ */
+export declare const alphaNumericRule: SchemaRule;
+/**
+ * Numeric string rule - allows only numeric characters
+ */
+export declare const isNumericRule: SchemaRule;
+//# sourceMappingURL=alpha.d.ts.map

package/cjs/rules/string/alpha.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alpha.d.ts","sourceRoot":"","sources":["../../../src/rules/string/alpha.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,UASvB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,UAS9B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,UAS3B,CAAC"}

package/cjs/rules/string/alpha.js

@@ -0,0 +1,39 @@
+'use strict';require('@mongez/reinforcements');var validationHelpers=require('../../helpers/validation-helpers.js');/**
+ * Alpha rule - allows only alphabetic characters
+ */
+const alphaRule = {
+    name: "alpha",
+    defaultErrorMessage: "The :input must contain only alphabetic characters",
+    async validate(value, context) {
+        if (/^[a-zA-Z]+$/.test(value)) {
+            return validationHelpers.VALID_RULE;
+        }
+        return validationHelpers.invalidRule(this, context);
+    },
+};
+/**
+ * AlphaNumeric rule - allows only alphanumeric characters
+ */
+const alphaNumericRule = {
+    name: "alphaNumeric",
+    defaultErrorMessage: "The :input must contain only alphanumeric characters",
+    async validate(value, context) {
+        if (/^[a-zA-Z0-9]+$/.test(value)) {
+            return validationHelpers.VALID_RULE;
+        }
+        return validationHelpers.invalidRule(this, context);
+    },
+};
+/**
+ * Numeric string rule - allows only numeric characters
+ */
+const isNumericRule = {
+    name: "numeric",
+    defaultErrorMessage: "The :input must contain only numeric characters",
+    async validate(value, context) {
+        if (/^[0-9]+$/.test(String(value))) {
+            return validationHelpers.VALID_RULE;
+        }
+        return validationHelpers.invalidRule(this, context);
+    },
+};exports.alphaNumericRule=alphaNumericRule;exports.alphaRule=alphaRule;exports.isNumericRule=isNumericRule;//# sourceMappingURL=alpha.js.map

package/cjs/rules/string/alpha.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"alpha.js","sources":["../../../src/rules/string/alpha.ts"],"sourcesContent":[null],"names":["VALID_RULE","invalidRule"],"mappings":"oHAGA;;AAEG;AACU,MAAA,SAAS,GAAe;AACnC,IAAA,IAAI,EAAE,OAAO;AACb,IAAA,mBAAmB,EAAE,oDAAoD;AACzE,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;AAChC,QAAA,IAAI,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;AAC7B,YAAA,OAAOA,4BAAU,CAAC;AACnB,SAAA;AACD,QAAA,OAAOC,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;KACnC;EACD;AAEF;;AAEG;AACU,MAAA,gBAAgB,GAAe;AAC1C,IAAA,IAAI,EAAE,cAAc;AACpB,IAAA,mBAAmB,EAAE,sDAAsD;AAC3E,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;AAChC,QAAA,IAAI,gBAAgB,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;AAChC,YAAA,OAAOD,4BAAU,CAAC;AACnB,SAAA;AACD,QAAA,OAAOC,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;KACnC;EACD;AAEF;;AAEG;AACU,MAAA,aAAa,GAAe;AACvC,IAAA,IAAI,EAAE,SAAS;AACf,IAAA,mBAAmB,EAAE,iDAAiD;AACtE,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;QAChC,IAAI,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE;AAClC,YAAA,OAAOD,4BAAU,CAAC;AACnB,SAAA;AACD,QAAA,OAAOC,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;KACnC;"}

package/cjs/rules/string/credit-card.d.ts

@@ -0,0 +1,6 @@
+import type { SchemaRule } from "../../types";
+/**
+ * Credit card rule - validates credit card number
+ */
+export declare const isCreditCardRule: SchemaRule;
+//# sourceMappingURL=credit-card.d.ts.map

package/cjs/rules/string/credit-card.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credit-card.d.ts","sourceRoot":"","sources":["../../../src/rules/string/credit-card.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,UAkC9B,CAAC"}

package/cjs/rules/string/credit-card.js

@@ -0,0 +1,31 @@
+'use strict';require('@mongez/reinforcements');var validationHelpers=require('../../helpers/validation-helpers.js');/**
+ * Credit card rule - validates credit card number
+ */
+const isCreditCardRule = {
+    name: "creditCard",
+    defaultErrorMessage: "The :input must be a valid credit card number",
+    async validate(value, context) {
+        // Luhn algorithm for credit card validation
+        const cardNumber = String(value).replace(/\s/g, "");
+        if (!/^\d+$/.test(cardNumber)) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        let sum = 0;
+        let isEven = false;
+        for (let i = cardNumber.length - 1; i >= 0; i--) {
+            let digit = parseInt(cardNumber[i], 10);
+            if (isEven) {
+                digit *= 2;
+                if (digit > 9) {
+                    digit -= 9;
+                }
+            }
+            sum += digit;
+            isEven = !isEven;
+        }
+        if (sum % 10 === 0) {
+            return validationHelpers.VALID_RULE;
+        }
+        return validationHelpers.invalidRule(this, context);
+    },
+};exports.isCreditCardRule=isCreditCardRule;//# sourceMappingURL=credit-card.js.map

package/cjs/rules/string/credit-card.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"credit-card.js","sources":["../../../src/rules/string/credit-card.ts"],"sourcesContent":[null],"names":["invalidRule","VALID_RULE"],"mappings":"oHAGA;;AAEG;AACU,MAAA,gBAAgB,GAAe;AAC1C,IAAA,IAAI,EAAE,YAAY;AAClB,IAAA,mBAAmB,EAAE,+CAA+C;AACpE,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;;AAEhC,QAAA,MAAM,UAAU,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;AAEpD,QAAA,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE;AAC7B,YAAA,OAAOA,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACnC,SAAA;QAED,IAAI,GAAG,GAAG,CAAC,CAAC;QACZ,IAAI,MAAM,GAAG,KAAK,CAAC;AAEnB,QAAA,KAAK,IAAI,CAAC,GAAG,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE;YAC/C,IAAI,KAAK,GAAG,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAExC,YAAA,IAAI,MAAM,EAAE;gBACV,KAAK,IAAI,CAAC,CAAC;gBACX,IAAI,KAAK,GAAG,CAAC,EAAE;oBACb,KAAK,IAAI,CAAC,CAAC;AACZ,iBAAA;AACF,aAAA;YAED,GAAG,IAAI,KAAK,CAAC;YACb,MAAM,GAAG,CAAC,MAAM,CAAC;AAClB,SAAA;AAED,QAAA,IAAI,GAAG,GAAG,EAAE,KAAK,CAAC,EAAE;AAClB,YAAA,OAAOC,4BAAU,CAAC;AACnB,SAAA;AAED,QAAA,OAAOD,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;KACnC;"}

package/cjs/rules/string/email.d.ts

@@ -0,0 +1,6 @@
+import type { SchemaRule } from "../../types";
+/**
+ * Email rule - validates email format
+ */
+export declare const emailRule: SchemaRule;
+//# sourceMappingURL=email.d.ts.map

package/cjs/rules/string/email.d.ts.map

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

package/cjs/rules/string/email.js

@@ -0,0 +1,13 @@
+'use strict';var supportiveIs=require('@mongez/supportive-is');require('@mongez/reinforcements');var validationHelpers=require('../../helpers/validation-helpers.js');/**
+ * Email rule - validates email format
+ */
+const emailRule = {
+    name: "email",
+    defaultErrorMessage: "The :input must be a valid email address",
+    async validate(value, context) {
+        if (supportiveIs.isEmail(value)) {
+            return validationHelpers.VALID_RULE;
+        }
+        return validationHelpers.invalidRule(this, context);
+    },
+};exports.emailRule=emailRule;//# sourceMappingURL=email.js.map

package/cjs/rules/string/email.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"email.js","sources":["../../../src/rules/string/email.ts"],"sourcesContent":[null],"names":["isEmail","VALID_RULE","invalidRule"],"mappings":"sKAIA;;AAEG;AACU,MAAA,SAAS,GAAe;AACnC,IAAA,IAAI,EAAE,OAAO;AACb,IAAA,mBAAmB,EAAE,0CAA0C;AAC/D,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;AAChC,QAAA,IAAIA,oBAAO,CAAC,KAAK,CAAC,EAAE;AAClB,YAAA,OAAOC,4BAAU,CAAC;AACnB,SAAA;AACD,QAAA,OAAOC,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;KACnC;"}

package/cjs/rules/string/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * String Validation Rules - Core rules only
+ *
+ * Note: uploadableRule has been moved to @warlock.js/core/validator/v
+ * as it requires framework-specific Upload model
+ */
+export * from "./alpha";
+export * from "./credit-card";
+export * from "./email";
+export * from "./ip";
+export * from "./matches";
+export * from "./pattern";
+export * from "./string-comparison";
+export * from "./strong-password-rule";
+export * from "./url";
+export * from "./without-whitespace";
+//# sourceMappingURL=index.d.ts.map

package/cjs/rules/string/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/rules/string/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,cAAc,SAAS,CAAC;AACxB,cAAc,MAAM,CAAC;AACrB,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,OAAO,CAAC;AACtB,cAAc,sBAAsB,CAAC"}

package/cjs/rules/string/ip.d.ts

@@ -0,0 +1,14 @@
+import type { SchemaRule } from "../../types";
+/**
+ * IP rule - validates IP address (v4 or v6)
+ */
+export declare const ipRule: SchemaRule;
+/**
+ * IPv4 rule - validates IPv4 address
+ */
+export declare const ip4Rule: SchemaRule;
+/**
+ * IPv6 rule - validates IPv6 address
+ */
+export declare const ip6Rule: SchemaRule;
+//# sourceMappingURL=ip.d.ts.map

package/cjs/rules/string/ip.d.ts.map

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

package/cjs/rules/string/ip.js

@@ -0,0 +1,39 @@
+'use strict';var net=require('net');require('@mongez/reinforcements');var validationHelpers=require('../../helpers/validation-helpers.js');/**
+ * IP rule - validates IP address (v4 or v6)
+ */
+const ipRule = {
+    name: "ip",
+    defaultErrorMessage: "The :input must be a valid IP address",
+    async validate(value, context) {
+        if (net.isIP(value)) {
+            return validationHelpers.VALID_RULE;
+        }
+        return validationHelpers.invalidRule(this, context);
+    },
+};
+/**
+ * IPv4 rule - validates IPv4 address
+ */
+const ip4Rule = {
+    name: "ip4",
+    defaultErrorMessage: "The :input must be a valid IPv4 address",
+    async validate(value, context) {
+        if (net.isIP(value) === 4) {
+            return validationHelpers.VALID_RULE;
+        }
+        return validationHelpers.invalidRule(this, context);
+    },
+};
+/**
+ * IPv6 rule - validates IPv6 address
+ */
+const ip6Rule = {
+    name: "ip6",
+    defaultErrorMessage: "The :input must be a valid IPv6 address",
+    async validate(value, context) {
+        if (net.isIP(value) === 6) {
+            return validationHelpers.VALID_RULE;
+        }
+        return validationHelpers.invalidRule(this, context);
+    },
+};exports.ip4Rule=ip4Rule;exports.ip6Rule=ip6Rule;exports.ipRule=ipRule;//# sourceMappingURL=ip.js.map

package/cjs/rules/string/ip.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ip.js","sources":["../../../src/rules/string/ip.ts"],"sourcesContent":[null],"names":["isIP","VALID_RULE","invalidRule"],"mappings":"2IAIA;;AAEG;AACU,MAAA,MAAM,GAAe;AAChC,IAAA,IAAI,EAAE,IAAI;AACV,IAAA,mBAAmB,EAAE,uCAAuC;AAC5D,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;AAChC,QAAA,IAAIA,QAAI,CAAC,KAAK,CAAC,EAAE;AACf,YAAA,OAAOC,4BAAU,CAAC;AACnB,SAAA;AACD,QAAA,OAAOC,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;KACnC;EACD;AAEF;;AAEG;AACU,MAAA,OAAO,GAAe;AACjC,IAAA,IAAI,EAAE,KAAK;AACX,IAAA,mBAAmB,EAAE,yCAAyC;AAC9D,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;AAChC,QAAA,IAAIF,QAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE;AACrB,YAAA,OAAOC,4BAAU,CAAC;AACnB,SAAA;AACD,QAAA,OAAOC,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;KACnC;EACD;AAEF;;AAEG;AACU,MAAA,OAAO,GAAe;AACjC,IAAA,IAAI,EAAE,KAAK;AACX,IAAA,mBAAmB,EAAE,yCAAyC;AAC9D,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;AAChC,QAAA,IAAIF,QAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE;AACrB,YAAA,OAAOC,4BAAU,CAAC;AACnB,SAAA;AACD,QAAA,OAAOC,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;KACnC;"}

package/cjs/rules/string/matches.d.ts

@@ -0,0 +1,8 @@
+import type { SchemaRule } from "../../types";
+/**
+ * Matches rule - value must match another field value
+ */
+export declare const matchesRule: SchemaRule<{
+    field: string;
+}>;
+//# sourceMappingURL=matches.d.ts.map

package/cjs/rules/string/matches.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matches.d.ts","sourceRoot":"","sources":["../../../src/rules/string/matches.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,UAAU,CAAC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAYrD,CAAC"}

package/cjs/rules/string/matches.js

@@ -0,0 +1,14 @@
+'use strict';var reinforcements=require('@mongez/reinforcements'),validationHelpers=require('../../helpers/validation-helpers.js');/**
+ * Matches rule - value must match another field value
+ */
+const matchesRule = {
+    name: "matches",
+    defaultErrorMessage: "The :input must match :field",
+    async validate(value, context) {
+        const otherFieldValue = reinforcements.get(context.allValues, this.context.options.field);
+        if (value === otherFieldValue) {
+            return validationHelpers.VALID_RULE;
+        }
+        return validationHelpers.invalidRule(this, context);
+    },
+};exports.matchesRule=matchesRule;//# sourceMappingURL=matches.js.map

package/cjs/rules/string/matches.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"matches.js","sources":["../../../src/rules/string/matches.ts"],"sourcesContent":[null],"names":["get","VALID_RULE","invalidRule"],"mappings":"mIAIA;;AAEG;AACU,MAAA,WAAW,GAAkC;AACxD,IAAA,IAAI,EAAE,SAAS;AACf,IAAA,mBAAmB,EAAE,8BAA8B;AACnD,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;AAChC,QAAA,MAAM,eAAe,GAAGA,kBAAG,CAAC,OAAO,CAAC,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QAE3E,IAAI,KAAK,KAAK,eAAe,EAAE;AAC7B,YAAA,OAAOC,4BAAU,CAAC;AACnB,SAAA;AAED,QAAA,OAAOC,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;KACnC;"}

package/cjs/rules/string/pattern.d.ts

@@ -0,0 +1,8 @@
+import type { SchemaRule } from "../../types";
+/**
+ * Pattern rule - validates against regex pattern
+ */
+export declare const patternRule: SchemaRule<{
+    pattern: RegExp;
+}>;
+//# sourceMappingURL=pattern.d.ts.map

package/cjs/rules/string/pattern.d.ts.map

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

package/cjs/rules/string/pattern.js

@@ -0,0 +1,13 @@
+'use strict';require('@mongez/reinforcements');var validationHelpers=require('../../helpers/validation-helpers.js');/**
+ * Pattern rule - validates against regex pattern
+ */
+const patternRule = {
+    name: "pattern",
+    defaultErrorMessage: "The :input does not match the required pattern",
+    async validate(value, context) {
+        if (this.context.options.pattern.test(value)) {
+            return validationHelpers.VALID_RULE;
+        }
+        return validationHelpers.invalidRule(this, context);
+    },
+};exports.patternRule=patternRule;//# sourceMappingURL=pattern.js.map

package/cjs/rules/string/pattern.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern.js","sources":["../../../src/rules/string/pattern.ts"],"sourcesContent":[null],"names":["VALID_RULE","invalidRule"],"mappings":"oHAGA;;AAEG;AACU,MAAA,WAAW,GAAoC;AAC1D,IAAA,IAAI,EAAE,SAAS;AACf,IAAA,mBAAmB,EAAE,gDAAgD;AACrE,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;AAChC,QAAA,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;AAC5C,YAAA,OAAOA,4BAAU,CAAC;AACnB,SAAA;AACD,QAAA,OAAOC,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;KACnC;"}

package/cjs/rules/string/string-comparison.d.ts

@@ -0,0 +1,26 @@
+import type { SchemaRule } from "../../types";
+/**
+ * Starts with rule
+ */
+export declare const startsWithRule: SchemaRule<{
+    value: string;
+}>;
+/**
+ * Ends with rule
+ */
+export declare const endsWithRule: SchemaRule<{
+    value: string;
+}>;
+/**
+ * Contains rule
+ */
+export declare const containsRule: SchemaRule<{
+    value: string;
+}>;
+/**
+ * Not contains rule
+ */
+export declare const notContainsRule: SchemaRule<{
+    value: string;
+}>;
+//# sourceMappingURL=string-comparison.d.ts.map

package/cjs/rules/string/string-comparison.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-comparison.d.ts","sourceRoot":"","sources":["../../../src/rules/string/string-comparison.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,UAAU,CAAC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CASxD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,UAAU,CAAC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAStD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,UAAU,CAAC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAStD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,UAAU,CAAC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CASzD,CAAC"}