@warlock.js/notifications 4.16.0 → 5.0.0

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

@@ -0,0 +1,97 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+import { isObject, isPlainObject } from "../../../../node_modules/@mongez/supportive-is/esm/index.mjs";
+
+//#region ../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);
+	}
+};
+/**
+* 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, stringRule };
+//# sourceMappingURL=type-rules.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"type-rules.mjs","names":[],"sources":["../../../../../../../../../../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;;;;AAmBA,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/seal/src/rules/common/unknown-key.mjs

@@ -0,0 +1,25 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+
+//#region ../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/seal/src/rules/common/unknown-key.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"unknown-key.mjs","names":[],"sources":["../../../../../../../../../../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,CAAC,CAAC,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/seal/src/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 ../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/seal/src/rules/conditional/forbidden-if-rules.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"forbidden-if-rules.mjs","names":[],"sources":["../../../../../../../../../../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/seal/src/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/seal/src/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 ../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/seal/src/rules/conditional/present-if-rules.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"present-if-rules.mjs","names":[],"sources":["../../../../../../../../../../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/seal/src/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 ../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/seal/src/rules/conditional/present-unless-rules.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"present-unless-rules.mjs","names":[],"sources":["../../../../../../../../../../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/seal/src/rules/conditional/present-with-rules.mjs

@@ -0,0 +1,76 @@
+import { get } from "../../../../node_modules/@mongez/reinforcements/esm/object/get.mjs";
+import "../../../../node_modules/@mongez/reinforcements/esm/index.mjs";
+import { getFieldValue } from "../../helpers/get-field-value.mjs";
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+
+//#region ../seal/src/rules/conditional/present-with-rules.ts
+/**
+* Present with rule - field must be present if another field is present
+* Supports both global and sibling scope
+*/
+const presentWithRule = {
+	name: "presentWith",
+	description: "The field must be present if another field is present",
+	sortOrder: -2,
+	requiresValue: false,
+	defaultErrorMessage: "The :input field must be present",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		if (value === void 0 && fieldValue !== void 0) {
+			this.context.translatableParams.field = this.context.options.field;
+			return invalidRule(this, context);
+		}
+		return VALID_RULE;
+	}
+};
+/**
+* Present with all rule - field must be present if all specified fields are present
+* Supports both global and sibling scope
+*/
+const presentWithAllRule = {
+	name: "presentWithAll",
+	description: "The field must be present if all specified fields are present",
+	sortOrder: -2,
+	requiresValue: false,
+	defaultErrorMessage: "The :input field must be present",
+	async validate(value, context) {
+		const { fields, scope = "global" } = this.context.options;
+		const source = scope === "sibling" ? context.parent : context.allValues;
+		const allPresent = fields.every((field) => get(source, field) !== void 0);
+		if (value === void 0 && allPresent) {
+			fields.forEach((field) => {
+				this.context.translatableParams.field = field;
+			});
+			return invalidRule(this, context);
+		}
+		return VALID_RULE;
+	}
+};
+/**
+* Present with any rule - field must be present if any of the specified fields is present
+* Supports both global and sibling scope
+*/
+const presentWithAnyRule = {
+	name: "presentWithAny",
+	description: "The field must be present if any of the specified fields is present",
+	sortOrder: -2,
+	requiresValue: false,
+	defaultErrorMessage: "The :input field must be present",
+	async validate(value, context) {
+		const { fields, scope = "global" } = this.context.options;
+		const source = scope === "sibling" ? context.parent : context.allValues;
+		const anyPresent = fields.some((field) => get(source, field) !== void 0);
+		if (value === void 0 && anyPresent) {
+			fields.forEach((field) => {
+				this.context.translatableParams.field = field;
+			});
+			return invalidRule(this, context);
+		}
+		return VALID_RULE;
+	}
+};
+
+//#endregion
+export { presentWithAllRule, presentWithAnyRule, presentWithRule };
+//# sourceMappingURL=present-with-rules.mjs.map

package/esm/seal/src/rules/conditional/present-with-rules.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"present-with-rules.mjs","names":[],"sources":["../../../../../../../../../../seal/src/rules/conditional/present-with-rules.ts"],"sourcesContent":["import { get } from \"@mongez/reinforcements\";\r\nimport { getFieldValue, invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * Present with rule - field must be present if another field is present\r\n * Supports both global and sibling scope\r\n */\r\nexport const presentWithRule: SchemaRule<{\r\n  field: string;\r\n  scope?: \"global\" | \"sibling\";\r\n}> = {\r\n  name: \"presentWith\",\r\n  description: \"The field must be present if another field is present\",\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    // The field must be present if the other field is present\r\n    if (value === undefined && fieldValue !== undefined) {\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 with all rule - field must be present if all specified fields are present\r\n * Supports both global and sibling scope\r\n */\r\nexport const presentWithAllRule: SchemaRule<{\r\n  fields: string[];\r\n  scope?: \"global\" | \"sibling\";\r\n}> = {\r\n  name: \"presentWithAll\",\r\n  description: \"The field must be present if all specified fields are present\",\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 { fields, scope = \"global\" } = this.context.options;\r\n    const source = scope === \"sibling\" ? context.parent : context.allValues;\r\n\r\n    // Check if all fields are present\r\n    const allPresent = fields.every((field) => get(source, field) !== undefined);\r\n\r\n    // Field must be present if all other fields are present\r\n    if (value === undefined && allPresent) {\r\n      fields.forEach((field) => {\r\n        this.context.translatableParams.field = field;\r\n      });\r\n\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 with any rule - field must be present if any of the specified fields is present\r\n * Supports both global and sibling scope\r\n */\r\nexport const presentWithAnyRule: SchemaRule<{\r\n  fields: string[];\r\n  scope?: \"global\" | \"sibling\";\r\n}> = {\r\n  name: \"presentWithAny\",\r\n  description: \"The field must be present if any of the specified fields is present\",\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 { fields, scope = \"global\" } = this.context.options;\r\n    const source = scope === \"sibling\" ? context.parent : context.allValues;\r\n\r\n    // Check if any field is present\r\n    const anyPresent = fields.some((field) => get(source, field) !== undefined);\r\n\r\n    // Field must be present if any other field is present\r\n    if (value === undefined && anyPresent) {\r\n      fields.forEach((field) => {\r\n        this.context.translatableParams.field = field;\r\n      });\r\n\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n"],"mappings":";;;;;;;;;;;AAQA,MAAa,kBAGR;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,eAAe,QAAW;GACnD,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,EAAE,QAAQ,QAAQ,aAAa,KAAK,QAAQ;EAClD,MAAM,SAAS,UAAU,YAAY,QAAQ,SAAS,QAAQ;EAG9D,MAAM,aAAa,OAAO,OAAO,UAAU,IAAI,QAAQ,KAAK,MAAM,MAAS;EAG3E,IAAI,UAAU,UAAa,YAAY;GACrC,OAAO,SAAS,UAAU;IACxB,KAAK,QAAQ,mBAAmB,QAAQ;GAC1C,CAAC;GAED,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,EAAE,QAAQ,QAAQ,aAAa,KAAK,QAAQ;EAClD,MAAM,SAAS,UAAU,YAAY,QAAQ,SAAS,QAAQ;EAG9D,MAAM,aAAa,OAAO,MAAM,UAAU,IAAI,QAAQ,KAAK,MAAM,MAAS;EAG1E,IAAI,UAAU,UAAa,YAAY;GACrC,OAAO,SAAS,UAAU;IACxB,KAAK,QAAQ,mBAAmB,QAAQ;GAC1C,CAAC;GAED,OAAO,YAAY,MAAM,OAAO;EAClC;EAEA,OAAO;CACT;AACF"}

package/esm/seal/src/rules/conditional/present-without-rules.mjs

@@ -0,0 +1,76 @@
+import { get } from "../../../../node_modules/@mongez/reinforcements/esm/object/get.mjs";
+import "../../../../node_modules/@mongez/reinforcements/esm/index.mjs";
+import { getFieldValue } from "../../helpers/get-field-value.mjs";
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+
+//#region ../seal/src/rules/conditional/present-without-rules.ts
+/**
+* Present without rule - field must be present if another field is missing
+* Supports both global and sibling scope
+*/
+const presentWithoutRule = {
+	name: "presentWithout",
+	description: "The field must be present if another field is missing",
+	sortOrder: -2,
+	requiresValue: false,
+	defaultErrorMessage: "The :input field must be present",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		if (value === void 0 && fieldValue === void 0) {
+			this.context.translatableParams.field = this.context.options.field;
+			return invalidRule(this, context);
+		}
+		return VALID_RULE;
+	}
+};
+/**
+* Present without all rule - field must be present if all specified fields are missing
+* Supports both global and sibling scope
+*/
+const presentWithoutAllRule = {
+	name: "presentWithoutAll",
+	description: "The field must be present if all specified fields are missing",
+	sortOrder: -2,
+	requiresValue: false,
+	defaultErrorMessage: "The :input field must be present",
+	async validate(value, context) {
+		const { fields, scope = "global" } = this.context.options;
+		const source = scope === "sibling" ? context.parent : context.allValues;
+		const allMissing = fields.every((field) => get(source, field) === void 0);
+		if (value === void 0 && allMissing) {
+			fields.forEach((field) => {
+				this.context.translatableParams.field = field;
+			});
+			return invalidRule(this, context);
+		}
+		return VALID_RULE;
+	}
+};
+/**
+* Present without any rule - field must be present if any of the specified fields is missing
+* Supports both global and sibling scope
+*/
+const presentWithoutAnyRule = {
+	name: "presentWithoutAny",
+	description: "The field must be present if any of the specified fields is missing",
+	sortOrder: -2,
+	requiresValue: false,
+	defaultErrorMessage: "The :input field must be present",
+	async validate(value, context) {
+		const { fields, scope = "global" } = this.context.options;
+		const source = scope === "sibling" ? context.parent : context.allValues;
+		const anyMissing = fields.some((field) => get(source, field) === void 0);
+		if (value === void 0 && anyMissing) {
+			fields.forEach((field) => {
+				this.context.translatableParams.field = field;
+			});
+			return invalidRule(this, context);
+		}
+		return VALID_RULE;
+	}
+};
+
+//#endregion
+export { presentWithoutAllRule, presentWithoutAnyRule, presentWithoutRule };
+//# sourceMappingURL=present-without-rules.mjs.map

package/esm/seal/src/rules/conditional/present-without-rules.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"present-without-rules.mjs","names":[],"sources":["../../../../../../../../../../seal/src/rules/conditional/present-without-rules.ts"],"sourcesContent":["import { get } from \"@mongez/reinforcements\";\r\nimport { getFieldValue, invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * Present without rule - field must be present if another field is missing\r\n * Supports both global and sibling scope\r\n */\r\nexport const presentWithoutRule: SchemaRule<{\r\n  field: string;\r\n  scope?: \"global\" | \"sibling\";\r\n}> = {\r\n  name: \"presentWithout\",\r\n  description: \"The field must be present if another field is missing\",\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 missing\r\n    if (value === undefined && fieldValue === undefined) {\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 without all rule - field must be present if all specified fields are missing\r\n * Supports both global and sibling scope\r\n */\r\nexport const presentWithoutAllRule: SchemaRule<{\r\n  fields: string[];\r\n  scope?: \"global\" | \"sibling\";\r\n}> = {\r\n  name: \"presentWithoutAll\",\r\n  description: \"The field must be present if all specified fields are missing\",\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 { fields, scope = \"global\" } = this.context.options;\r\n    const source = scope === \"sibling\" ? context.parent : context.allValues;\r\n\r\n    // Check if all fields are missing\r\n    const allMissing = fields.every((field) => get(source, field) === undefined);\r\n\r\n    // Field must be present if all other fields are missing\r\n    if (value === undefined && allMissing) {\r\n      fields.forEach((field) => {\r\n        this.context.translatableParams.field = field;\r\n      });\r\n\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 without any rule - field must be present if any of the specified fields is missing\r\n * Supports both global and sibling scope\r\n */\r\nexport const presentWithoutAnyRule: SchemaRule<{\r\n  fields: string[];\r\n  scope?: \"global\" | \"sibling\";\r\n}> = {\r\n  name: \"presentWithoutAny\",\r\n  description: \"The field must be present if any of the specified fields is missing\",\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 { fields, scope = \"global\" } = this.context.options;\r\n    const source = scope === \"sibling\" ? context.parent : context.allValues;\r\n\r\n    // Check if any field is missing\r\n    const anyMissing = fields.some((field) => get(source, field) === undefined);\r\n\r\n    // Field must be present if any other field is missing\r\n    if (value === undefined && anyMissing) {\r\n      fields.forEach((field) => {\r\n        this.context.translatableParams.field = field;\r\n      });\r\n\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n"],"mappings":";;;;;;;;;;;AAQA,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,eAAe,QAAW;GACnD,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;GAC7D,OAAO,YAAY,MAAM,OAAO;EAClC;EAEA,OAAO;CACT;AACF;;;;;AAMA,MAAa,wBAGR;CACH,MAAM;CACN,aAAa;CACb,WAAW;CACX,eAAe;CACf,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,EAAE,QAAQ,QAAQ,aAAa,KAAK,QAAQ;EAClD,MAAM,SAAS,UAAU,YAAY,QAAQ,SAAS,QAAQ;EAG9D,MAAM,aAAa,OAAO,OAAO,UAAU,IAAI,QAAQ,KAAK,MAAM,MAAS;EAG3E,IAAI,UAAU,UAAa,YAAY;GACrC,OAAO,SAAS,UAAU;IACxB,KAAK,QAAQ,mBAAmB,QAAQ;GAC1C,CAAC;GAED,OAAO,YAAY,MAAM,OAAO;EAClC;EAEA,OAAO;CACT;AACF;;;;;AAMA,MAAa,wBAGR;CACH,MAAM;CACN,aAAa;CACb,WAAW;CACX,eAAe;CACf,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,EAAE,QAAQ,QAAQ,aAAa,KAAK,QAAQ;EAClD,MAAM,SAAS,UAAU,YAAY,QAAQ,SAAS,QAAQ;EAG9D,MAAM,aAAa,OAAO,MAAM,UAAU,IAAI,QAAQ,KAAK,MAAM,MAAS;EAG1E,IAAI,UAAU,UAAa,YAAY;GACrC,OAAO,SAAS,UAAU;IACxB,KAAK,QAAQ,mBAAmB,QAAQ;GAC1C,CAAC;GAED,OAAO,YAAY,MAAM,OAAO;EAClC;EAEA,OAAO;CACT;AACF"}