@warlock.js/seal 4.0.174 → 4.1.1

package/esm/rules/scalar/declined-rule.mjs

@@ -0,0 +1,116 @@
+import { getFieldValue } from "../../helpers/get-field-value.mjs";
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+import { isEmptyValue } from "../../helpers/is-empty-value.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/scalar/declined-rule.ts
+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 VALID_RULE;
+		return 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 :field's value equals to :value",
+	defaultErrorMessage: "The :input must be declined",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		const { value: expectedValue } = this.context.options;
+		this.context.translatableParams.field = this.context.options.field;
+		this.context.translatableParams.value = this.context.options.value;
+		if (fieldValue !== expectedValue) return invalidRule(this, context);
+		if (!isDeclinedValue(value)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+/**
+* Declined if another field is not equal to the given value
+*/
+const declinedUnlessRule = {
+	name: "declinedUnless",
+	description: "The field must be declined if :field's value is not equal to :value",
+	defaultErrorMessage: "The :input must be declined",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		const { value: expectedValue } = this.context.options;
+		this.context.translatableParams.field = this.context.options.field;
+		this.context.translatableParams.value = this.context.options.value;
+		if (fieldValue === expectedValue) return invalidRule(this, context);
+		if (!isDeclinedValue(value)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+/**
+* Declined if another field is required
+*/
+const declinedIfRequiredRule = {
+	name: "declinedIfRequired",
+	description: "The field must be declined if :field is required",
+	defaultErrorMessage: "The :input must be declined",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		this.context.translatableParams.field = this.context.options.field;
+		if (isEmptyValue(fieldValue)) return invalidRule(this, context);
+		if (!isDeclinedValue(value)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+/**
+* Declined if another field is present
+*/
+const declinedIfPresentRule = {
+	name: "declinedIfPresent",
+	description: "The field must be declined if :field is present",
+	defaultErrorMessage: "The :input must be declined",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		this.context.translatableParams.field = this.context.options.field;
+		if (fieldValue === void 0) return invalidRule(this, context);
+		if (!isDeclinedValue(value)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+/**
+* Declined if another field is missing
+*/
+const declinedWithoutRule = {
+	name: "declinedWithout",
+	description: "The field must be declined if :field is missing",
+	defaultErrorMessage: "The :input must be declined",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		this.context.translatableParams.field = this.context.options.field;
+		if (fieldValue !== void 0) return invalidRule(this, context);
+		if (!isDeclinedValue(value)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+
+//#endregion
+export { declinedIfPresentRule, declinedIfRequiredRule, declinedIfRule, declinedRule, declinedUnlessRule, declinedWithoutRule };
+//# sourceMappingURL=declined-rule.mjs.map

package/esm/rules/scalar/declined-rule.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"declined-rule.mjs","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/scalar/declined-rule.ts"],"sourcesContent":["import { getFieldValue, invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport { isEmptyValue } from \"../../helpers/is-empty-value\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\nconst isDeclinedValue = (value: any) => {\r\n  return [\"0\", \"false\", \"no\", \"n\", \"off\", 0, false, \"No\", \"N\", \"Off\"].includes(value);\r\n};\r\n\r\n/**\r\n * Validate value as declined if it equals:\r\n * 0 | \"0\" | false | \"false\" | \"no\" | \"n\" | \"off\" | 0 | false | \"No\" | \"N\" | \"Off\"\r\n */\r\nexport const declinedRule: SchemaRule = {\r\n  name: \"declined\",\r\n  defaultErrorMessage: \"The :input must be declined\",\r\n  description:\r\n    \"The value must be declined if it equals: 0 | '0' | false | 'false' | 'no' | 'n' | 'off' | 0 | false | 'No' | 'N' | 'Off'\",\r\n  async validate(value: any, context) {\r\n    if (isDeclinedValue(value)) {\r\n      return VALID_RULE;\r\n    }\r\n\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * Declined value if another field's value equals to a specific value\r\n */\r\nexport const declinedIfRule: SchemaRule<{ field: string; value: any }> = {\r\n  name: \"declinedIf\",\r\n  description: \"The field must be declined if :field's value equals to :value\",\r\n  defaultErrorMessage: \"The :input must be declined\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n    const { value: expectedValue } = this.context.options;\r\n\r\n    this.context.translatableParams.field = this.context.options.field;\r\n    this.context.translatableParams.value = this.context.options.value;\r\n\r\n    if (fieldValue !== expectedValue) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (!isDeclinedValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\n/**\r\n * Declined if another field is not equal to the given value\r\n */\r\nexport const declinedUnlessRule: SchemaRule<{ field: string; value: any }> = {\r\n  name: \"declinedUnless\",\r\n  description: \"The field must be declined if :field's value is not equal to :value\",\r\n  defaultErrorMessage: \"The :input must be declined\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n    const { value: expectedValue } = this.context.options;\r\n\r\n    this.context.translatableParams.field = this.context.options.field;\r\n    this.context.translatableParams.value = this.context.options.value;\r\n    if (fieldValue === expectedValue) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (!isDeclinedValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\n/**\r\n * Declined if another field is required\r\n */\r\nexport const declinedIfRequiredRule: SchemaRule<{ field: string }> = {\r\n  name: \"declinedIfRequired\",\r\n  description: \"The field must be declined if :field is required\",\r\n  defaultErrorMessage: \"The :input must be declined\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n    this.context.translatableParams.field = this.context.options.field;\r\n\r\n    if (isEmptyValue(fieldValue)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (!isDeclinedValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\n/**\r\n * Declined if another field is present\r\n */\r\nexport const declinedIfPresentRule: SchemaRule<{ field: string }> = {\r\n  name: \"declinedIfPresent\",\r\n  description: \"The field must be declined if :field is present\",\r\n  defaultErrorMessage: \"The :input must be declined\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n    this.context.translatableParams.field = this.context.options.field;\r\n\r\n    if (fieldValue === undefined) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (!isDeclinedValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\n/**\r\n * Declined if another field is missing\r\n */\r\nexport const declinedWithoutRule: SchemaRule<{ field: string }> = {\r\n  name: \"declinedWithout\",\r\n  description: \"The field must be declined if :field is missing\",\r\n  defaultErrorMessage: \"The :input must be declined\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n    this.context.translatableParams.field = this.context.options.field;\r\n\r\n    if (fieldValue !== undefined) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (!isDeclinedValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n"],"mappings":";;;;;;AAIA,MAAM,mBAAmB,UAAe;CACtC,OAAO;EAAC;EAAK;EAAS;EAAM;EAAK;EAAO;EAAG;EAAO;EAAM;EAAK;CAAK,EAAE,SAAS,KAAK;AACpF;;;;;AAMA,MAAa,eAA2B;CACtC,MAAM;CACN,qBAAqB;CACrB,aACE;CACF,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,gBAAgB,KAAK,GACvB,OAAO;EAGT,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,iBAA4D;CACvE,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAC9C,MAAM,EAAE,OAAO,kBAAkB,KAAK,QAAQ;EAE9C,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAC7D,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,IAAI,eAAe,eACjB,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,CAAC,gBAAgB,KAAK,GACxB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;AAKA,MAAa,qBAAgE;CAC3E,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAC9C,MAAM,EAAE,OAAO,kBAAkB,KAAK,QAAQ;EAE9C,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAC7D,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAC7D,IAAI,eAAe,eACjB,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,CAAC,gBAAgB,KAAK,GACxB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;AAKA,MAAa,yBAAwD;CACnE,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAC9C,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,IAAI,aAAa,UAAU,GACzB,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,CAAC,gBAAgB,KAAK,GACxB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;AAKA,MAAa,wBAAuD;CAClE,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAC9C,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,IAAI,eAAe,QACjB,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,CAAC,gBAAgB,KAAK,GACxB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;AAKA,MAAa,sBAAqD;CAChE,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAC9C,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,IAAI,eAAe,QACjB,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,CAAC,gBAAgB,KAAK,GACxB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF"}

package/esm/rules/scalar/index.mjs

@@ -0,0 +1,4 @@
+import { acceptedIfPresentRule, acceptedIfRequiredRule, acceptedIfRule, acceptedRule, acceptedUnlessRule, acceptedWithoutRule } from "./accepted-rule.mjs";
+import { declinedIfPresentRule, declinedIfRequiredRule, declinedIfRule, declinedRule, declinedUnlessRule, declinedWithoutRule } from "./declined-rule.mjs";
+
+export {  };

package/esm/rules/string/alpha.d.mts

@@ -0,0 +1,18 @@
+import { SchemaRule } from "../../types/rule-types.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/string/alpha.d.ts
+/**
+ * Alpha rule - allows only alphabetic characters
+ */
+declare const alphaRule: SchemaRule;
+/**
+ * AlphaNumeric rule - allows only alphanumeric characters
+ */
+declare const alphaNumericRule: SchemaRule;
+/**
+ * Numeric string rule - allows only numeric characters
+ */
+declare const isNumericRule: SchemaRule;
+//#endregion
+export { alphaNumericRule, alphaRule, isNumericRule };
+//# sourceMappingURL=alpha.d.mts.map

package/esm/rules/string/alpha.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alpha.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/string/alpha.ts"],"mappings":";;;;;AAMA;cAAa,SAAA,EAAW,UASvB;;;AAAA;cAKY,gBAAA,EAAkB,UAS9B;;;;cAKY,aAAA,EAAe,UAS3B"}

package/esm/rules/string/alpha.mjs

@@ -0,0 +1,41 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/string/alpha.ts
+/**
+* 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 VALID_RULE;
+		return 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 VALID_RULE;
+		return 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 VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+
+//#endregion
+export { alphaNumericRule, alphaRule, isNumericRule };
+//# sourceMappingURL=alpha.mjs.map

package/esm/rules/string/alpha.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"alpha.mjs","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/string/alpha.ts"],"sourcesContent":["import { invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * Alpha rule - allows only alphabetic characters\r\n */\r\nexport const alphaRule: SchemaRule = {\r\n  name: \"alpha\",\r\n  defaultErrorMessage: \"The :input must contain only alphabetic characters\",\r\n  async validate(value: any, context) {\r\n    if (/^[a-zA-Z]+$/.test(value)) {\r\n      return VALID_RULE;\r\n    }\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * AlphaNumeric rule - allows only alphanumeric characters\r\n */\r\nexport const alphaNumericRule: SchemaRule = {\r\n  name: \"alphaNumeric\",\r\n  defaultErrorMessage: \"The :input must contain only alphanumeric characters\",\r\n  async validate(value: any, context) {\r\n    if (/^[a-zA-Z0-9]+$/.test(value)) {\r\n      return VALID_RULE;\r\n    }\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * Numeric string rule - allows only numeric characters\r\n */\r\nexport const isNumericRule: SchemaRule = {\r\n  name: \"numeric\",\r\n  defaultErrorMessage: \"The :input must contain only numeric characters\",\r\n  async validate(value: any, context) {\r\n    if (/^[0-9]+$/.test(String(value))) {\r\n      return VALID_RULE;\r\n    }\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n"],"mappings":";;;;;;;AAMA,MAAa,YAAwB;CACnC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,cAAc,KAAK,KAAK,GAC1B,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,mBAA+B;CAC1C,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,iBAAiB,KAAK,KAAK,GAC7B,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,gBAA4B;CACvC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,WAAW,KAAK,OAAO,KAAK,CAAC,GAC/B,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF"}

package/esm/rules/string/credit-card.d.mts

@@ -0,0 +1,10 @@
+import { SchemaRule } from "../../types/rule-types.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/string/credit-card.d.ts
+/**
+ * Credit card rule - validates credit card number
+ */
+declare const isCreditCardRule: SchemaRule;
+//#endregion
+export { isCreditCardRule };
+//# sourceMappingURL=credit-card.d.mts.map

package/esm/rules/string/credit-card.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credit-card.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/string/credit-card.ts"],"mappings":";;;;;AAMA;cAAa,gBAAA,EAAkB,UAkC9B"}

package/esm/rules/string/credit-card.mjs

@@ -0,0 +1,32 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/string/credit-card.ts
+/**
+* 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) {
+		const cardNumber = String(value).replace(/\s/g, "");
+		if (!/^\d+$/.test(cardNumber)) return 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 VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+
+//#endregion
+export { isCreditCardRule };
+//# sourceMappingURL=credit-card.mjs.map

package/esm/rules/string/credit-card.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"credit-card.mjs","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/string/credit-card.ts"],"sourcesContent":["import { invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * Credit card rule - validates credit card number\r\n */\r\nexport const isCreditCardRule: SchemaRule = {\r\n  name: \"creditCard\",\r\n  defaultErrorMessage: \"The :input must be a valid credit card number\",\r\n  async validate(value: any, context) {\r\n    // Luhn algorithm for credit card validation\r\n    const cardNumber = String(value).replace(/\\s/g, \"\");\r\n\r\n    if (!/^\\d+$/.test(cardNumber)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    let sum = 0;\r\n    let isEven = false;\r\n\r\n    for (let i = cardNumber.length - 1; i >= 0; i--) {\r\n      let digit = parseInt(cardNumber[i], 10);\r\n\r\n      if (isEven) {\r\n        digit *= 2;\r\n        if (digit > 9) {\r\n          digit -= 9;\r\n        }\r\n      }\r\n\r\n      sum += digit;\r\n      isEven = !isEven;\r\n    }\r\n\r\n    if (sum % 10 === 0) {\r\n      return VALID_RULE;\r\n    }\r\n\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n"],"mappings":";;;;;;;AAMA,MAAa,mBAA+B;CAC1C,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAElC,MAAM,aAAa,OAAO,KAAK,EAAE,QAAQ,OAAO,EAAE;EAElD,IAAI,CAAC,QAAQ,KAAK,UAAU,GAC1B,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,MAAM;EACV,IAAI,SAAS;EAEb,KAAK,IAAI,IAAI,WAAW,SAAS,GAAG,KAAK,GAAG,KAAK;GAC/C,IAAI,QAAQ,SAAS,WAAW,IAAI,EAAE;GAEtC,IAAI,QAAQ;IACV,SAAS;IACT,IAAI,QAAQ,GACV,SAAS;GAEb;GAEA,OAAO;GACP,SAAS,CAAC;EACZ;EAEA,IAAI,MAAM,OAAO,GACf,OAAO;EAGT,OAAO,YAAY,MAAM,OAAO;CAClC;AACF"}

package/esm/rules/string/email.d.mts

@@ -0,0 +1,10 @@
+import { SchemaRule } from "../../types/rule-types.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/string/email.d.ts
+/**
+ * Email rule - validates email format
+ */
+declare const emailRule: SchemaRule;
+//#endregion
+export { emailRule };
+//# sourceMappingURL=email.d.mts.map

package/esm/rules/string/email.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"email.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/string/email.ts"],"mappings":";;;;;AAOA;cAAa,SAAA,EAAW,UASvB"}

package/esm/rules/string/email.mjs

@@ -0,0 +1,20 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+import { isEmail } from "@mongez/supportive-is";
+
+//#region ../../@warlock.js/seal/src/rules/string/email.ts
+/**
+* Email rule - validates email format
+*/
+const emailRule = {
+	name: "email",
+	defaultErrorMessage: "The :input must be a valid email address",
+	async validate(value, context) {
+		if (isEmail(value)) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+
+//#endregion
+export { emailRule };
+//# sourceMappingURL=email.mjs.map

package/esm/rules/string/email.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"email.mjs","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/string/email.ts"],"sourcesContent":["import { isEmail } from \"@mongez/supportive-is\";\r\nimport { invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * Email rule - validates email format\r\n */\r\nexport const emailRule: SchemaRule = {\r\n  name: \"email\",\r\n  defaultErrorMessage: \"The :input must be a valid email address\",\r\n  async validate(value: any, context) {\r\n    if (isEmail(value)) {\r\n      return VALID_RULE;\r\n    }\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n"],"mappings":";;;;;;;;AAOA,MAAa,YAAwB;CACnC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,QAAQ,KAAK,GACf,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF"}

package/esm/rules/string/id-formats.d.mts

@@ -0,0 +1,54 @@
+import { SchemaRule } from "../../types/rule-types.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/string/id-formats.d.ts
+type UUIDVersion = 1 | 3 | 4 | 5 | 6 | 7;
+/**
+ * UUID rule — value must be a valid UUID. Optionally restrict to a specific version.
+ *
+ * @example
+ * v.string().uuid()       // any RFC 4122 UUID
+ * v.string().uuid(4)      // only v4 (random)
+ * v.string().uuid(7)      // only v7 (timestamp-ordered)
+ */
+declare const uuidRule: SchemaRule<{
+  version?: UUIDVersion;
+}>;
+/**
+ * CUID rule — value must be a valid CUID.
+ *
+ * Defaults to CUID2 (24 chars, lowercase, starts with letter — see
+ * https://github.com/paralleldrive/cuid2). Pass `{ version: 1 }` for legacy
+ * CUID1 format (starts with "c", ≥25 chars).
+ *
+ * @example
+ * v.string().cuid()                  // CUID2
+ * v.string().cuid({ version: 1 })    // legacy CUID1
+ */
+declare const cuidRule: SchemaRule<{
+  version?: 1 | 2;
+}>;
+/**
+ * ULID rule — value must be a valid ULID (26 chars, Crockford base32).
+ *
+ * Crockford base32 excludes the letters I, L, O, U to avoid ambiguity.
+ *
+ * @example
+ * v.string().ulid()
+ */
+declare const ulidRule: SchemaRule;
+/**
+ * nanoid rule — value must be a valid nanoid string.
+ *
+ * Default length is 21 (standard nanoid). URL-safe alphabet:
+ * A–Z, a–z, 0–9, `_`, `-`.
+ *
+ * @example
+ * v.string().nanoid()         // 21 chars (default)
+ * v.string().nanoid(10)       // 10 chars
+ */
+declare const nanoidRule: SchemaRule<{
+  length?: number;
+}>;
+//#endregion
+export { UUIDVersion, cuidRule, nanoidRule, ulidRule, uuidRule };
+//# sourceMappingURL=id-formats.d.mts.map

package/esm/rules/string/id-formats.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"id-formats.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/string/id-formats.ts"],"mappings":";;;KAuBY,WAAA;;AAAZ;;;;AAAuB;AAUvB;;cAAa,QAAA,EAAU,UAAU;EAAG,OAAA,GAAU,WAAA;AAAA;;;;AAAW;AA8BzD;;;;AAA2C;AAqB3C;;cArBa,QAAA,EAAU,UAAU;EAAG,OAAO;AAAA;AAyC3C;;;;AAA4C;;;;AAA5C,cApBa,QAAA,EAAU,UAQtB;;;;;;;;;;;cAYY,UAAA,EAAY,UAAU;EAAG,MAAM;AAAA"}

package/esm/rules/string/id-formats.mjs

@@ -0,0 +1,104 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/string/id-formats.ts
+/**
+* Modern ID format validators — UUID, CUID, ULID, nanoid.
+*
+* Each rule asserts the value is a string in the canonical format for its
+* identifier scheme. Rules are intentionally strict (variant nibbles checked
+* for UUID, character classes enforced for ULID's Crockford base32, etc.)
+* so "looks-like-but-not-valid" inputs are rejected.
+*/
+const UUID_ANY = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const UUID_BY_VERSION = {
+	1: /^[0-9a-f]{8}-[0-9a-f]{4}-1[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+	3: /^[0-9a-f]{8}-[0-9a-f]{4}-3[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+	4: /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+	5: /^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+	6: /^[0-9a-f]{8}-[0-9a-f]{4}-6[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+	7: /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
+};
+/**
+* UUID rule — value must be a valid UUID. Optionally restrict to a specific version.
+*
+* @example
+* v.string().uuid()       // any RFC 4122 UUID
+* v.string().uuid(4)      // only v4 (random)
+* v.string().uuid(7)      // only v7 (timestamp-ordered)
+*/
+const uuidRule = {
+	name: "uuid",
+	defaultErrorMessage: "The :input must be a valid UUID",
+	async validate(value, context) {
+		if (typeof value !== "string") return invalidRule(this, context);
+		const version = this.context.options.version;
+		if ((version ? UUID_BY_VERSION[version] : UUID_ANY).test(value)) return VALID_RULE;
+		if (version !== void 0) this.context.translationParams.version = version;
+		return invalidRule(this, context);
+	}
+};
+/**
+* CUID rule — value must be a valid CUID.
+*
+* Defaults to CUID2 (24 chars, lowercase, starts with letter — see
+* https://github.com/paralleldrive/cuid2). Pass `{ version: 1 }` for legacy
+* CUID1 format (starts with "c", ≥25 chars).
+*
+* @example
+* v.string().cuid()                  // CUID2
+* v.string().cuid({ version: 1 })    // legacy CUID1
+*/
+const cuidRule = {
+	name: "cuid",
+	defaultErrorMessage: "The :input must be a valid CUID",
+	async validate(value, context) {
+		if (typeof value !== "string") return invalidRule(this, context);
+		const version = this.context.options.version ?? 2;
+		if ((version === 1 ? /^c[a-z0-9]{24,}$/ : /^[a-z][a-z0-9]{23}$/).test(value)) return VALID_RULE;
+		this.context.translationParams.version = version;
+		return invalidRule(this, context);
+	}
+};
+/**
+* ULID rule — value must be a valid ULID (26 chars, Crockford base32).
+*
+* Crockford base32 excludes the letters I, L, O, U to avoid ambiguity.
+*
+* @example
+* v.string().ulid()
+*/
+const ulidRule = {
+	name: "ulid",
+	defaultErrorMessage: "The :input must be a valid ULID",
+	async validate(value, context) {
+		if (typeof value !== "string") return invalidRule(this, context);
+		if (/^[0-9A-HJKMNP-TV-Z]{26}$/.test(value)) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+/**
+* nanoid rule — value must be a valid nanoid string.
+*
+* Default length is 21 (standard nanoid). URL-safe alphabet:
+* A–Z, a–z, 0–9, `_`, `-`.
+*
+* @example
+* v.string().nanoid()         // 21 chars (default)
+* v.string().nanoid(10)       // 10 chars
+*/
+const nanoidRule = {
+	name: "nanoid",
+	defaultErrorMessage: "The :input must be a valid nanoid",
+	async validate(value, context) {
+		if (typeof value !== "string") return invalidRule(this, context);
+		const length = this.context.options.length ?? 21;
+		if (new RegExp(`^[A-Za-z0-9_-]{${length}}$`).test(value)) return VALID_RULE;
+		this.context.translationParams.length = length;
+		return invalidRule(this, context);
+	}
+};
+
+//#endregion
+export { cuidRule, nanoidRule, ulidRule, uuidRule };
+//# sourceMappingURL=id-formats.mjs.map

package/esm/rules/string/id-formats.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"id-formats.mjs","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/string/id-formats.ts"],"sourcesContent":["import { invalidRule, VALID_RULE } from \"../../helpers\";\nimport type { SchemaRule } from \"../../types\";\n\n/**\n * Modern ID format validators — UUID, CUID, ULID, nanoid.\n *\n * Each rule asserts the value is a string in the canonical format for its\n * identifier scheme. Rules are intentionally strict (variant nibbles checked\n * for UUID, character classes enforced for ULID's Crockford base32, etc.)\n * so \"looks-like-but-not-valid\" inputs are rejected.\n */\n\nconst UUID_ANY = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;\n\nconst UUID_BY_VERSION: Record<1 | 3 | 4 | 5 | 6 | 7, RegExp> = {\n  1: /^[0-9a-f]{8}-[0-9a-f]{4}-1[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,\n  3: /^[0-9a-f]{8}-[0-9a-f]{4}-3[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,\n  4: /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,\n  5: /^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,\n  6: /^[0-9a-f]{8}-[0-9a-f]{4}-6[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,\n  7: /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,\n};\n\nexport type UUIDVersion = 1 | 3 | 4 | 5 | 6 | 7;\n\n/**\n * UUID rule — value must be a valid UUID. Optionally restrict to a specific version.\n *\n * @example\n * v.string().uuid()       // any RFC 4122 UUID\n * v.string().uuid(4)      // only v4 (random)\n * v.string().uuid(7)      // only v7 (timestamp-ordered)\n */\nexport const uuidRule: SchemaRule<{ version?: UUIDVersion }> = {\n  name: \"uuid\",\n  defaultErrorMessage: \"The :input must be a valid UUID\",\n  async validate(value, context) {\n    if (typeof value !== \"string\") return invalidRule(this, context);\n\n    const version = this.context.options.version;\n\n    const pattern = version ? UUID_BY_VERSION[version] : UUID_ANY;\n    if (pattern.test(value)) return VALID_RULE;\n\n    if (version !== undefined) {\n      this.context.translationParams.version = version;\n    }\n\n    return invalidRule(this, context);\n  },\n};\n\n/**\n * CUID rule — value must be a valid CUID.\n *\n * Defaults to CUID2 (24 chars, lowercase, starts with letter — see\n * https://github.com/paralleldrive/cuid2). Pass `{ version: 1 }` for legacy\n * CUID1 format (starts with \"c\", ≥25 chars).\n *\n * @example\n * v.string().cuid()                  // CUID2\n * v.string().cuid({ version: 1 })    // legacy CUID1\n */\nexport const cuidRule: SchemaRule<{ version?: 1 | 2 }> = {\n  name: \"cuid\",\n  defaultErrorMessage: \"The :input must be a valid CUID\",\n  async validate(value, context) {\n    if (typeof value !== \"string\") return invalidRule(this, context);\n    const version = this.context.options.version ?? 2;\n    const pattern = version === 1 ? /^c[a-z0-9]{24,}$/ : /^[a-z][a-z0-9]{23}$/;\n    if (pattern.test(value)) return VALID_RULE;\n    this.context.translationParams.version = version;\n    return invalidRule(this, context);\n  },\n};\n\n/**\n * ULID rule — value must be a valid ULID (26 chars, Crockford base32).\n *\n * Crockford base32 excludes the letters I, L, O, U to avoid ambiguity.\n *\n * @example\n * v.string().ulid()\n */\nexport const ulidRule: SchemaRule = {\n  name: \"ulid\",\n  defaultErrorMessage: \"The :input must be a valid ULID\",\n  async validate(value, context) {\n    if (typeof value !== \"string\") return invalidRule(this, context);\n    if (/^[0-9A-HJKMNP-TV-Z]{26}$/.test(value)) return VALID_RULE;\n    return invalidRule(this, context);\n  },\n};\n\n/**\n * nanoid rule — value must be a valid nanoid string.\n *\n * Default length is 21 (standard nanoid). URL-safe alphabet:\n * A–Z, a–z, 0–9, `_`, `-`.\n *\n * @example\n * v.string().nanoid()         // 21 chars (default)\n * v.string().nanoid(10)       // 10 chars\n */\nexport const nanoidRule: SchemaRule<{ length?: number }> = {\n  name: \"nanoid\",\n  defaultErrorMessage: \"The :input must be a valid nanoid\",\n  async validate(value, context) {\n    if (typeof value !== \"string\") return invalidRule(this, context);\n    const length = this.context.options.length ?? 21;\n    const pattern = new RegExp(`^[A-Za-z0-9_-]{${length}}$`);\n    if (pattern.test(value)) return VALID_RULE;\n    this.context.translationParams.length = length;\n    return invalidRule(this, context);\n  },\n};\n"],"mappings":";;;;;;;;;;;;AAYA,MAAM,WAAW;AAEjB,MAAM,kBAAyD;CAC7D,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;AACL;;;;;;;;;AAYA,MAAa,WAAkD;CAC7D,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAO,SAAS;EAC7B,IAAI,OAAO,UAAU,UAAU,OAAO,YAAY,MAAM,OAAO;EAE/D,MAAM,UAAU,KAAK,QAAQ,QAAQ;EAGrC,KADgB,UAAU,gBAAgB,WAAW,UACzC,KAAK,KAAK,GAAG,OAAO;EAEhC,IAAI,YAAY,QACd,KAAK,QAAQ,kBAAkB,UAAU;EAG3C,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;;;;;;;;;AAaA,MAAa,WAA4C;CACvD,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAO,SAAS;EAC7B,IAAI,OAAO,UAAU,UAAU,OAAO,YAAY,MAAM,OAAO;EAC/D,MAAM,UAAU,KAAK,QAAQ,QAAQ,WAAW;EAEhD,KADgB,YAAY,IAAI,qBAAqB,uBACzC,KAAK,KAAK,GAAG,OAAO;EAChC,KAAK,QAAQ,kBAAkB,UAAU;EACzC,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;;;;;;AAUA,MAAa,WAAuB;CAClC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAO,SAAS;EAC7B,IAAI,OAAO,UAAU,UAAU,OAAO,YAAY,MAAM,OAAO;EAC/D,IAAI,2BAA2B,KAAK,KAAK,GAAG,OAAO;EACnD,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;;;;;;;;AAYA,MAAa,aAA8C;CACzD,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAO,SAAS;EAC7B,IAAI,OAAO,UAAU,UAAU,OAAO,YAAY,MAAM,OAAO;EAC/D,MAAM,SAAS,KAAK,QAAQ,QAAQ,UAAU;EAE9C,IAAI,IADgB,OAAO,kBAAkB,OAAO,GAC1C,EAAE,KAAK,KAAK,GAAG,OAAO;EAChC,KAAK,QAAQ,kBAAkB,SAAS;EACxC,OAAO,YAAY,MAAM,OAAO;CAClC;AACF"}

package/esm/rules/string/index.mjs

@@ -0,0 +1,13 @@
+import { alphaNumericRule, alphaRule, isNumericRule } from "./alpha.mjs";
+import { isCreditCardRule } from "./credit-card.mjs";
+import { emailRule } from "./email.mjs";
+import { cuidRule, nanoidRule, ulidRule, uuidRule } from "./id-formats.mjs";
+import { ip4Rule, ip6Rule, ipRule } from "./ip.mjs";
+import { matchesRule } from "./matches.mjs";
+import { patternRule } from "./pattern.mjs";
+import { containsRule, endsWithRule, notContainsRule, startsWithRule } from "./string-comparison.mjs";
+import { strongPasswordRule } from "./strong-password-rule.mjs";
+import { urlRule } from "./url.mjs";
+import { withoutWhitespaceRule } from "./without-whitespace.mjs";
+
+export {  };

package/esm/rules/string/ip.d.mts

@@ -0,0 +1,18 @@
+import { SchemaRule } from "../../types/rule-types.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/string/ip.d.ts
+/**
+ * IP rule - validates IP address (v4 or v6)
+ */
+declare const ipRule: SchemaRule;
+/**
+ * IPv4 rule - validates IPv4 address
+ */
+declare const ip4Rule: SchemaRule;
+/**
+ * IPv6 rule - validates IPv6 address
+ */
+declare const ip6Rule: SchemaRule;
+//#endregion
+export { ip4Rule, ip6Rule, ipRule };
+//# sourceMappingURL=ip.d.mts.map

package/esm/rules/string/ip.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ip.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/string/ip.ts"],"mappings":";;;;;AAOA;cAAa,MAAA,EAAQ,UASpB;;;AAAA;cAKY,OAAA,EAAS,UASrB;;;;cAKY,OAAA,EAAS,UASrB"}

package/esm/rules/string/ip.mjs

@@ -0,0 +1,42 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+import { isIP } from "net";
+
+//#region ../../@warlock.js/seal/src/rules/string/ip.ts
+/**
+* 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 (isIP(value)) return VALID_RULE;
+		return 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 (isIP(value) === 4) return VALID_RULE;
+		return 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 (isIP(value) === 6) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+
+//#endregion
+export { ip4Rule, ip6Rule, ipRule };
+//# sourceMappingURL=ip.mjs.map

package/esm/rules/string/ip.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ip.mjs","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/string/ip.ts"],"sourcesContent":["import { isIP } from \"net\";\r\nimport { invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * IP rule - validates IP address (v4 or v6)\r\n */\r\nexport const ipRule: SchemaRule = {\r\n  name: \"ip\",\r\n  defaultErrorMessage: \"The :input must be a valid IP address\",\r\n  async validate(value: any, context) {\r\n    if (isIP(value)) {\r\n      return VALID_RULE;\r\n    }\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * IPv4 rule - validates IPv4 address\r\n */\r\nexport const ip4Rule: SchemaRule = {\r\n  name: \"ip4\",\r\n  defaultErrorMessage: \"The :input must be a valid IPv4 address\",\r\n  async validate(value: any, context) {\r\n    if (isIP(value) === 4) {\r\n      return VALID_RULE;\r\n    }\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * IPv6 rule - validates IPv6 address\r\n */\r\nexport const ip6Rule: SchemaRule = {\r\n  name: \"ip6\",\r\n  defaultErrorMessage: \"The :input must be a valid IPv6 address\",\r\n  async validate(value: any, context) {\r\n    if (isIP(value) === 6) {\r\n      return VALID_RULE;\r\n    }\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n"],"mappings":";;;;;;;;AAOA,MAAa,SAAqB;CAChC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,KAAK,KAAK,GACZ,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,UAAsB;CACjC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,KAAK,KAAK,MAAM,GAClB,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,UAAsB;CACjC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,KAAK,KAAK,MAAM,GAClB,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF"}

package/esm/rules/string/matches.d.mts

@@ -0,0 +1,12 @@
+import { SchemaRule } from "../../types/rule-types.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/string/matches.d.ts
+/**
+ * Matches rule - value must match another field value
+ */
+declare const matchesRule: SchemaRule<{
+  field: string;
+}>;
+//#endregion
+export { matchesRule };
+//# sourceMappingURL=matches.d.mts.map

package/esm/rules/string/matches.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matches.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/string/matches.ts"],"mappings":";;;;;AAOA;cAAa,WAAA,EAAa,UAAU;EAAG,KAAK;AAAA"}

package/esm/rules/string/matches.mjs

@@ -0,0 +1,21 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+import { get } from "@mongez/reinforcements";
+
+//#region ../../@warlock.js/seal/src/rules/string/matches.ts
+/**
+* Matches rule - value must match another field value
+*/
+const matchesRule = {
+	name: "matches",
+	defaultErrorMessage: "The :input must match :field",
+	async validate(value, context) {
+		if (value === get(context.allValues, this.context.options.field)) return VALID_RULE;
+		this.context.translatableParams.field = this.context.options.field;
+		return invalidRule(this, context);
+	}
+};
+
+//#endregion
+export { matchesRule };
+//# sourceMappingURL=matches.mjs.map

package/esm/rules/string/matches.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"matches.mjs","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/string/matches.ts"],"sourcesContent":["import { get } from \"@mongez/reinforcements\";\r\nimport { invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * Matches rule - value must match another field value\r\n */\r\nexport const matchesRule: SchemaRule<{ field: string }> = {\r\n  name: \"matches\",\r\n  defaultErrorMessage: \"The :input must match :field\",\r\n  async validate(value: any, context) {\r\n    const otherFieldValue = get(context.allValues, this.context.options.field);\r\n\r\n    if (value === otherFieldValue) {\r\n      return VALID_RULE;\r\n    }\r\n\r\n    this.context.translatableParams.field = this.context.options.field;\r\n\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n"],"mappings":";;;;;;;;AAOA,MAAa,cAA6C;CACxD,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAGlC,IAAI,UAFoB,IAAI,QAAQ,WAAW,KAAK,QAAQ,QAAQ,KAExC,GAC1B,OAAO;EAGT,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,OAAO,YAAY,MAAM,OAAO;CAClC;AACF"}

package/esm/rules/string/pattern.d.mts

@@ -0,0 +1,12 @@
+import { SchemaRule } from "../../types/rule-types.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/string/pattern.d.ts
+/**
+ * Pattern rule - validates against regex pattern
+ */
+declare const patternRule: SchemaRule<{
+  pattern: RegExp;
+}>;
+//#endregion
+export { patternRule };
+//# sourceMappingURL=pattern.d.mts.map

package/esm/rules/string/pattern.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/string/pattern.ts"],"mappings":";;;;;AAMA;cAAa,WAAA,EAAa,UAAU;EAAG,OAAA,EAAS,MAAA;AAAA"}