@warlock.js/seal 4.0.174 → 4.1.1

package/esm/rules/common/type-rules.mjs

@@ -0,0 +1,112 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+import { isObject, isPlainObject } from "@mongez/supportive-is";
+
+//#region ../../@warlock.js/seal/src/rules/common/type-rules.ts
+/**
+* String rule - validates string type
+*/
+const stringRule = {
+	name: "string",
+	defaultErrorMessage: "The :input must be a string",
+	async validate(value, context) {
+		if (typeof value === "string") return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+/**
+* Number rule - validates number type
+*/
+const numberRule = {
+	name: "number",
+	defaultErrorMessage: "The :input must be a number",
+	async validate(value, context) {
+		if (typeof value === "number") return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+/**
+* Boolean rule - validates boolean type
+*/
+const booleanRule = {
+	name: "boolean",
+	defaultErrorMessage: "The :input must be a boolean",
+	async validate(value, context) {
+		if (typeof value === "boolean") return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+/**
+* Int rule - validates integer type
+*/
+const intRule = {
+	name: "int",
+	defaultErrorMessage: "The :input must be an integer",
+	async validate(value, context) {
+		if (Number.isInteger(value)) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+/**
+* Float rule - validates float type
+*/
+const floatRule = {
+	name: "float",
+	defaultErrorMessage: "The :input must be a float",
+	async validate(value, context) {
+		if (Number.isFinite(value) && !Number.isInteger(value)) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+/**
+* Scalar rule - validates scalar value (string, number, or boolean)
+*/
+const scalarRule = {
+	name: "scalar",
+	defaultErrorMessage: "The :input must be a scalar value",
+	async validate(value, context) {
+		if ([
+			"string",
+			"number",
+			"boolean"
+		].includes(typeof value)) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+/**
+* Object rule - validates object type
+*/
+const objectRule = {
+	name: "object",
+	defaultErrorMessage: "The :input must be an object",
+	async validate(value, context) {
+		if (!!isObject(value) && value !== null) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+/**
+* Object rule - validates object type
+*/
+const plainObjectRule = {
+	name: "plainObject",
+	defaultErrorMessage: "The :input must be an object",
+	async validate(value, context) {
+		if (!!isPlainObject(value) && value !== null) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+/**
+* Array rule - validates array type
+*/
+const arrayRule = {
+	name: "array",
+	defaultErrorMessage: "The :input must be an array",
+	async validate(value, context) {
+		if (Array.isArray(value)) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+
+//#endregion
+export { arrayRule, booleanRule, floatRule, intRule, numberRule, objectRule, plainObjectRule, scalarRule, stringRule };
+//# sourceMappingURL=type-rules.mjs.map

package/esm/rules/common/type-rules.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-rules.mjs","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/common/type-rules.ts"],"sourcesContent":["import { isObject, isPlainObject } from \"@mongez/supportive-is\";\r\nimport { invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * String rule - validates string type\r\n */\r\nexport const stringRule: SchemaRule = {\r\n  name: \"string\",\r\n  defaultErrorMessage: \"The :input must be a string\",\r\n  async validate(value: any, context) {\r\n    if (typeof value === \"string\") {\r\n      return VALID_RULE;\r\n    }\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * Number rule - validates number type\r\n */\r\nexport const numberRule: SchemaRule = {\r\n  name: \"number\",\r\n  defaultErrorMessage: \"The :input must be a number\",\r\n  async validate(value: any, context) {\r\n    if (typeof value === \"number\") {\r\n      return VALID_RULE;\r\n    }\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * Boolean rule - validates boolean type\r\n */\r\nexport const booleanRule: SchemaRule = {\r\n  name: \"boolean\",\r\n  defaultErrorMessage: \"The :input must be a boolean\",\r\n  async validate(value: any, context) {\r\n    if (typeof value === \"boolean\") {\r\n      return VALID_RULE;\r\n    }\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * Int rule - validates integer type\r\n */\r\nexport const intRule: SchemaRule = {\r\n  name: \"int\",\r\n  defaultErrorMessage: \"The :input must be an integer\",\r\n  async validate(value: any, context) {\r\n    if (Number.isInteger(value)) {\r\n      return VALID_RULE;\r\n    }\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * Float rule - validates float type\r\n */\r\nexport const floatRule: SchemaRule = {\r\n  name: \"float\",\r\n  defaultErrorMessage: \"The :input must be a float\",\r\n  async validate(value: any, context) {\r\n    if (Number.isFinite(value) && !Number.isInteger(value)) {\r\n      return VALID_RULE;\r\n    }\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * Scalar rule - validates scalar value (string, number, or boolean)\r\n */\r\nexport const scalarRule: SchemaRule = {\r\n  name: \"scalar\",\r\n  defaultErrorMessage: \"The :input must be a scalar value\",\r\n  async validate(value: any, context) {\r\n    if ([\"string\", \"number\", \"boolean\"].includes(typeof value)) {\r\n      return VALID_RULE;\r\n    }\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * Object rule - validates object type\r\n */\r\nexport const objectRule: SchemaRule = {\r\n  name: \"object\",\r\n  defaultErrorMessage: \"The :input must be an object\",\r\n  async validate(value: any, context) {\r\n    if (!!isObject(value) && value !== null) {\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 * Object rule - validates object type\r\n */\r\nexport const plainObjectRule: SchemaRule = {\r\n  name: \"plainObject\",\r\n  defaultErrorMessage: \"The :input must be an object\",\r\n  async validate(value: any, context) {\r\n    if (!!isPlainObject(value) && value !== null) {\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 * Array rule - validates array type\r\n */\r\nexport const arrayRule: SchemaRule = {\r\n  name: \"array\",\r\n  defaultErrorMessage: \"The :input must be an array\",\r\n  async validate(value: any, context) {\r\n    if (Array.isArray(value)) {\r\n      return VALID_RULE;\r\n    }\r\n\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n"],"mappings":";;;;;;;;AAOA,MAAa,aAAyB;CACpC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,OAAO,UAAU,UACnB,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,aAAyB;CACpC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,OAAO,UAAU,UACnB,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,cAA0B;CACrC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,OAAO,UAAU,WACnB,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,UAAsB;CACjC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,OAAO,UAAU,KAAK,GACxB,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,YAAwB;CACnC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,OAAO,SAAS,KAAK,KAAK,CAAC,OAAO,UAAU,KAAK,GACnD,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,aAAyB;CACpC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI;GAAC;GAAU;GAAU;EAAS,EAAE,SAAS,OAAO,KAAK,GACvD,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,aAAyB;CACpC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,CAAC,CAAC,SAAS,KAAK,KAAK,UAAU,MACjC,OAAO;EAGT,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,kBAA8B;CACzC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,CAAC,CAAC,cAAc,KAAK,KAAK,UAAU,MACtC,OAAO;EAGT,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,YAAwB;CACnC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,MAAM,QAAQ,KAAK,GACrB,OAAO;EAGT,OAAO,YAAY,MAAM,OAAO;CAClC;AACF"}

package/esm/rules/common/unknown-key.d.mts

@@ -0,0 +1,14 @@
+import { Schema } from "../../types/schema-types.mjs";
+import { SchemaRule } from "../../types/rule-types.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/common/unknown-key.d.ts
+/**
+ * Unknown key rule - validates that object doesn't have unknown keys
+ */
+declare const unknownKeyRule: SchemaRule<{
+  schema: Schema;
+  allowedKeys: string[];
+}>;
+//#endregion
+export { unknownKeyRule };
+//# sourceMappingURL=unknown-key.d.mts.map

package/esm/rules/common/unknown-key.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unknown-key.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/common/unknown-key.ts"],"mappings":";;;;;;;cAMa,cAAA,EAAgB,UAAU;EACrC,MAAA,EAAQ,MAAA;EACR,WAAA;AAAA"}

package/esm/rules/common/unknown-key.mjs

@@ -0,0 +1,25 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/common/unknown-key.ts
+/**
+* Unknown key rule - validates that object doesn't have unknown keys
+*/
+const unknownKeyRule = {
+	name: "unknownKeys",
+	defaultErrorMessage: "The :input contains unknown keys: :unknownKeys",
+	async validate(value, context) {
+		const schema = this.context.options.schema;
+		const allowedKeys = [...Object.keys(schema), ...this.context.options.allowedKeys || []];
+		const unknownKeys = Object.keys(value).filter((key) => !allowedKeys.includes(key));
+		if (unknownKeys.length > 0) {
+			this.context.translationParams.unknownKeys = unknownKeys.join(", ");
+			return invalidRule(this, context);
+		}
+		return VALID_RULE;
+	}
+};
+
+//#endregion
+export { unknownKeyRule };
+//# sourceMappingURL=unknown-key.mjs.map

package/esm/rules/common/unknown-key.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"unknown-key.mjs","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/common/unknown-key.ts"],"sourcesContent":["import { invalidRule, VALID_RULE } from \"../../helpers\";\nimport type { Schema, SchemaRule } from \"../../types\";\n\n/**\n * Unknown key rule - validates that object doesn't have unknown keys\n */\nexport const unknownKeyRule: SchemaRule<{\n  schema: Schema;\n  allowedKeys: string[];\n}> = {\n  name: \"unknownKeys\",\n  defaultErrorMessage: \"The :input contains unknown keys: :unknownKeys\",\n  async validate(value: any, context) {\n    const schema = this.context.options.schema;\n    const allowedKeys = [...Object.keys(schema), ...(this.context.options.allowedKeys || [])];\n\n    const unknownKeys = Object.keys(value).filter((key) => !allowedKeys.includes(key));\n\n    if (unknownKeys.length > 0) {\n      this.context.translationParams.unknownKeys = unknownKeys.join(\", \");\n\n      return invalidRule(this, context);\n    }\n\n    return VALID_RULE;\n  },\n};\n"],"mappings":";;;;;;;AAMA,MAAa,iBAGR;CACH,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,SAAS,KAAK,QAAQ,QAAQ;EACpC,MAAM,cAAc,CAAC,GAAG,OAAO,KAAK,MAAM,GAAG,GAAI,KAAK,QAAQ,QAAQ,eAAe,CAAC,CAAE;EAExF,MAAM,cAAc,OAAO,KAAK,KAAK,EAAE,QAAQ,QAAQ,CAAC,YAAY,SAAS,GAAG,CAAC;EAEjF,IAAI,YAAY,SAAS,GAAG;GAC1B,KAAK,QAAQ,kBAAkB,cAAc,YAAY,KAAK,IAAI;GAElE,OAAO,YAAY,MAAM,OAAO;EAClC;EAEA,OAAO;CACT;AACF"}

package/esm/rules/conditional/forbidden-if-rules.d.mts

@@ -0,0 +1,58 @@
+import { SchemaRule } from "../../types/rule-types.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/conditional/forbidden-if-rules.d.ts
+/**
+ * Forbidden if rule - field is forbidden if another field equals a specific value
+ * Supports both global and sibling scope
+ */
+declare const forbiddenIfRule: SchemaRule<{
+  field: string;
+  value: any;
+  scope?: "global" | "sibling";
+}>;
+/**
+ * Forbidden if not rule - field is forbidden if another field does NOT equal a specific value
+ * Supports both global and sibling scope
+ */
+declare const forbiddenIfNotRule: SchemaRule<{
+  field: string;
+  value: any;
+  scope?: "global" | "sibling";
+}>;
+/**
+ * Forbidden if empty rule - field is forbidden if another field is empty
+ * Supports both global and sibling scope
+ */
+declare const forbiddenIfEmptyRule: SchemaRule<{
+  field: string;
+  scope?: "global" | "sibling";
+}>;
+/**
+ * Forbidden if not empty rule - field is forbidden if another field is not empty
+ * Supports both global and sibling scope
+ */
+declare const forbiddenIfNotEmptyRule: SchemaRule<{
+  field: string;
+  scope?: "global" | "sibling";
+}>;
+/**
+ * Forbidden if in rule - field is forbidden if another field's value is in the given array
+ * Supports both global and sibling scope
+ */
+declare const forbiddenIfInRule: SchemaRule<{
+  field: string;
+  values: any[];
+  scope?: "global" | "sibling";
+}>;
+/**
+ * Forbidden if not in rule - field is forbidden if another field's value is NOT in the given array
+ * Supports both global and sibling scope
+ */
+declare const forbiddenIfNotInRule: SchemaRule<{
+  field: string;
+  values: any[];
+  scope?: "global" | "sibling";
+}>;
+//#endregion
+export { forbiddenIfEmptyRule, forbiddenIfInRule, forbiddenIfNotEmptyRule, forbiddenIfNotInRule, forbiddenIfNotRule, forbiddenIfRule };
+//# sourceMappingURL=forbidden-if-rules.d.mts.map

package/esm/rules/conditional/forbidden-if-rules.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forbidden-if-rules.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/conditional/forbidden-if-rules.ts"],"mappings":";;;;;AAQA;;cAAa,eAAA,EAAiB,UAAU;EACtC,KAAA;EACA,KAAA;EACA,KAAA;AAAA;;;AAAK;AAyBP;cAAa,kBAAA,EAAoB,UAAU;EACzC,KAAA;EACA,KAAA;EACA,KAAA;AAAA;;;;AAAK;cAuBM,oBAAA,EAAsB,UAAU;EAC3C,KAAA;EACA,KAAA;AAAA;;;;;cAsBW,uBAAA,EAAyB,UAAU;EAC9C,KAAA;EACA,KAAA;AAAA;;;;;cAsBW,iBAAA,EAAmB,UAAU;EACxC,KAAA;EACA,MAAA;EACA,KAAA;AAAA;;;;;cAyBW,oBAAA,EAAsB,UAAU;EAC3C,KAAA;EACA,MAAA;EACA,KAAA;AAAA"}

package/esm/rules/conditional/forbidden-if-rules.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/conditional/forbidden-if-rules.ts
+/**
+* Forbidden if rule - field is forbidden if another field equals a specific value
+* Supports both global and sibling scope
+*/
+const forbiddenIfRule = {
+	name: "forbiddenIf",
+	description: "The field is forbidden if another field equals a specific value",
+	sortOrder: -2,
+	defaultErrorMessage: "The :input is forbidden",
+	async validate(value, context) {
+		const { value: expectedValue } = this.context.options;
+		const fieldValue = getFieldValue(this, context);
+		if (!isEmptyValue(value) && fieldValue === expectedValue) {
+			this.context.translatableParams.field = this.context.options.field;
+			this.context.translationParams.value = expectedValue;
+			return invalidRule(this, context);
+		}
+		return VALID_RULE;
+	}
+};
+/**
+* Forbidden if not rule - field is forbidden if another field does NOT equal a specific value
+* Supports both global and sibling scope
+*/
+const forbiddenIfNotRule = {
+	name: "forbiddenIfNot",
+	description: "The field is forbidden if another field does NOT equal a specific value",
+	sortOrder: -2,
+	defaultErrorMessage: "The :input is forbidden",
+	async validate(value, context) {
+		const { value: expectedValue } = this.context.options;
+		const fieldValue = getFieldValue(this, context);
+		if (!isEmptyValue(value) && fieldValue !== expectedValue) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+/**
+* Forbidden if empty rule - field is forbidden if another field is empty
+* Supports both global and sibling scope
+*/
+const forbiddenIfEmptyRule = {
+	name: "forbiddenIfEmpty",
+	description: "The field is forbidden if another field is empty",
+	sortOrder: -2,
+	defaultErrorMessage: "The :input is forbidden",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		if (!isEmptyValue(value) && isEmptyValue(fieldValue)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+/**
+* Forbidden if not empty rule - field is forbidden if another field is not empty
+* Supports both global and sibling scope
+*/
+const forbiddenIfNotEmptyRule = {
+	name: "forbiddenIfNotEmpty",
+	description: "The field is forbidden if another field is not empty",
+	sortOrder: -2,
+	defaultErrorMessage: "The :input is forbidden",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		if (!isEmptyValue(value) && !isEmptyValue(fieldValue)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+/**
+* Forbidden if in rule - field is forbidden if another field's value is in the given array
+* Supports both global and sibling scope
+*/
+const forbiddenIfInRule = {
+	name: "forbiddenIfIn",
+	description: "The field is forbidden if another field's value is in the given array",
+	sortOrder: -2,
+	defaultErrorMessage: "The :input is forbidden",
+	async validate(value, context) {
+		const { values } = this.context.options;
+		const fieldValue = getFieldValue(this, context);
+		if (!isEmptyValue(value) && values.includes(fieldValue)) {
+			this.context.translationParams.values = values.join(", ");
+			this.context.translatableParams.field = this.context.options.field;
+			return invalidRule(this, context);
+		}
+		return VALID_RULE;
+	}
+};
+/**
+* Forbidden if not in rule - field is forbidden if another field's value is NOT in the given array
+* Supports both global and sibling scope
+*/
+const forbiddenIfNotInRule = {
+	name: "forbiddenIfNotIn",
+	description: "The field is forbidden if another field's value is NOT in the given array",
+	sortOrder: -2,
+	defaultErrorMessage: "The :input is forbidden",
+	async validate(value, context) {
+		const { values } = this.context.options;
+		const fieldValue = getFieldValue(this, context);
+		if (!isEmptyValue(value) && !values.includes(fieldValue)) {
+			this.context.translationParams.values = values.join(", ");
+			this.context.translatableParams.field = this.context.options.field;
+			return invalidRule(this, context);
+		}
+		return VALID_RULE;
+	}
+};
+
+//#endregion
+export { forbiddenIfEmptyRule, forbiddenIfInRule, forbiddenIfNotEmptyRule, forbiddenIfNotInRule, forbiddenIfNotRule, forbiddenIfRule };
+//# sourceMappingURL=forbidden-if-rules.mjs.map

package/esm/rules/conditional/forbidden-if-rules.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"forbidden-if-rules.mjs","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/conditional/forbidden-if-rules.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\n/**\r\n * Forbidden if rule - field is forbidden if another field equals a specific value\r\n * Supports both global and sibling scope\r\n */\r\nexport const forbiddenIfRule: SchemaRule<{\r\n  field: string;\r\n  value: any;\r\n  scope?: \"global\" | \"sibling\";\r\n}> = {\r\n  name: \"forbiddenIf\",\r\n  description: \"The field is forbidden if another field equals a specific value\",\r\n  sortOrder: -2,\r\n  defaultErrorMessage: \"The :input is forbidden\",\r\n  async validate(value: any, context) {\r\n    const { value: expectedValue } = this.context.options;\r\n    const fieldValue = getFieldValue(this, context);\r\n\r\n    // Field is forbidden if it has a value and the other field equals the expected value\r\n    if (!isEmptyValue(value) && fieldValue === expectedValue) {\r\n      this.context.translatableParams.field = this.context.options.field;\r\n      this.context.translationParams.value = expectedValue;\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 * Forbidden if not rule - field is forbidden if another field does NOT equal a specific value\r\n * Supports both global and sibling scope\r\n */\r\nexport const forbiddenIfNotRule: SchemaRule<{\r\n  field: string;\r\n  value: any;\r\n  scope?: \"global\" | \"sibling\";\r\n}> = {\r\n  name: \"forbiddenIfNot\",\r\n  description: \"The field is forbidden if another field does NOT equal a specific value\",\r\n  sortOrder: -2,\r\n  defaultErrorMessage: \"The :input is forbidden\",\r\n  async validate(value: any, context) {\r\n    const { value: expectedValue } = this.context.options;\r\n    const fieldValue = getFieldValue(this, context);\r\n\r\n    // Field is forbidden if it has a value and the other field does NOT equal the expected value\r\n    if (!isEmptyValue(value) && fieldValue !== expectedValue) {\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 * Forbidden if empty rule - field is forbidden if another field is empty\r\n * Supports both global and sibling scope\r\n */\r\nexport const forbiddenIfEmptyRule: SchemaRule<{\r\n  field: string;\r\n  scope?: \"global\" | \"sibling\";\r\n}> = {\r\n  name: \"forbiddenIfEmpty\",\r\n  description: \"The field is forbidden if another field is empty\",\r\n  sortOrder: -2,\r\n  defaultErrorMessage: \"The :input is forbidden\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n\r\n    // Field is forbidden if it has a value and the other field is empty\r\n    if (!isEmptyValue(value) && isEmptyValue(fieldValue)) {\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 * Forbidden if not empty rule - field is forbidden if another field is not empty\r\n * Supports both global and sibling scope\r\n */\r\nexport const forbiddenIfNotEmptyRule: SchemaRule<{\r\n  field: string;\r\n  scope?: \"global\" | \"sibling\";\r\n}> = {\r\n  name: \"forbiddenIfNotEmpty\",\r\n  description: \"The field is forbidden if another field is not empty\",\r\n  sortOrder: -2,\r\n  defaultErrorMessage: \"The :input is forbidden\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n\r\n    // Field is forbidden if it has a value and the other field is not empty\r\n    if (!isEmptyValue(value) && !isEmptyValue(fieldValue)) {\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 * Forbidden if in rule - field is forbidden if another field's value is in the given array\r\n * Supports both global and sibling scope\r\n */\r\nexport const forbiddenIfInRule: SchemaRule<{\r\n  field: string;\r\n  values: any[];\r\n  scope?: \"global\" | \"sibling\";\r\n}> = {\r\n  name: \"forbiddenIfIn\",\r\n  description: \"The field is forbidden if another field's value is in the given array\",\r\n  sortOrder: -2,\r\n  defaultErrorMessage: \"The :input is forbidden\",\r\n  async validate(value: any, context) {\r\n    const { values } = this.context.options;\r\n    const fieldValue = getFieldValue(this, context);\r\n\r\n    // Field is forbidden if it has a value and the other field's value is in the array\r\n    if (!isEmptyValue(value) && values.includes(fieldValue)) {\r\n      this.context.translationParams.values = values.join(\", \");\r\n      this.context.translatableParams.field = this.context.options.field;\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 * Forbidden if not in rule - field is forbidden if another field's value is NOT in the given array\r\n * Supports both global and sibling scope\r\n */\r\nexport const forbiddenIfNotInRule: SchemaRule<{\r\n  field: string;\r\n  values: any[];\r\n  scope?: \"global\" | \"sibling\";\r\n}> = {\r\n  name: \"forbiddenIfNotIn\",\r\n  description: \"The field is forbidden if another field's value is NOT in the given array\",\r\n  sortOrder: -2,\r\n  defaultErrorMessage: \"The :input is forbidden\",\r\n  async validate(value: any, context) {\r\n    const { values } = this.context.options;\r\n    const fieldValue = getFieldValue(this, context);\r\n\r\n    // Field is forbidden if it has a value and the other field's value is NOT in the array\r\n    if (!isEmptyValue(value) && !values.includes(fieldValue)) {\r\n      this.context.translationParams.values = values.join(\", \");\r\n      this.context.translatableParams.field = this.context.options.field;\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n"],"mappings":";;;;;;;;;;AAQA,MAAa,kBAIR;CACH,MAAM;CACN,aAAa;CACb,WAAW;CACX,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,EAAE,OAAO,kBAAkB,KAAK,QAAQ;EAC9C,MAAM,aAAa,cAAc,MAAM,OAAO;EAG9C,IAAI,CAAC,aAAa,KAAK,KAAK,eAAe,eAAe;GACxD,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;GAC7D,KAAK,QAAQ,kBAAkB,QAAQ;GACvC,OAAO,YAAY,MAAM,OAAO;EAClC;EAEA,OAAO;CACT;AACF;;;;;AAMA,MAAa,qBAIR;CACH,MAAM;CACN,aAAa;CACb,WAAW;CACX,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,EAAE,OAAO,kBAAkB,KAAK,QAAQ;EAC9C,MAAM,aAAa,cAAc,MAAM,OAAO;EAG9C,IAAI,CAAC,aAAa,KAAK,KAAK,eAAe,eACzC,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;;AAMA,MAAa,uBAGR;CACH,MAAM;CACN,aAAa;CACb,WAAW;CACX,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAG9C,IAAI,CAAC,aAAa,KAAK,KAAK,aAAa,UAAU,GACjD,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;;AAMA,MAAa,0BAGR;CACH,MAAM;CACN,aAAa;CACb,WAAW;CACX,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAG9C,IAAI,CAAC,aAAa,KAAK,KAAK,CAAC,aAAa,UAAU,GAClD,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;;AAMA,MAAa,oBAIR;CACH,MAAM;CACN,aAAa;CACb,WAAW;CACX,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,EAAE,WAAW,KAAK,QAAQ;EAChC,MAAM,aAAa,cAAc,MAAM,OAAO;EAG9C,IAAI,CAAC,aAAa,KAAK,KAAK,OAAO,SAAS,UAAU,GAAG;GACvD,KAAK,QAAQ,kBAAkB,SAAS,OAAO,KAAK,IAAI;GACxD,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;GAC7D,OAAO,YAAY,MAAM,OAAO;EAClC;EAEA,OAAO;CACT;AACF;;;;;AAMA,MAAa,uBAIR;CACH,MAAM;CACN,aAAa;CACb,WAAW;CACX,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,EAAE,WAAW,KAAK,QAAQ;EAChC,MAAM,aAAa,cAAc,MAAM,OAAO;EAG9C,IAAI,CAAC,aAAa,KAAK,KAAK,CAAC,OAAO,SAAS,UAAU,GAAG;GACxD,KAAK,QAAQ,kBAAkB,SAAS,OAAO,KAAK,IAAI;GACxD,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;GAC7D,OAAO,YAAY,MAAM,OAAO;EAClC;EAEA,OAAO;CACT;AACF"}

package/esm/rules/conditional/index.mjs

@@ -0,0 +1,12 @@
+import { requiredIfAllEmptyRule, requiredIfAllNotEmptyRule, requiredIfAnyEmptyRule, requiredIfAnyNotEmptyRule, requiredIfEmptyRule, requiredIfInRule, requiredIfNotEmptyRule, requiredIfNotInRule, requiredIfRule } from "./required-if-rules.mjs";
+import { requiredUnlessRule } from "./required-unless-rules.mjs";
+import { requiredWhenRule } from "./required-when-rule.mjs";
+import { requiredWithAllRule, requiredWithAnyRule, requiredWithRule } from "./required-with-rules.mjs";
+import { requiredWithoutAllRule, requiredWithoutAnyRule, requiredWithoutRule } from "./required-without-rules.mjs";
+import { presentIfEmptyRule, presentIfInRule, presentIfNotEmptyRule, presentIfNotInRule, presentIfRule } from "./present-if-rules.mjs";
+import { presentUnlessRule } from "./present-unless-rules.mjs";
+import { presentWithAllRule, presentWithAnyRule, presentWithRule } from "./present-with-rules.mjs";
+import { presentWithoutAllRule, presentWithoutAnyRule, presentWithoutRule } from "./present-without-rules.mjs";
+import { forbiddenIfEmptyRule, forbiddenIfInRule, forbiddenIfNotEmptyRule, forbiddenIfNotInRule, forbiddenIfNotRule, forbiddenIfRule } from "./forbidden-if-rules.mjs";
+
+export {  };

package/esm/rules/conditional/present-if-rules.d.mts

@@ -0,0 +1,49 @@
+import { SchemaRule } from "../../types/rule-types.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/conditional/present-if-rules.d.ts
+/**
+ * Present if rule - field must be present if another field equals a specific value
+ * Supports both global and sibling scope
+ */
+declare const presentIfRule: SchemaRule<{
+  field: string;
+  value: any;
+  scope?: "global" | "sibling";
+}>;
+/**
+ * Present if empty rule - field must be present if another field is empty
+ * Supports both global and sibling scope
+ */
+declare const presentIfEmptyRule: SchemaRule<{
+  field: string;
+  scope?: "global" | "sibling";
+}>;
+/**
+ * Present if not empty rule - field must be present if another field is not empty
+ * Supports both global and sibling scope
+ */
+declare const presentIfNotEmptyRule: SchemaRule<{
+  field: string;
+  scope?: "global" | "sibling";
+}>;
+/**
+ * Present if in rule - field must be present if another field's value is in the given array
+ * Supports both global and sibling scope
+ */
+declare const presentIfInRule: SchemaRule<{
+  field: string;
+  values: any[];
+  scope?: "global" | "sibling";
+}>;
+/**
+ * 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
+ */
+declare const presentIfNotInRule: SchemaRule<{
+  field: string;
+  values: any[];
+  scope?: "global" | "sibling";
+}>;
+//#endregion
+export { presentIfEmptyRule, presentIfInRule, presentIfNotEmptyRule, presentIfNotInRule, presentIfRule };
+//# sourceMappingURL=present-if-rules.d.mts.map

package/esm/rules/conditional/present-if-rules.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"present-if-rules.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/conditional/present-if-rules.ts"],"mappings":";;;;;AAQA;;cAAa,aAAA,EAAe,UAAU;EACpC,KAAA;EACA,KAAA;EACA,KAAA;AAAA;;;AAAK;AA0BP;cAAa,kBAAA,EAAoB,UAAU;EACzC,KAAA;EACA,KAAA;AAAA;;;;AAAK;cAuBM,qBAAA,EAAuB,UAAU;EAC5C,KAAA;EACA,KAAA;AAAA;;;;;cAuBW,eAAA,EAAiB,UAAU;EACtC,KAAA;EACA,MAAA;EACA,KAAA;AAAA;;;;;cAwBW,kBAAA,EAAoB,UAAU;EACzC,KAAA;EACA,MAAA;EACA,KAAA;AAAA"}

package/esm/rules/conditional/present-if-rules.mjs

@@ -0,0 +1,97 @@
+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/conditional/present-if-rules.ts
+/**
+* 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(this, context);
+		if (value === void 0 && fieldValue === expectedValue) {
+			this.context.translationParams.value = expectedValue;
+			this.context.translatableParams.field = this.context.options.field;
+			return invalidRule(this, context);
+		}
+		return 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(this, context);
+		if (value === void 0 && isEmptyValue(fieldValue)) return invalidRule(this, context);
+		return 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(this, context);
+		if (value === void 0 && !isEmptyValue(fieldValue)) return invalidRule(this, context);
+		return 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(this, context);
+		if (value === void 0 && values.includes(fieldValue)) return invalidRule(this, context);
+		return 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(this, context);
+		if (value === void 0 && !values.includes(fieldValue)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+
+//#endregion
+export { presentIfEmptyRule, presentIfInRule, presentIfNotEmptyRule, presentIfNotInRule, presentIfRule };
+//# sourceMappingURL=present-if-rules.mjs.map

package/esm/rules/conditional/present-if-rules.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"present-if-rules.mjs","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/conditional/present-if-rules.ts"],"sourcesContent":["import { getFieldValue, invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\nimport { isEmptyValue } from \"./../../helpers/is-empty-value\";\r\n\r\n/**\r\n * Present if rule - field must be present if another field equals a specific value\r\n * Supports both global and sibling scope\r\n */\r\nexport const presentIfRule: SchemaRule<{\r\n  field: string;\r\n  value: any;\r\n  scope?: \"global\" | \"sibling\";\r\n}> = {\r\n  name: \"presentIf\",\r\n  description: \"The field must be present if another field equals a specific value\",\r\n  sortOrder: -2,\r\n  requiresValue: false,\r\n  defaultErrorMessage: \"The :input field must be present\",\r\n  async validate(value: any, context) {\r\n    const { value: expectedValue } = this.context.options;\r\n    const fieldValue = getFieldValue(this, context);\r\n\r\n    // Field must be present if the other field equals the expected value\r\n    if (value === undefined && fieldValue === expectedValue) {\r\n      this.context.translationParams.value = expectedValue;\r\n      this.context.translatableParams.field = this.context.options.field;\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 * Present if empty rule - field must be present if another field is empty\r\n * Supports both global and sibling scope\r\n */\r\nexport const presentIfEmptyRule: SchemaRule<{\r\n  field: string;\r\n  scope?: \"global\" | \"sibling\";\r\n}> = {\r\n  name: \"presentIfEmpty\",\r\n  description: \"The field must be present if another field is empty\",\r\n  sortOrder: -2,\r\n  requiresValue: false,\r\n  defaultErrorMessage: \"The :input field must be present\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n\r\n    // Field must be present if the other field is empty\r\n    if (value === undefined && isEmptyValue(fieldValue)) {\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 * Present if not empty rule - field must be present if another field is not empty\r\n * Supports both global and sibling scope\r\n */\r\nexport const presentIfNotEmptyRule: SchemaRule<{\r\n  field: string;\r\n  scope?: \"global\" | \"sibling\";\r\n}> = {\r\n  name: \"presentIfNotEmpty\",\r\n  description: \"The field must be present if another field is not empty\",\r\n  sortOrder: -2,\r\n  requiresValue: false,\r\n  defaultErrorMessage: \"The :input field must be present\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n\r\n    // Field must be present if the other field is not empty\r\n    if (value === undefined && !isEmptyValue(fieldValue)) {\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 * Present if in rule - field must be present if another field's value is in the given array\r\n * Supports both global and sibling scope\r\n */\r\nexport const presentIfInRule: SchemaRule<{\r\n  field: string;\r\n  values: any[];\r\n  scope?: \"global\" | \"sibling\";\r\n}> = {\r\n  name: \"presentIfIn\",\r\n  description: \"The field must be present if another field's value is in the given array\",\r\n  sortOrder: -2,\r\n  requiresValue: false,\r\n  defaultErrorMessage: \"The :input field must be present\",\r\n  async validate(value: any, context) {\r\n    const { values } = this.context.options;\r\n    const fieldValue = getFieldValue(this, context);\r\n\r\n    // Field must be present if the other field's value is in the array\r\n    if (value === undefined && values.includes(fieldValue)) {\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 * Present if not in rule - field must be present if another field's value is NOT in the given array\r\n * Supports both global and sibling scope\r\n */\r\nexport const presentIfNotInRule: SchemaRule<{\r\n  field: string;\r\n  values: any[];\r\n  scope?: \"global\" | \"sibling\";\r\n}> = {\r\n  name: \"presentIfNotIn\",\r\n  description: \"The field must be present if another field's value is NOT in the given array\",\r\n  sortOrder: -2,\r\n  requiresValue: false,\r\n  defaultErrorMessage: \"The :input field must be present\",\r\n  async validate(value: any, context) {\r\n    const { values } = this.context.options;\r\n    const fieldValue = getFieldValue(this, context);\r\n\r\n    // Field must be present if the other field's value is NOT in the array\r\n    if (value === undefined && !values.includes(fieldValue)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n"],"mappings":";;;;;;;;;;AAQA,MAAa,gBAIR;CACH,MAAM;CACN,aAAa;CACb,WAAW;CACX,eAAe;CACf,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,EAAE,OAAO,kBAAkB,KAAK,QAAQ;EAC9C,MAAM,aAAa,cAAc,MAAM,OAAO;EAG9C,IAAI,UAAU,UAAa,eAAe,eAAe;GACvD,KAAK,QAAQ,kBAAkB,QAAQ;GACvC,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;GAC7D,OAAO,YAAY,MAAM,OAAO;EAClC;EAEA,OAAO;CACT;AACF;;;;;AAMA,MAAa,qBAGR;CACH,MAAM;CACN,aAAa;CACb,WAAW;CACX,eAAe;CACf,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAG9C,IAAI,UAAU,UAAa,aAAa,UAAU,GAChD,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;;AAMA,MAAa,wBAGR;CACH,MAAM;CACN,aAAa;CACb,WAAW;CACX,eAAe;CACf,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAG9C,IAAI,UAAU,UAAa,CAAC,aAAa,UAAU,GACjD,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;;AAMA,MAAa,kBAIR;CACH,MAAM;CACN,aAAa;CACb,WAAW;CACX,eAAe;CACf,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,EAAE,WAAW,KAAK,QAAQ;EAChC,MAAM,aAAa,cAAc,MAAM,OAAO;EAG9C,IAAI,UAAU,UAAa,OAAO,SAAS,UAAU,GACnD,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;;AAMA,MAAa,qBAIR;CACH,MAAM;CACN,aAAa;CACb,WAAW;CACX,eAAe;CACf,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,EAAE,WAAW,KAAK,QAAQ;EAChC,MAAM,aAAa,cAAc,MAAM,OAAO;EAG9C,IAAI,UAAU,UAAa,CAAC,OAAO,SAAS,UAAU,GACpD,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF"}

package/esm/rules/conditional/present-unless-rules.d.mts

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

package/esm/rules/conditional/present-unless-rules.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"present-unless-rules.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/conditional/present-unless-rules.ts"],"mappings":";;;;;AAOA;;cAAa,iBAAA,EAAmB,UAAU;EACxC,KAAA;EACA,KAAA;EACA,KAAA;AAAA"}

package/esm/rules/conditional/present-unless-rules.mjs

@@ -0,0 +1,30 @@
+import { getFieldValue } from "../../helpers/get-field-value.mjs";
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/conditional/present-unless-rules.ts
+/**
+* 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(this, context);
+		if (value === void 0 && fieldValue !== expectedValue) {
+			this.context.translationParams.value = expectedValue;
+			this.context.translatableParams.field = this.context.options.field;
+			return invalidRule(this, context);
+		}
+		return VALID_RULE;
+	}
+};
+
+//#endregion
+export { presentUnlessRule };
+//# sourceMappingURL=present-unless-rules.mjs.map

package/esm/rules/conditional/present-unless-rules.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"present-unless-rules.mjs","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/conditional/present-unless-rules.ts"],"sourcesContent":["import { getFieldValue, invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * Present unless rule - field must be present unless another field equals a specific value\r\n * Supports both global and sibling scope\r\n */\r\nexport const presentUnlessRule: SchemaRule<{\r\n  field: string;\r\n  value: any;\r\n  scope?: \"global\" | \"sibling\";\r\n}> = {\r\n  name: \"presentUnless\",\r\n  description: \"The field must be present unless another field equals a specific value\",\r\n  sortOrder: -2,\r\n  requiresValue: false,\r\n  defaultErrorMessage: \"The :input field must be present\",\r\n  async validate(value: any, context) {\r\n    const { value: expectedValue } = this.context.options;\r\n    const fieldValue = getFieldValue(this, context);\r\n\r\n    // Field must be present unless the other field equals the expected value\r\n    if (value === undefined && fieldValue !== expectedValue) {\r\n      this.context.translationParams.value = expectedValue;\r\n      this.context.translatableParams.field = this.context.options.field;\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n"],"mappings":";;;;;;;;;AAOA,MAAa,oBAIR;CACH,MAAM;CACN,aAAa;CACb,WAAW;CACX,eAAe;CACf,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,EAAE,OAAO,kBAAkB,KAAK,QAAQ;EAC9C,MAAM,aAAa,cAAc,MAAM,OAAO;EAG9C,IAAI,UAAU,UAAa,eAAe,eAAe;GACvD,KAAK,QAAQ,kBAAkB,QAAQ;GACvC,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;GAC7D,OAAO,YAAY,MAAM,OAAO;EAClC;EAEA,OAAO;CACT;AACF"}

package/esm/rules/conditional/present-with-rules.d.mts

@@ -0,0 +1,30 @@
+import { SchemaRule } from "../../types/rule-types.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/conditional/present-with-rules.d.ts
+/**
+ * Present with rule - field must be present if another field is present
+ * Supports both global and sibling scope
+ */
+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
+ */
+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
+ */
+declare const presentWithAnyRule: SchemaRule<{
+  fields: string[];
+  scope?: "global" | "sibling";
+}>;
+//#endregion
+export { presentWithAllRule, presentWithAnyRule, presentWithRule };
+//# sourceMappingURL=present-with-rules.d.mts.map

package/esm/rules/conditional/present-with-rules.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"present-with-rules.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/conditional/present-with-rules.ts"],"mappings":";;;;;AAQA;;cAAa,eAAA,EAAiB,UAAU;EACtC,KAAA;EACA,KAAA;AAAA;;;AAAK;AAwBP;cAAa,kBAAA,EAAoB,UAAU;EACzC,MAAA;EACA,KAAA;AAAA;;;;AAAK;cA+BM,kBAAA,EAAoB,UAAU;EACzC,MAAA;EACA,KAAA;AAAA"}