@warlock.js/seal 4.0.174 → 4.1.1

package/esm/validators/number-validator.d.mts

@@ -0,0 +1,170 @@
+import { JsonSchemaResult, JsonSchemaTarget } from "../standard-schema/json-schema.mjs";
+import { PrimitiveValidator } from "./primitive-validator.mjs";
+
+//#region ../../@warlock.js/seal/src/validators/number-validator.d.ts
+/**
+ * Number validator class - base for Int and Float validators
+ */
+declare class NumberValidator extends PrimitiveValidator {
+  constructor(errorMessage?: string);
+  /**
+   * Check if value is a number type
+   */
+  matchesType(value: any): boolean;
+  /**
+   * Value must be equal or higher than the given number or field
+   * Smart detection: number or field name
+   *
+   * @category Validation Rule
+   */
+  min(min: number | string, errorMessage?: string): this;
+  /**
+   * Value must be equal or less than the given number or field
+   * Smart detection: number or field name
+   *
+   * @category Validation Rule
+   */
+  max(max: number | string, errorMessage?: string): this;
+  /**
+   * Value must be >= sibling field value
+   * @category Validation Rule
+   */
+  minSibling(field: string, errorMessage?: string): this;
+  /**
+   * Value must be <= sibling field value
+   * @category Validation Rule
+   */
+  maxSibling(field: string, errorMessage?: string): this;
+  /**
+   * Value must be strictly greater than the given number or field (>)
+   * Smart detection: number or field name
+   *
+   * @category Validation Rule
+   */
+  greaterThan(value: number | string, errorMessage?: string): this;
+  /**
+   * Value must be strictly less than the given number or field (<)
+   * Smart detection: number or field name
+   *
+   * @category Validation Rule
+   */
+  lessThan(value: number | string, errorMessage?: string): this;
+  /**
+   * Alias for greaterThan() - shorter syntax
+   * @category Validation Rule
+   */
+  gt(value: number | string, errorMessage?: string): this;
+  /**
+   * Alias for lessThan() - shorter syntax
+   * @category Validation Rule
+   */
+  lt(value: number | string, errorMessage?: string): this;
+  /**
+   * Value must be > sibling field value
+   * @category Validation Rule
+   */
+  greaterThanSibling(field: string, errorMessage?: string): this;
+  /**
+   * Alias for greaterThanSibling() - shorter syntax
+   * @category Validation Rule
+   */
+  gtSibling(field: string, errorMessage?: string): this;
+  /**
+   * Value must be < sibling field value
+   * @category Validation Rule
+   */
+  lessThanSibling(field: string, errorMessage?: string): this;
+  /**
+   * Alias for lessThanSibling() - shorter syntax
+   * @category Validation Rule
+   */
+  ltSibling(field: string, errorMessage?: string): this;
+  /** Value must be a modulo of the given number */
+  modulo(value: number, errorMessage?: string): this;
+  /**
+   * Alias for modulo() - Value must be divisible by the given number
+   */
+  divisibleBy(value: number, errorMessage?: string): this;
+  /**
+   * Alias for modulo() - Value must be a multiple of the given number
+   */
+  multipleOf(value: number, errorMessage?: string): this;
+  /**
+   * Alias for modulo() - Value must be a multiple of the given number
+   */
+  modulusOf(value: number, errorMessage?: string): this;
+  /** Accept only numbers higher than 0 */
+  positive(errorMessage?: string): this;
+  /** Accept only negative numbers */
+  negative(errorMessage?: string): this;
+  /** Accept only odd numbers */
+  odd(errorMessage?: string): this;
+  /** Accept only even numbers */
+  even(errorMessage?: string): this;
+  /**
+   * Accept only numbers between the given two numbers or fields (Inclusive)
+   * Smart detection: number or field name
+   *
+   * @category Validation Rule
+   */
+  between(min: number | string, max: number | string, errorMessage?: string): this;
+  /**
+   * Value must be between sibling field values
+   * @category Validation Rule
+   */
+  betweenSibling(minField: string, maxField: string, errorMessage?: string): this;
+  /**
+   * Value (as a string) must be exactly this many characters.
+   * Useful for fixed-format numeric codes (e.g. 4-digit PIN).
+   */
+  length(length: number, errorMessage?: string): this;
+  /** Value (as string representation) length must be ≥ min */
+  minLength(length: number, errorMessage?: string): this;
+  /** Value (as string representation) length must be ≤ max */
+  maxLength(length: number, errorMessage?: string): this;
+  /**
+   * Convert value to its absolute value
+   */
+  abs(): this;
+  /**
+   * Round value up to the nearest integer
+   */
+  ceil(): this;
+  /**
+   * Round value down to the nearest integer
+   */
+  floor(): this;
+  /**
+   * Round value to the nearest integer or specified decimals
+   */
+  round(decimals?: number): this;
+  /**
+   * Format number using fixed-point notation
+   */
+  toFixed(decimals?: number): this;
+  /**
+   * @inheritdoc
+   *
+   * Returns `{ type: "number" }` with numeric constraint keywords.
+   * IntValidator overrides `type` to `"integer"`.
+   *
+   * @note Sibling-scoped rules (minSibling, maxSibling, etc.) are not representable
+   * in JSON Schema and are silently omitted.
+   *
+   * @example
+   * ```ts
+   * v.number().min(0).max(100).toJsonSchema("draft-2020-12")
+   * // → { type: "number", minimum: 0, maximum: 100 }
+   * ```
+   */
+  toJsonSchema(target?: JsonSchemaTarget): JsonSchemaResult;
+  /**
+   * Shared logic for number/integer JSON Schema generation.
+   * Called by NumberValidator.toJsonSchema() (→ type: "number")
+   * and IntValidator.toJsonSchema() (→ type: "integer").
+   */
+  protected buildNumberJsonSchema(type: "number" | "integer", target: JsonSchemaTarget): JsonSchemaResult;
+}
+//#endregion
+export { NumberValidator };
+//# sourceMappingURL=number-validator.d.mts.map

package/esm/validators/number-validator.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number-validator.d.mts","names":[],"sources":["../../../../../../@warlock.js/seal/src/validators/number-validator.ts"],"mappings":";;;;;;AAwBA;cAAa,eAAA,SAAwB,kBAAA;cAChB,YAAA;EAgRkB;;;EAxQ9B,WAAA,CAAY,KAAA;EATgB;;;;;;EAmB5B,GAAA,CAAI,GAAA,mBAAsB,YAAA;EAVd;;;;;;EAoBZ,GAAA,CAAI,GAAA,mBAAsB,YAAA;EAQ1B;;;;EAAA,UAAA,CAAW,KAAA,UAAe,YAAA;EAQA;;;;EAA1B,UAAA,CAAW,KAAA,UAAe,YAAA;EAuBjB;;;;;;EAbT,WAAA,CAAY,KAAA,mBAAwB,YAAA;EAgCT;;;;;;EAnB3B,QAAA,CAAS,KAAA,mBAAwB,YAAA;EA8CjC;;;;EAnCA,EAAA,CAAG,KAAA,mBAAwB,YAAA;EA8CF;;;;EAtCzB,EAAA,CAAG,KAAA,mBAAwB,YAAA;EAkDf;;;;EA1CZ,kBAAA,CAAmB,KAAA,UAAe,YAAA;EAwDlC;;;;EA7CA,SAAA,CAAU,KAAA,UAAe,YAAA;EAuDzB;;;;EA/CA,eAAA,CAAgB,KAAA,UAAe,YAAA;EAyD1B;;;;EA9CL,SAAA,CAAU,KAAA,UAAe,YAAA;EAoEzB;EA/DA,MAAA,CAAO,KAAA,UAAe,YAAA;EA+DW;;;EAxDjC,WAAA,CAAY,KAAA,UAAe,YAAA;EAsEJ;;;EA/DvB,UAAA,CAAW,KAAA,UAAe,YAAA;EAyE1B;;;EAlEA,SAAA,CAAU,KAAA,UAAe,YAAA;EAkFzB;EA7EA,QAAA,CAAS,YAAA;EA2FT;EAtFA,QAAA,CAAS,YAAA;EA6FT;EAxFA,GAAA,CAAI,YAAA;EA2GK;EAtGT,IAAA,CAAK,YAAA;EAsGiB;;;;;;EA5FtB,OAAA,CAAQ,GAAA,mBAAsB,GAAA,mBAAsB,YAAA;EAwGxC;AAAA;;;EA5FZ,cAAA,CAAe,QAAA,UAAkB,QAAA,UAAkB,YAAA;;;;;EAcnD,MAAA,CAAO,MAAA,UAAgB,YAAA;;EAKvB,SAAA,CAAU,MAAA,UAAgB,YAAA;;EAK1B,SAAA,CAAU,MAAA,UAAgB,YAAA;;;;EAS1B,GAAA,CAAA;;;;EAOA,IAAA,CAAA;;;;EAOA,KAAA,CAAA;;;;EAOA,KAAA,CAAM,QAAA;;;;EAON,OAAA,CAAQ,QAAA;;;;;;;;;;;;;;;;EAmBC,YAAA,CAAa,MAAA,GAAQ,gBAAA,GAAqC,gBAAA;;;;;;YAShE,qBAAA,CACR,IAAA,wBACA,MAAA,EAAQ,gBAAA,GACP,gBAAA;AAAA"}

package/esm/validators/number-validator.mjs

@@ -0,0 +1,303 @@
+import { applyNullable, getRuleOptions } from "../standard-schema/json-schema.mjs";
+import { absMutator, ceilMutator, floorMutator, roundMutator, toFixedMutator } from "../mutators/number-mutators.mjs";
+import "../mutators/index.mjs";
+import { betweenNumbersRule, evenRule, greaterThanRule, lessThanRule, maxRule, minRule, moduloRule, negativeRule, oddRule, positiveRule } from "../rules/number/number-rules.mjs";
+import { lengthRule, maxLengthRule, minLengthRule } from "../rules/length/length-rules.mjs";
+import { numberRule } from "../rules/common/type-rules.mjs";
+import "../rules/index.mjs";
+import { PrimitiveValidator } from "./primitive-validator.mjs";
+
+//#region ../../@warlock.js/seal/src/validators/number-validator.ts
+/**
+* Number validator class - base for Int and Float validators
+*/
+var NumberValidator = class extends PrimitiveValidator {
+	constructor(errorMessage) {
+		super();
+		this.addMutableRule(numberRule, errorMessage);
+	}
+	/**
+	* Check if value is a number type
+	*/
+	matchesType(value) {
+		return typeof value === "number" && !isNaN(value);
+	}
+	/**
+	* Value must be equal or higher than the given number or field
+	* Smart detection: number or field name
+	*
+	* @category Validation Rule
+	*/
+	min(min, errorMessage) {
+		return this.addRule(minRule, errorMessage, {
+			min,
+			scope: "global"
+		});
+	}
+	/**
+	* Value must be equal or less than the given number or field
+	* Smart detection: number or field name
+	*
+	* @category Validation Rule
+	*/
+	max(max, errorMessage) {
+		return this.addRule(maxRule, errorMessage, {
+			max,
+			scope: "global"
+		});
+	}
+	/**
+	* Value must be >= sibling field value
+	* @category Validation Rule
+	*/
+	minSibling(field, errorMessage) {
+		return this.addRule(minRule, errorMessage, {
+			min: field,
+			scope: "sibling"
+		});
+	}
+	/**
+	* Value must be <= sibling field value
+	* @category Validation Rule
+	*/
+	maxSibling(field, errorMessage) {
+		return this.addRule(maxRule, errorMessage, {
+			max: field,
+			scope: "sibling"
+		});
+	}
+	/**
+	* Value must be strictly greater than the given number or field (>)
+	* Smart detection: number or field name
+	*
+	* @category Validation Rule
+	*/
+	greaterThan(value, errorMessage) {
+		return this.addRule(greaterThanRule, errorMessage, {
+			value,
+			scope: "global"
+		});
+	}
+	/**
+	* Value must be strictly less than the given number or field (<)
+	* Smart detection: number or field name
+	*
+	* @category Validation Rule
+	*/
+	lessThan(value, errorMessage) {
+		return this.addRule(lessThanRule, errorMessage, {
+			value,
+			scope: "global"
+		});
+	}
+	/**
+	* Alias for greaterThan() - shorter syntax
+	* @category Validation Rule
+	*/
+	gt(value, errorMessage) {
+		return this.greaterThan(value, errorMessage);
+	}
+	/**
+	* Alias for lessThan() - shorter syntax
+	* @category Validation Rule
+	*/
+	lt(value, errorMessage) {
+		return this.lessThan(value, errorMessage);
+	}
+	/**
+	* Value must be > sibling field value
+	* @category Validation Rule
+	*/
+	greaterThanSibling(field, errorMessage) {
+		return this.addRule(greaterThanRule, errorMessage, {
+			value: field,
+			scope: "sibling"
+		});
+	}
+	/**
+	* Alias for greaterThanSibling() - shorter syntax
+	* @category Validation Rule
+	*/
+	gtSibling(field, errorMessage) {
+		return this.greaterThanSibling(field, errorMessage);
+	}
+	/**
+	* Value must be < sibling field value
+	* @category Validation Rule
+	*/
+	lessThanSibling(field, errorMessage) {
+		return this.addRule(lessThanRule, errorMessage, {
+			value: field,
+			scope: "sibling"
+		});
+	}
+	/**
+	* Alias for lessThanSibling() - shorter syntax
+	* @category Validation Rule
+	*/
+	ltSibling(field, errorMessage) {
+		return this.lessThanSibling(field, errorMessage);
+	}
+	/** Value must be a modulo of the given number */
+	modulo(value, errorMessage) {
+		return this.addRule(moduloRule, errorMessage, { value });
+	}
+	/**
+	* Alias for modulo() - Value must be divisible by the given number
+	*/
+	divisibleBy(value, errorMessage) {
+		return this.modulo(value, errorMessage);
+	}
+	/**
+	* Alias for modulo() - Value must be a multiple of the given number
+	*/
+	multipleOf(value, errorMessage) {
+		return this.modulo(value, errorMessage);
+	}
+	/**
+	* Alias for modulo() - Value must be a multiple of the given number
+	*/
+	modulusOf(value, errorMessage) {
+		return this.modulo(value, errorMessage);
+	}
+	/** Accept only numbers higher than 0 */
+	positive(errorMessage) {
+		return this.addRule(positiveRule, errorMessage);
+	}
+	/** Accept only negative numbers */
+	negative(errorMessage) {
+		return this.addRule(negativeRule, errorMessage);
+	}
+	/** Accept only odd numbers */
+	odd(errorMessage) {
+		return this.addRule(oddRule, errorMessage);
+	}
+	/** Accept only even numbers */
+	even(errorMessage) {
+		return this.addRule(evenRule, errorMessage);
+	}
+	/**
+	* Accept only numbers between the given two numbers or fields (Inclusive)
+	* Smart detection: number or field name
+	*
+	* @category Validation Rule
+	*/
+	between(min, max, errorMessage) {
+		return this.addRule(betweenNumbersRule, errorMessage, {
+			min,
+			max,
+			scope: "global"
+		});
+	}
+	/**
+	* Value must be between sibling field values
+	* @category Validation Rule
+	*/
+	betweenSibling(minField, maxField, errorMessage) {
+		return this.addRule(betweenNumbersRule, errorMessage, {
+			min: minField,
+			max: maxField,
+			scope: "sibling"
+		});
+	}
+	/**
+	* Value (as a string) must be exactly this many characters.
+	* Useful for fixed-format numeric codes (e.g. 4-digit PIN).
+	*/
+	length(length, errorMessage) {
+		return this.addRule(lengthRule, errorMessage, { length });
+	}
+	/** Value (as string representation) length must be ≥ min */
+	minLength(length, errorMessage) {
+		return this.addRule(minLengthRule, errorMessage, { minLength: length });
+	}
+	/** Value (as string representation) length must be ≤ max */
+	maxLength(length, errorMessage) {
+		return this.addRule(maxLengthRule, errorMessage, { maxLength: length });
+	}
+	/**
+	* Convert value to its absolute value
+	*/
+	abs() {
+		return this.addMutator(absMutator);
+	}
+	/**
+	* Round value up to the nearest integer
+	*/
+	ceil() {
+		return this.addMutator(ceilMutator);
+	}
+	/**
+	* Round value down to the nearest integer
+	*/
+	floor() {
+		return this.addMutator(floorMutator);
+	}
+	/**
+	* Round value to the nearest integer or specified decimals
+	*/
+	round(decimals = 0) {
+		return this.addMutator(roundMutator, { decimals });
+	}
+	/**
+	* Format number using fixed-point notation
+	*/
+	toFixed(decimals = 2) {
+		return this.addMutator(toFixedMutator, { decimals });
+	}
+	/**
+	* @inheritdoc
+	*
+	* Returns `{ type: "number" }` with numeric constraint keywords.
+	* IntValidator overrides `type` to `"integer"`.
+	*
+	* @note Sibling-scoped rules (minSibling, maxSibling, etc.) are not representable
+	* in JSON Schema and are silently omitted.
+	*
+	* @example
+	* ```ts
+	* v.number().min(0).max(100).toJsonSchema("draft-2020-12")
+	* // → { type: "number", minimum: 0, maximum: 100 }
+	* ```
+	*/
+	toJsonSchema(target = "draft-2020-12") {
+		return this.buildNumberJsonSchema("number", target);
+	}
+	/**
+	* Shared logic for number/integer JSON Schema generation.
+	* Called by NumberValidator.toJsonSchema() (→ type: "number")
+	* and IntValidator.toJsonSchema() (→ type: "integer").
+	*/
+	buildNumberJsonSchema(type, target) {
+		const schema = { type };
+		const minOpts = getRuleOptions(this.rules, "min");
+		if (minOpts?.min !== void 0 && typeof minOpts.min === "number") schema.minimum = minOpts.min;
+		const maxOpts = getRuleOptions(this.rules, "max");
+		if (maxOpts?.max !== void 0 && typeof maxOpts.max === "number") schema.maximum = maxOpts.max;
+		const betweenOpts = getRuleOptions(this.rules, "betweenNumbers");
+		if (betweenOpts) {
+			if (typeof betweenOpts.min === "number") schema.minimum = betweenOpts.min;
+			if (typeof betweenOpts.max === "number") schema.maximum = betweenOpts.max;
+		}
+		const gtOpts = getRuleOptions(this.rules, "greaterThan");
+		if (gtOpts?.value !== void 0 && typeof gtOpts.value === "number") if (target === "draft-07") {
+			schema.minimum = gtOpts.value;
+			schema.exclusiveMinimum = true;
+		} else schema.exclusiveMinimum = gtOpts.value;
+		const ltOpts = getRuleOptions(this.rules, "lessThan");
+		if (ltOpts?.value !== void 0 && typeof ltOpts.value === "number") if (target === "draft-07") {
+			schema.maximum = ltOpts.value;
+			schema.exclusiveMaximum = true;
+		} else schema.exclusiveMaximum = ltOpts.value;
+		const moduloOpts = getRuleOptions(this.rules, "modulo");
+		if (moduloOpts?.value !== void 0 && typeof moduloOpts.value === "number") schema.multipleOf = moduloOpts.value;
+		const inOpts = getRuleOptions(this.rules, "in");
+		if (inOpts?.values && Array.isArray(inOpts.values)) schema.enum = inOpts.values;
+		if (this.isNullable) applyNullable(schema, target);
+		return schema;
+	}
+};
+
+//#endregion
+export { NumberValidator };
+//# sourceMappingURL=number-validator.mjs.map

package/esm/validators/number-validator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"number-validator.mjs","names":[],"sources":["../../../../../../@warlock.js/seal/src/validators/number-validator.ts"],"sourcesContent":["import { absMutator, ceilMutator, floorMutator, roundMutator, toFixedMutator } from \"../mutators\";\r\nimport {\r\n  betweenNumbersRule,\r\n  evenRule,\r\n  greaterThanRule,\r\n  lengthRule,\r\n  lessThanRule,\r\n  maxLengthRule,\r\n  maxRule,\r\n  minLengthRule,\r\n  minRule,\r\n  moduloRule,\r\n  negativeRule,\r\n  numberRule,\r\n  oddRule,\r\n  positiveRule,\r\n} from \"../rules\";\r\nimport { PrimitiveValidator } from \"./primitive-validator\";\r\nimport { applyNullable, getRuleOptions } from \"../standard-schema/json-schema\";\r\nimport type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\r\n\r\n/**\r\n * Number validator class - base for Int and Float validators\r\n */\r\nexport class NumberValidator extends PrimitiveValidator {\r\n  public constructor(errorMessage?: string) {\r\n    super();\r\n    this.addMutableRule(numberRule, errorMessage);\r\n  }\r\n\r\n  /**\r\n   * Check if value is a number type\r\n   */\r\n  public matchesType(value: any): boolean {\r\n    return typeof value === \"number\" && !isNaN(value);\r\n  }\r\n\r\n  /**\r\n   * Value must be equal or higher than the given number or field\r\n   * Smart detection: number or field name\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public min(min: number | string, errorMessage?: string) {\r\n    return this.addRule(minRule, errorMessage, { min, scope: \"global\" });\r\n  }\r\n\r\n  /**\r\n   * Value must be equal or less than the given number or field\r\n   * Smart detection: number or field name\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public max(max: number | string, errorMessage?: string) {\r\n    return this.addRule(maxRule, errorMessage, { max, scope: \"global\" });\r\n  }\r\n\r\n  /**\r\n   * Value must be >= sibling field value\r\n   * @category Validation Rule\r\n   */\r\n  public minSibling(field: string, errorMessage?: string) {\r\n    return this.addRule(minRule, errorMessage, { min: field, scope: \"sibling\" });\r\n  }\r\n\r\n  /**\r\n   * Value must be <= sibling field value\r\n   * @category Validation Rule\r\n   */\r\n  public maxSibling(field: string, errorMessage?: string) {\r\n    return this.addRule(maxRule, errorMessage, { max: field, scope: \"sibling\" });\r\n  }\r\n\r\n  /**\r\n   * Value must be strictly greater than the given number or field (>)\r\n   * Smart detection: number or field name\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public greaterThan(value: number | string, errorMessage?: string) {\r\n    return this.addRule(greaterThanRule, errorMessage, {\r\n      value,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Value must be strictly less than the given number or field (<)\r\n   * Smart detection: number or field name\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public lessThan(value: number | string, errorMessage?: string) {\r\n    return this.addRule(lessThanRule, errorMessage, {\r\n      value,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Alias for greaterThan() - shorter syntax\r\n   * @category Validation Rule\r\n   */\r\n  public gt(value: number | string, errorMessage?: string) {\r\n    return this.greaterThan(value, errorMessage);\r\n  }\r\n\r\n  /**\r\n   * Alias for lessThan() - shorter syntax\r\n   * @category Validation Rule\r\n   */\r\n  public lt(value: number | string, errorMessage?: string) {\r\n    return this.lessThan(value, errorMessage);\r\n  }\r\n\r\n  /**\r\n   * Value must be > sibling field value\r\n   * @category Validation Rule\r\n   */\r\n  public greaterThanSibling(field: string, errorMessage?: string) {\r\n    return this.addRule(greaterThanRule, errorMessage, {\r\n      value: field,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Alias for greaterThanSibling() - shorter syntax\r\n   * @category Validation Rule\r\n   */\r\n  public gtSibling(field: string, errorMessage?: string) {\r\n    return this.greaterThanSibling(field, errorMessage);\r\n  }\r\n\r\n  /**\r\n   * Value must be < sibling field value\r\n   * @category Validation Rule\r\n   */\r\n  public lessThanSibling(field: string, errorMessage?: string) {\r\n    return this.addRule(lessThanRule, errorMessage, {\r\n      value: field,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Alias for lessThanSibling() - shorter syntax\r\n   * @category Validation Rule\r\n   */\r\n  public ltSibling(field: string, errorMessage?: string) {\r\n    return this.lessThanSibling(field, errorMessage);\r\n  }\r\n\r\n  /** Value must be a modulo of the given number */\r\n  public modulo(value: number, errorMessage?: string) {\r\n    return this.addRule(moduloRule, errorMessage, { value });\r\n  }\r\n\r\n  /**\r\n   * Alias for modulo() - Value must be divisible by the given number\r\n   */\r\n  public divisibleBy(value: number, errorMessage?: string) {\r\n    return this.modulo(value, errorMessage);\r\n  }\r\n\r\n  /**\r\n   * Alias for modulo() - Value must be a multiple of the given number\r\n   */\r\n  public multipleOf(value: number, errorMessage?: string) {\r\n    return this.modulo(value, errorMessage);\r\n  }\r\n\r\n  /**\r\n   * Alias for modulo() - Value must be a multiple of the given number\r\n   */\r\n  public modulusOf(value: number, errorMessage?: string) {\r\n    return this.modulo(value, errorMessage);\r\n  }\r\n\r\n  /** Accept only numbers higher than 0 */\r\n  public positive(errorMessage?: string) {\r\n    return this.addRule(positiveRule, errorMessage);\r\n  }\r\n\r\n  /** Accept only negative numbers */\r\n  public negative(errorMessage?: string) {\r\n    return this.addRule(negativeRule, errorMessage);\r\n  }\r\n\r\n  /** Accept only odd numbers */\r\n  public odd(errorMessage?: string) {\r\n    return this.addRule(oddRule, errorMessage);\r\n  }\r\n\r\n  /** Accept only even numbers */\r\n  public even(errorMessage?: string) {\r\n    return this.addRule(evenRule, errorMessage);\r\n  }\r\n\r\n  /**\r\n   * Accept only numbers between the given two numbers or fields (Inclusive)\r\n   * Smart detection: number or field name\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public between(min: number | string, max: number | string, errorMessage?: string) {\r\n    return this.addRule(betweenNumbersRule, errorMessage, {\r\n      min,\r\n      max,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Value must be between sibling field values\r\n   * @category Validation Rule\r\n   */\r\n  public betweenSibling(minField: string, maxField: string, errorMessage?: string) {\r\n    return this.addRule(betweenNumbersRule, errorMessage, {\r\n      min: minField,\r\n      max: maxField,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  // Enum and value membership methods are inherited from PrimitiveValidator.\r\n\r\n  /**\r\n   * Value (as a string) must be exactly this many characters.\r\n   * Useful for fixed-format numeric codes (e.g. 4-digit PIN).\r\n   */\r\n  public length(length: number, errorMessage?: string) {\r\n    return this.addRule(lengthRule, errorMessage, { length });\r\n  }\r\n\r\n  /** Value (as string representation) length must be ≥ min */\r\n  public minLength(length: number, errorMessage?: string) {\r\n    return this.addRule(minLengthRule, errorMessage, { minLength: length });\r\n  }\r\n\r\n  /** Value (as string representation) length must be ≤ max */\r\n  public maxLength(length: number, errorMessage?: string) {\r\n    return this.addRule(maxLengthRule, errorMessage, { maxLength: length });\r\n  }\r\n\r\n  // Mutators\r\n\r\n  /**\r\n   * Convert value to its absolute value\r\n   */\r\n  public abs() {\r\n    return this.addMutator(absMutator);\r\n  }\r\n\r\n  /**\r\n   * Round value up to the nearest integer\r\n   */\r\n  public ceil() {\r\n    return this.addMutator(ceilMutator);\r\n  }\r\n\r\n  /**\r\n   * Round value down to the nearest integer\r\n   */\r\n  public floor() {\r\n    return this.addMutator(floorMutator);\r\n  }\r\n\r\n  /**\r\n   * Round value to the nearest integer or specified decimals\r\n   */\r\n  public round(decimals = 0) {\r\n    return this.addMutator(roundMutator, { decimals });\r\n  }\r\n\r\n  /**\r\n   * Format number using fixed-point notation\r\n   */\r\n  public toFixed(decimals = 2) {\r\n    return this.addMutator(toFixedMutator, { decimals });\r\n  }\r\n\r\n  /**\r\n   * @inheritdoc\r\n   *\r\n   * Returns `{ type: \"number\" }` with numeric constraint keywords.\r\n   * IntValidator overrides `type` to `\"integer\"`.\r\n   *\r\n   * @note Sibling-scoped rules (minSibling, maxSibling, etc.) are not representable\r\n   * in JSON Schema and are silently omitted.\r\n   *\r\n   * @example\r\n   * ```ts\r\n   * v.number().min(0).max(100).toJsonSchema(\"draft-2020-12\")\r\n   * // → { type: \"number\", minimum: 0, maximum: 100 }\r\n   * ```\r\n   */\r\n  public override toJsonSchema(target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\r\n    return this.buildNumberJsonSchema(\"number\", target);\r\n  }\r\n\r\n  /**\r\n   * Shared logic for number/integer JSON Schema generation.\r\n   * Called by NumberValidator.toJsonSchema() (→ type: \"number\")\r\n   * and IntValidator.toJsonSchema() (→ type: \"integer\").\r\n   */\r\n  protected buildNumberJsonSchema(\r\n    type: \"number\" | \"integer\",\r\n    target: JsonSchemaTarget,\r\n  ): JsonSchemaResult {\r\n    const schema: JsonSchemaResult = { type };\r\n\r\n    // minimum (inclusive)\r\n    const minOpts = getRuleOptions(this.rules, \"min\");\r\n    if (minOpts?.min !== undefined && typeof minOpts.min === \"number\") {\r\n      schema.minimum = minOpts.min;\r\n    }\r\n\r\n    // maximum (inclusive)\r\n    const maxOpts = getRuleOptions(this.rules, \"max\");\r\n    if (maxOpts?.max !== undefined && typeof maxOpts.max === \"number\") {\r\n      schema.maximum = maxOpts.max;\r\n    }\r\n\r\n    // between (inclusive range)\r\n    const betweenOpts = getRuleOptions(this.rules, \"betweenNumbers\");\r\n    if (betweenOpts) {\r\n      if (typeof betweenOpts.min === \"number\") schema.minimum = betweenOpts.min;\r\n      if (typeof betweenOpts.max === \"number\") schema.maximum = betweenOpts.max;\r\n    }\r\n\r\n    // greaterThan (>) → exclusiveMinimum\r\n    const gtOpts = getRuleOptions(this.rules, \"greaterThan\");\r\n    if (gtOpts?.value !== undefined && typeof gtOpts.value === \"number\") {\r\n      if (target === \"draft-07\") {\r\n        schema.minimum = gtOpts.value;\r\n        schema.exclusiveMinimum = true;\r\n      } else {\r\n        schema.exclusiveMinimum = gtOpts.value;\r\n      }\r\n    }\r\n\r\n    // lessThan (<) → exclusiveMaximum\r\n    const ltOpts = getRuleOptions(this.rules, \"lessThan\");\r\n    if (ltOpts?.value !== undefined && typeof ltOpts.value === \"number\") {\r\n      if (target === \"draft-07\") {\r\n        schema.maximum = ltOpts.value;\r\n        schema.exclusiveMaximum = true;\r\n      } else {\r\n        schema.exclusiveMaximum = ltOpts.value;\r\n      }\r\n    }\r\n\r\n    // multipleOf / modulo\r\n    const moduloOpts = getRuleOptions(this.rules, \"modulo\");\r\n    if (moduloOpts?.value !== undefined && typeof moduloOpts.value === \"number\") {\r\n      schema.multipleOf = moduloOpts.value;\r\n    }\r\n\r\n    // enum (from PrimitiveValidator.in / .enum)\r\n    const inOpts = getRuleOptions(this.rules, \"in\");\r\n    if (inOpts?.values && Array.isArray(inOpts.values)) {\r\n      schema.enum = inOpts.values;\r\n    }\r\n\r\n    if (this.isNullable) applyNullable(schema, target);\r\n\r\n    return schema;\r\n  }\r\n}\r\n"],"mappings":"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"}

package/esm/validators/numeric-validator.d.mts

@@ -0,0 +1,19 @@
+import { NumberValidator } from "./number-validator.mjs";
+
+//#region ../../@warlock.js/seal/src/validators/numeric-validator.d.ts
+/**
+ * Numeric validator class - base for Int and Float validators either as number or string
+ */
+declare class NumericValidator extends NumberValidator {
+  /**
+   * Constructor
+   */
+  constructor(errorMessage?: string);
+  /**
+   * Check if value is a numeric type
+   */
+  matchesType(value: any): boolean;
+}
+//#endregion
+export { NumericValidator };
+//# sourceMappingURL=numeric-validator.d.mts.map

package/esm/validators/numeric-validator.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numeric-validator.d.mts","names":[],"sources":["../../../../../../@warlock.js/seal/src/validators/numeric-validator.ts"],"mappings":";;;;;AAOA;cAAa,gBAAA,SAAyB,eAAe;;;;cAIhC,YAAA;EAAA;;;EAQZ,WAAA,CAAY,KAAA;AAAA"}

package/esm/validators/numeric-validator.mjs

@@ -0,0 +1,27 @@
+import { numericMutator } from "../mutators/number-mutators.mjs";
+import { NumberValidator } from "./number-validator.mjs";
+import { isNumeric } from "@mongez/supportive-is";
+
+//#region ../../@warlock.js/seal/src/validators/numeric-validator.ts
+/**
+* Numeric validator class - base for Int and Float validators either as number or string
+*/
+var NumericValidator = class extends NumberValidator {
+	/**
+	* Constructor
+	*/
+	constructor(errorMessage) {
+		super(errorMessage);
+		this.addMutableMutator(numericMutator);
+	}
+	/**
+	* Check if value is a numeric type
+	*/
+	matchesType(value) {
+		return isNumeric(value);
+	}
+};
+
+//#endregion
+export { NumericValidator };
+//# sourceMappingURL=numeric-validator.mjs.map

package/esm/validators/numeric-validator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"numeric-validator.mjs","names":[],"sources":["../../../../../../@warlock.js/seal/src/validators/numeric-validator.ts"],"sourcesContent":["import { isNumeric } from \"@mongez/supportive-is\";\r\nimport { numericMutator } from \"../mutators/number-mutators\";\r\nimport { NumberValidator } from \"./number-validator\";\r\n\r\n/**\r\n * Numeric validator class - base for Int and Float validators either as number or string\r\n */\r\nexport class NumericValidator extends NumberValidator {\r\n  /**\r\n   * Constructor\r\n   */\r\n  public constructor(errorMessage?: string) {\r\n    super(errorMessage);\r\n    this.addMutableMutator(numericMutator);\r\n  }\r\n\r\n  /**\r\n   * Check if value is a numeric type\r\n   */\r\n  public matchesType(value: any): boolean {\r\n    return isNumeric(value);\r\n  }\r\n}\r\n"],"mappings":";;;;;;;;AAOA,IAAa,mBAAb,cAAsC,gBAAgB;;;;CAIpD,AAAO,YAAY,cAAuB;EACxC,MAAM,YAAY;EAClB,KAAK,kBAAkB,cAAc;CACvC;;;;CAKA,AAAO,YAAY,OAAqB;EACtC,OAAO,UAAU,KAAK;CACxB;AACF"}