@warlock.js/seal 4.0.174 → 4.1.1

package/esm/config.d.mts

@@ -0,0 +1,47 @@
+import { AttributeTranslation, RuleTranslation } from "./types/context-types.mjs";
+
+//#region ../../@warlock.js/seal/src/config.d.ts
+type TranslateRuleCallback = (ruleTranslation: RuleTranslation) => string;
+type TranslateAttributeCallback = (attributeTranslation: AttributeTranslation) => string;
+type SealConfig = {
+  /**
+   * Translation function for error messages
+   * Default: returns the key with attributes replaced
+   */
+  translateRule?: TranslateRuleCallback;
+  /**
+   * Translation function for attribute messages
+   */
+  translateAttribute?: TranslateAttributeCallback;
+  /**
+   * Default to first error only in validation
+   * Default: true
+   */
+  firstErrorOnly?: boolean;
+};
+/**
+ * Configure Seal globally
+ *
+ * @example
+ * ```ts
+ * import { configureSeal } from "@warlock.js/seal";
+ * import { trans } from "@mongez/localization";
+ *
+ * configureSeal({
+ *   translateRule: (ruleTranslation) => trans(`validation.${ruleTranslation.rule.name}`, ruleTranslation.attributes),
+ *   translateAttribute: (attributeTranslation) => trans(`validation.attributes.${attributeTranslation.rule.name}.${attributeTranslation.attribute}`, attributeTranslation.context.allValues),
+ * });
+ * ```
+ */
+declare function configureSeal(options: Partial<SealConfig>): void;
+/**
+ * Get current Seal configuration
+ */
+declare function getSealConfig(): SealConfig;
+/**
+ * Reset configuration to defaults
+ */
+declare function resetSealConfig(): void;
+//#endregion
+export { SealConfig, TranslateAttributeCallback, TranslateRuleCallback, configureSeal, getSealConfig, resetSealConfig };
+//# sourceMappingURL=config.d.mts.map

package/esm/config.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.mts","names":[],"sources":["../../../../../@warlock.js/seal/src/config.ts"],"mappings":";;;KAQY,qBAAA,IACV,eAAgC,EAAf,eAAe;AAAA,KAGtB,0BAAA,IACV,oBAA0C,EAApB,oBAAoB;AAAA,KAGhC,UAAA;EAJ0B;;;AACM;EAQ1C,aAAA,GAAgB,qBAAA;EALI;;;EASpB,kBAAA,GAAqB,0BAA0B;EAJ/B;;;;EAUhB,cAAA;AAAA;AAwBF;;;;;;;;AAA0D;AAO1D;;;;AAA2C;AAP3C,iBAAgB,aAAA,CAAc,OAAA,EAAS,OAAO,CAAC,UAAA;;;;iBAO/B,aAAA,CAAA,GAAiB,UAAU;;;;iBAO3B,eAAA,CAAA"}

package/esm/config.mjs

@@ -0,0 +1,40 @@
+//#region ../../@warlock.js/seal/src/config.ts
+/**
+* Global Seal configuration
+*/
+const config = { firstErrorOnly: true };
+/**
+* Configure Seal globally
+*
+* @example
+* ```ts
+* import { configureSeal } from "@warlock.js/seal";
+* import { trans } from "@mongez/localization";
+*
+* configureSeal({
+*   translateRule: (ruleTranslation) => trans(`validation.${ruleTranslation.rule.name}`, ruleTranslation.attributes),
+*   translateAttribute: (attributeTranslation) => trans(`validation.attributes.${attributeTranslation.rule.name}.${attributeTranslation.attribute}`, attributeTranslation.context.allValues),
+* });
+* ```
+*/
+function configureSeal(options) {
+	Object.assign(config, options);
+}
+/**
+* Get current Seal configuration
+*/
+function getSealConfig() {
+	return config;
+}
+/**
+* Reset configuration to defaults
+*/
+function resetSealConfig() {
+	delete config.translateRule;
+	delete config.translateAttribute;
+	config.firstErrorOnly = true;
+}
+
+//#endregion
+export { configureSeal, getSealConfig, resetSealConfig };
+//# sourceMappingURL=config.mjs.map

package/esm/config.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.mjs","names":[],"sources":["../../../../../@warlock.js/seal/src/config.ts"],"sourcesContent":["/**\r\n * Seal Configuration\r\n *\r\n * Global configuration for the Seal validation library\r\n */\r\n\r\nimport type { AttributeTranslation, RuleTranslation } from \"./types\";\r\n\r\nexport type TranslateRuleCallback = (\r\n  ruleTranslation: RuleTranslation,\r\n) => string;\r\n\r\nexport type TranslateAttributeCallback = (\r\n  attributeTranslation: AttributeTranslation,\r\n) => string;\r\n\r\nexport type SealConfig = {\r\n  /**\r\n   * Translation function for error messages\r\n   * Default: returns the key with attributes replaced\r\n   */\r\n  translateRule?: TranslateRuleCallback;\r\n  /**\r\n   * Translation function for attribute messages\r\n   */\r\n  translateAttribute?: TranslateAttributeCallback;\r\n\r\n  /**\r\n   * Default to first error only in validation\r\n   * Default: true\r\n   */\r\n  firstErrorOnly?: boolean;\r\n};\r\n\r\n/**\r\n * Global Seal configuration\r\n */\r\nconst config: SealConfig = {\r\n  firstErrorOnly: true,\r\n};\r\n\r\n/**\r\n * Configure Seal globally\r\n *\r\n * @example\r\n * ```ts\r\n * import { configureSeal } from \"@warlock.js/seal\";\r\n * import { trans } from \"@mongez/localization\";\r\n *\r\n * configureSeal({\r\n *   translateRule: (ruleTranslation) => trans(`validation.${ruleTranslation.rule.name}`, ruleTranslation.attributes),\r\n *   translateAttribute: (attributeTranslation) => trans(`validation.attributes.${attributeTranslation.rule.name}.${attributeTranslation.attribute}`, attributeTranslation.context.allValues),\r\n * });\r\n * ```\r\n */\r\nexport function configureSeal(options: Partial<SealConfig>): void {\r\n  Object.assign(config, options);\r\n}\r\n\r\n/**\r\n * Get current Seal configuration\r\n */\r\nexport function getSealConfig(): SealConfig {\r\n  return config;\r\n}\r\n\r\n/**\r\n * Reset configuration to defaults\r\n */\r\nexport function resetSealConfig(): void {\r\n  delete config.translateRule;\r\n  delete config.translateAttribute;\r\n\r\n  config.firstErrorOnly = true;\r\n}\r\n"],"mappings":";;;;AAqCA,MAAM,SAAqB,EACzB,gBAAgB,KAClB;;;;;;;;;;;;;;;AAgBA,SAAgB,cAAc,SAAoC;CAChE,OAAO,OAAO,QAAQ,OAAO;AAC/B;;;;AAKA,SAAgB,gBAA4B;CAC1C,OAAO;AACT;;;;AAKA,SAAgB,kBAAwB;CACtC,OAAO,OAAO;CACd,OAAO,OAAO;CAEd,OAAO,iBAAiB;AAC1B"}

package/esm/factory/index.d.mts

@@ -0,0 +1,2 @@
+import { ValidateOptions, ValidatorV, v } from "./validators.mjs";
+import { validate } from "./validate.mjs";

package/esm/factory/index.mjs

@@ -0,0 +1,4 @@
+import { validate } from "./validate.mjs";
+import { v } from "./validators.mjs";
+
+export {  };

package/esm/factory/validate.d.mts

@@ -0,0 +1,16 @@
+import { ValidationResult } from "../types/result-types.mjs";
+import { BaseValidator } from "../validators/base-validator.mjs";
+import { ValidateOptions } from "./validators.mjs";
+
+//#region ../../@warlock.js/seal/src/factory/validate.d.ts
+/**
+ * Validate data against a schema
+ */
+declare const validate: <T extends BaseValidator>(schema: T, data: any, // Temporarily use any - will fix type inference
+{
+  context: extendedContext,
+  ...configurations
+}?: ValidateOptions) => Promise<ValidationResult>;
+//#endregion
+export { validate };
+//# sourceMappingURL=validate.d.mts.map

package/esm/factory/validate.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.mts","names":[],"sources":["../../../../../../@warlock.js/seal/src/factory/validate.ts"],"mappings":";;;;;;;;cAQa,QAAA,aAA4B,aAAA,EACvC,MAAA,EAAQ,CAAA,EACR,IAAA;AAAA;EACA,OAAA,EAAA,eAAA;EAAA,GAAA;AAAA,IAAiD,eAAA,KAChD,OAAA,CAAQ,gBAAA"}

package/esm/factory/validate.mjs

@@ -0,0 +1,29 @@
+import { getSealConfig } from "../config.mjs";
+
+//#region ../../@warlock.js/seal/src/factory/validate.ts
+/**
+* Validate data against a schema
+*/
+const validate = async (schema, data, { context: extendedContext, ...configurations } = getSealConfig() || {}) => {
+	const context = {
+		allValues: data,
+		parent: null,
+		value: data,
+		key: "",
+		path: "",
+		context: extendedContext,
+		rootContext: extendedContext,
+		translateRule(ruleTranslation) {
+			return configurations.translateRule?.(ruleTranslation) ?? "";
+		},
+		translateAttribute(attributeTranslation) {
+			return configurations.translateAttribute?.(attributeTranslation) ?? "";
+		},
+		configurations
+	};
+	return await schema.validate(data, context);
+};
+
+//#endregion
+export { validate };
+//# sourceMappingURL=validate.mjs.map

package/esm/factory/validate.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.mjs","names":[],"sources":["../../../../../../@warlock.js/seal/src/factory/validate.ts"],"sourcesContent":["import { getSealConfig } from \"../config\";\r\nimport type { SchemaContext, ValidationResult } from \"../types\";\r\nimport type { BaseValidator } from \"../validators\";\r\nimport { type ValidateOptions } from \"./validators\";\r\n\r\n/**\r\n * Validate data against a schema\r\n */\r\nexport const validate = async <T extends BaseValidator>(\r\n  schema: T,\r\n  data: any, // Temporarily use any - will fix type inference\r\n  { context: extendedContext, ...configurations }: ValidateOptions = getSealConfig() || {},\r\n): Promise<ValidationResult> => {\r\n  const context: SchemaContext = {\r\n    allValues: data,\r\n    parent: null,\r\n    value: data,\r\n    key: \"\",\r\n    path: \"\",\r\n    context: extendedContext,\r\n    rootContext: extendedContext,\r\n    translateRule(ruleTranslation) {\r\n      return configurations.translateRule?.(ruleTranslation) ?? \"\";\r\n    },\r\n    translateAttribute(attributeTranslation) {\r\n      return configurations.translateAttribute?.(attributeTranslation) ?? \"\";\r\n    },\r\n    configurations,\r\n  };\r\n\r\n  return await schema.validate(data, context);\r\n};\r\n"],"mappings":";;;;;;AAQA,MAAa,WAAW,OACtB,QACA,MACA,EAAE,SAAS,iBAAiB,GAAG,mBAAoC,cAAc,KAAK,CAAC,MACzD;CAC9B,MAAM,UAAyB;EAC7B,WAAW;EACX,QAAQ;EACR,OAAO;EACP,KAAK;EACL,MAAM;EACN,SAAS;EACT,aAAa;EACb,cAAc,iBAAiB;GAC7B,OAAO,eAAe,gBAAgB,eAAe,KAAK;EAC5D;EACA,mBAAmB,sBAAsB;GACvC,OAAO,eAAe,qBAAqB,oBAAoB,KAAK;EACtE;EACA;CACF;CAEA,OAAO,MAAM,OAAO,SAAS,MAAM,OAAO;AAC5C"}

package/esm/factory/validators.d.mts

@@ -0,0 +1,75 @@
+import { StandardSchemaV1 } from "../standard-schema/types.mjs";
+import { Schema } from "../types/schema-types.mjs";
+import { SchemaContext } from "../types/context-types.mjs";
+import { ValidationResult } from "../types/result-types.mjs";
+import { Infer } from "../types/inference-types.mjs";
+import { BaseValidator } from "../validators/base-validator.mjs";
+import { AnyValidator } from "../validators/any-validator.mjs";
+import { ArrayValidator } from "../validators/array-validator.mjs";
+import { BooleanValidator } from "../validators/boolean-validator.mjs";
+import { ComputedValidator } from "../validators/computed-validator.mjs";
+import { DateValidator } from "../validators/date-validator.mjs";
+import { ObjectValidator } from "../validators/object-validator.mjs";
+import { DiscriminatedUnionValidator } from "../validators/discriminated-union-validator.mjs";
+import { NumberValidator } from "../validators/number-validator.mjs";
+import { FloatValidator } from "../validators/float-validator.mjs";
+import { InstanceOfValidator } from "../validators/instanceof-validator.mjs";
+import { IntValidator } from "../validators/int-validator.mjs";
+import { LazyValidator } from "../validators/lazy-validator.mjs";
+import { LiteralValidator } from "../validators/literal-validator.mjs";
+import { ManagedValidator } from "../validators/managed-validator.mjs";
+import { NumericValidator } from "../validators/numeric-validator.mjs";
+import { RecordValidator } from "../validators/record-validator.mjs";
+import { ScalarValidator } from "../validators/scalar-validator.mjs";
+import { StringValidator } from "../validators/string-validator.mjs";
+import { TupleValidator } from "../validators/tuple-validator.mjs";
+import { UnionValidator } from "../validators/union-validator.mjs";
+import { SealConfig } from "../config.mjs";
+
+//#region ../../@warlock.js/seal/src/factory/validators.d.ts
+/**
+ * Seal factory object - creates instances of validators
+ *
+ * Use 'v' to create validation schemas (seals) for your data
+ */
+declare const v: ValidatorV;
+type ValidateOptions = {
+  context?: Record<string, any>;
+} & SealConfig;
+interface ValidatorV {
+  object: <T extends Schema>(schema: T, errorMessage?: string) => ObjectValidator<T> & StandardSchemaV1<Infer<ObjectValidator<T>>>;
+  any: () => AnyValidator & StandardSchemaV1<any>;
+  array: <T extends BaseValidator>(validator: T, errorMessage?: string) => ArrayValidator & {
+    validator: T;
+  } & StandardSchemaV1<Array<Infer<T>>>;
+  record: <T extends BaseValidator>(validator?: T, errorMessage?: string) => RecordValidator & {
+    valueValidator: T;
+  } & StandardSchemaV1<Record<string, Infer<T>>>;
+  tuple: <T extends BaseValidator[]>(validators: T, errorMessage?: string) => TupleValidator & {
+    validators: T;
+  } & StandardSchemaV1<{ [K in keyof T]: Infer<T[K]> }>;
+  date: (errorMessage?: string) => DateValidator & StandardSchemaV1<Date>;
+  literal: <T extends readonly [string | number | boolean, ...(string | number | boolean)[]]>(...values: T) => LiteralValidator<T> & StandardSchemaV1<T[number]>;
+  instanceof: <T>(ctor: new (...args: any[]) => T, errorMessage?: string) => InstanceOfValidator<T> & StandardSchemaV1<T>;
+  lazy: <T extends BaseValidator>(thunk: () => T) => LazyValidator<T> & StandardSchemaV1<Infer<T>>;
+  string: (errorMessage?: string) => StringValidator & StandardSchemaV1<string>;
+  email: (errorMessage?: string) => StringValidator & StandardSchemaV1<string>;
+  enum: {
+    <const T extends readonly (string | number | boolean)[]>(values: T, errorMessage?: string): ScalarValidator & StandardSchemaV1<T[number]>;
+    <const T extends Record<string, string | number>>(values: T, errorMessage?: string): ScalarValidator & StandardSchemaV1<T[keyof T]>;
+  };
+  number: (errorMessage?: string) => NumberValidator & StandardSchemaV1<number>;
+  numeric: (errorMessage?: string) => NumericValidator & StandardSchemaV1<number>;
+  int: (errorMessage?: string) => IntValidator & StandardSchemaV1<number>;
+  float: (errorMessage?: string) => FloatValidator & StandardSchemaV1<number>;
+  boolean: (errorMessage?: string) => BooleanValidator & StandardSchemaV1<boolean>;
+  scalar: (errorMessage?: string) => ScalarValidator & StandardSchemaV1<string | number | boolean>;
+  union: <T extends BaseValidator[]>(validators: T, errorMessage?: string) => UnionValidator & StandardSchemaV1<Infer<T[number]>>;
+  discriminatedUnion: <K extends string, Branches extends ReadonlyArray<ObjectValidator<any>>>(discriminator: K, validators: Branches) => DiscriminatedUnionValidator<K, Branches> & StandardSchemaV1<Infer<Branches[number]>>;
+  computed: <TResult = any>(callback: (data: any, context: SchemaContext) => TResult | Promise<TResult>, resultValidator?: BaseValidator) => ComputedValidator<TResult> & StandardSchemaV1<TResult>;
+  managed: <TResult = any>(callback?: (context: SchemaContext) => TResult | Promise<TResult>, resultValidator?: BaseValidator) => ManagedValidator<TResult> & StandardSchemaV1<TResult>;
+  validate: <T extends BaseValidator>(schema: T, data: any, options?: ValidateOptions) => Promise<ValidationResult>;
+}
+//#endregion
+export { ValidateOptions, ValidatorV, v };
+//# sourceMappingURL=validators.d.mts.map

package/esm/factory/validators.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.d.mts","names":[],"sources":["../../../../../../@warlock.js/seal/src/factory/validators.ts"],"mappings":"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"}

package/esm/factory/validators.mjs

@@ -0,0 +1,132 @@
+import { validate } from "./validate.mjs";
+import { AnyValidator } from "../validators/any-validator.mjs";
+import { ArrayValidator } from "../validators/array-validator.mjs";
+import "../validators/methods/equality-conditional-methods.mjs";
+import "../validators/methods/forbidden-methods.mjs";
+import "../validators/methods/present-methods.mjs";
+import "../validators/methods/required-methods.mjs";
+import { BooleanValidator } from "../validators/boolean-validator.mjs";
+import { ComputedValidator } from "../validators/computed-validator.mjs";
+import { DateValidator } from "../validators/date-validator.mjs";
+import { LiteralValidator } from "../validators/literal-validator.mjs";
+import { DiscriminatedUnionValidator } from "../validators/discriminated-union-validator.mjs";
+import { NumberValidator } from "../validators/number-validator.mjs";
+import { FloatValidator } from "../validators/float-validator.mjs";
+import { InstanceOfValidator } from "../validators/instanceof-validator.mjs";
+import { IntValidator } from "../validators/int-validator.mjs";
+import { LazyValidator } from "../validators/lazy-validator.mjs";
+import { ManagedValidator } from "../validators/managed-validator.mjs";
+import { NumericValidator } from "../validators/numeric-validator.mjs";
+import { ObjectValidator } from "../validators/object-validator.mjs";
+import { RecordValidator } from "../validators/record-validator.mjs";
+import { ScalarValidator } from "../validators/scalar-validator.mjs";
+import { StringValidator } from "../validators/string-validator.mjs";
+import { TupleValidator } from "../validators/tuple-validator.mjs";
+import { UnionValidator } from "../validators/union-validator.mjs";
+
+//#region ../../@warlock.js/seal/src/factory/validators.ts
+/**
+* Seal factory object - creates instances of validators
+*
+* Use 'v' to create validation schemas (seals) for your data
+*/
+const v = {
+	/** Create an object validator */
+	object: (schema, errorMessage) => new ObjectValidator(schema, errorMessage),
+	/** Create an any validator */
+	any: () => new AnyValidator(),
+	/** Create an array validator */
+	array: (validator, errorMessage) => new ArrayValidator(validator, errorMessage),
+	/** Create a record validator - object with dynamic keys and consistent value types */
+	record: (validator, errorMessage) => new RecordValidator(validator || v.any(), errorMessage),
+	/** Create a tuple validator - fixed-length array with position-specific types */
+	tuple: (validators, errorMessage) => new TupleValidator(validators, errorMessage),
+	/** Create a date validator */
+	date: (errorMessage) => new DateValidator(errorMessage),
+	/**
+	* Create a literal validator — narrows to the union of given literal values
+	*
+	* @example
+	* v.literal("items")               // type: "items"
+	* v.literal("draft", "published")  // type: "draft" | "published"
+	* v.literal(1, 2, 3)               // type: 1 | 2 | 3
+	*/
+	literal: (...values) => new LiteralValidator(values),
+	/**
+	* Create an instanceof validator — value must be `instanceof` the constructor
+	*
+	* @example
+	* v.instanceof(File)        // type: File
+	* v.instanceof(Buffer)      // type: Buffer
+	* v.instanceof(MyClass)     // type: MyClass
+	*/
+	instanceof: (ctor, errorMessage) => new InstanceOfValidator(ctor, errorMessage),
+	/**
+	* Create a lazy validator — defers resolution of the inner validator until
+	* validate-time. Use for recursive or forward-referenced schemas.
+	*
+	* @example
+	* type Category = { name: string; children: Category[] };
+	*
+	* const category: ObjectValidator<...> = v.object({
+	*   name: v.string(),
+	*   children: v.array(v.lazy(() => category)),
+	* });
+	*/
+	lazy: (thunk) => new LazyValidator(thunk),
+	/** Create a string validator */
+	string: (errorMessage) => new StringValidator(errorMessage),
+	/** Create an email validator */
+	email: (emailErrorMessage, errorMessage) => new StringValidator(errorMessage).email(emailErrorMessage),
+	/**
+	* Create an enum validator — preserves the literal union of accepted
+	* values in the inferred Standard Schema output.
+	*
+	* Two input shapes:
+	* - Tuple of literals: `v.enum(["draft", "published"])` →
+	*   `StandardSchemaV1<"draft" | "published">`
+	* - TypeScript enum object: `v.enum(Status)` →
+	*   `StandardSchemaV1<Status[keyof Status]>`
+	*
+	* Implementation is loosely typed; the public `ValidatorV.enum`
+	* surface declares the precise overloads.
+	*/
+	enum: ((values, errorMessage) => Array.isArray(values) ? new StringValidator().oneOf(values, errorMessage) : new ScalarValidator().enum(values, errorMessage)),
+	/** Create a number validator */
+	number: (errorMessage) => new NumberValidator(errorMessage),
+	/** Create a numeric validator */
+	numeric: (errorMessage) => new NumericValidator(errorMessage),
+	/** Create an integer validator */
+	int: (errorMessage) => new IntValidator(errorMessage),
+	/** Create a float validator */
+	float: (errorMessage) => new FloatValidator(errorMessage),
+	/** Create a boolean validator */
+	boolean: (errorMessage) => new BooleanValidator(errorMessage),
+	/** Create a scalar validator */
+	scalar: (errorMessage) => new ScalarValidator(errorMessage),
+	/** Create a union validator - validates against multiple types */
+	union: (validators, errorMessage) => new UnionValidator().union(validators, errorMessage),
+	/**
+	* Create a discriminated union — routes payloads by a shared literal
+	* discriminator field. Each branch must be a `v.object(...)` with the
+	* discriminator typed as `v.literal(...)`.
+	*
+	* @example
+	* const email = v.object({ type: v.literal("email"), email: v.string().email() });
+	* const sms   = v.object({ type: v.literal("sms"),   phone: v.string() });
+	* const notif = v.discriminatedUnion("type", [email, sms]);
+	* // type T = Infer<typeof notif>;
+	* // → { type: "email", email: string } | { type: "sms", phone: string }
+	*/
+	discriminatedUnion: (discriminator, validators) => new DiscriminatedUnionValidator(discriminator, validators),
+	/** Create a computed field validator - derives value from other validated fields */
+	computed: (callback, resultValidator) => new ComputedValidator(callback, resultValidator),
+	/** Create a managed field validator - framework-injected value */
+	managed: (callback, resultValidator) => new ManagedValidator(callback, resultValidator),
+	/** Validate data against a schema */
+	validate
+};
+
+//#endregion
+export { v };
+//# sourceMappingURL=validators.mjs.map

package/esm/factory/validators.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.mjs","names":["validateFunction"],"sources":["../../../../../../@warlock.js/seal/src/factory/validators.ts"],"sourcesContent":["import { SealConfig } from \"../config\";\nimport type { StandardSchemaV1 } from \"../standard-schema/types\";\nimport type { Schema, SchemaContext, ValidationResult } from \"../types\";\nimport type { Infer } from \"../types/inference-types\";\nimport { AnyValidator } from \"../validators/any-validator\";\nimport { ArrayValidator } from \"../validators/array-validator\";\nimport type { BaseValidator } from \"../validators/base-validator\";\nimport { BooleanValidator } from \"../validators/boolean-validator\";\nimport { ComputedValidator } from \"../validators/computed-validator\";\nimport { DateValidator } from \"../validators/date-validator\";\nimport { DiscriminatedUnionValidator } from \"../validators/discriminated-union-validator\";\nimport { FloatValidator } from \"../validators/float-validator\";\nimport { InstanceOfValidator } from \"../validators/instanceof-validator\";\nimport { IntValidator } from \"../validators/int-validator\";\nimport { LazyValidator } from \"../validators/lazy-validator\";\nimport { LiteralValidator } from \"../validators/literal-validator\";\nimport { ManagedValidator } from \"../validators/managed-validator\";\nimport { NumberValidator } from \"../validators/number-validator\";\nimport { NumericValidator } from \"../validators/numeric-validator\";\nimport { ObjectValidator } from \"../validators/object-validator\";\nimport { RecordValidator } from \"../validators/record-validator\";\nimport { ScalarValidator } from \"../validators/scalar-validator\";\nimport { StringValidator } from \"../validators/string-validator\";\nimport { TupleValidator } from \"../validators/tuple-validator\";\nimport { UnionValidator } from \"../validators/union-validator\";\n// BaseValidator prototype augmentations — side-effect imports so the `v`\n// factory always exposes the chain methods (.required, .requiredIf, .sameAs,\n// .present, .forbidden, .when, …) regardless of which entry path loaded it.\n// The package barrel (src/index.ts) loads these via the validators barrel, but\n// importing the factory leaf directly would otherwise yield a half-built `v`.\nimport \"../validators/methods/equality-conditional-methods\";\nimport \"../validators/methods/forbidden-methods\";\nimport \"../validators/methods/present-methods\";\nimport \"../validators/methods/required-methods\";\nimport { validate as validateFunction } from \"./validate\";\n\n/**\n * Seal factory object - creates instances of validators\n *\n * Use 'v' to create validation schemas (seals) for your data\n */\nexport const v: ValidatorV = {\n  /** Create an object validator */\n  object: <T extends Schema>(schema: T, errorMessage?: string) =>\n    new ObjectValidator<T>(schema, errorMessage) as ObjectValidator<T> &\n      StandardSchemaV1<Infer<ObjectValidator<T>>>,\n\n  /** Create an any validator */\n  any: () => new AnyValidator() as AnyValidator & StandardSchemaV1<any>,\n\n  /** Create an array validator */\n  array: <T extends BaseValidator>(validator: T, errorMessage?: string) =>\n    new ArrayValidator(validator, errorMessage) as ArrayValidator & {\n      validator: T;\n    } & StandardSchemaV1<Array<Infer<T>>>,\n\n  /** Create a record validator - object with dynamic keys and consistent value types */\n  record: <T extends BaseValidator>(validator?: T, errorMessage?: string) =>\n    new RecordValidator(validator || v.any(), errorMessage) as RecordValidator & {\n      valueValidator: T;\n    } & StandardSchemaV1<Record<string, Infer<T>>>,\n\n  /** Create a tuple validator - fixed-length array with position-specific types */\n  tuple: <T extends BaseValidator[]>(validators: T, errorMessage?: string) =>\n    new TupleValidator(validators, errorMessage) as TupleValidator & {\n      validators: T;\n    } & StandardSchemaV1<{ [K in keyof T]: Infer<T[K]> }>,\n\n  /** Create a date validator */\n  date: (errorMessage?: string) =>\n    new DateValidator(errorMessage) as DateValidator & StandardSchemaV1<Date>,\n\n  /**\n   * Create a literal validator — narrows to the union of given literal values\n   *\n   * @example\n   * v.literal(\"items\")               // type: \"items\"\n   * v.literal(\"draft\", \"published\")  // type: \"draft\" | \"published\"\n   * v.literal(1, 2, 3)               // type: 1 | 2 | 3\n   */\n  literal: <T extends readonly [string | number | boolean, ...(string | number | boolean)[]]>(\n    ...values: T\n  ) =>\n    new LiteralValidator<T>(values) as LiteralValidator<T> & StandardSchemaV1<T[number]>,\n\n  /**\n   * Create an instanceof validator — value must be `instanceof` the constructor\n   *\n   * @example\n   * v.instanceof(File)        // type: File\n   * v.instanceof(Buffer)      // type: Buffer\n   * v.instanceof(MyClass)     // type: MyClass\n   */\n  instanceof: <T>(ctor: new (...args: any[]) => T, errorMessage?: string) =>\n    new InstanceOfValidator<T>(ctor, errorMessage) as InstanceOfValidator<T> &\n      StandardSchemaV1<T>,\n\n  /**\n   * Create a lazy validator — defers resolution of the inner validator until\n   * validate-time. Use for recursive or forward-referenced schemas.\n   *\n   * @example\n   * type Category = { name: string; children: Category[] };\n   *\n   * const category: ObjectValidator<...> = v.object({\n   *   name: v.string(),\n   *   children: v.array(v.lazy(() => category)),\n   * });\n   */\n  lazy: <T extends BaseValidator>(thunk: () => T) =>\n    new LazyValidator(thunk) as LazyValidator<T> & StandardSchemaV1<Infer<T>>,\n\n  /** Create a string validator */\n  string: (errorMessage?: string) =>\n    new StringValidator(errorMessage) as StringValidator & StandardSchemaV1<string>,\n\n  /** Create an email validator */\n  email: (emailErrorMessage?: string, errorMessage?: string) =>\n    new StringValidator(errorMessage).email(emailErrorMessage) as StringValidator &\n      StandardSchemaV1<string>,\n\n  /**\n   * Create an enum validator — preserves the literal union of accepted\n   * values in the inferred Standard Schema output.\n   *\n   * Two input shapes:\n   * - Tuple of literals: `v.enum([\"draft\", \"published\"])` →\n   *   `StandardSchemaV1<\"draft\" | \"published\">`\n   * - TypeScript enum object: `v.enum(Status)` →\n   *   `StandardSchemaV1<Status[keyof Status]>`\n   *\n   * Implementation is loosely typed; the public `ValidatorV.enum`\n   * surface declares the precise overloads.\n   */\n  enum: ((values: any, errorMessage?: string) =>\n    Array.isArray(values)\n      ? new StringValidator().oneOf(values, errorMessage)\n      : new ScalarValidator().enum(values, errorMessage)) as ValidatorV[\"enum\"],\n\n  /** Create a number validator */\n  number: (errorMessage?: string) =>\n    new NumberValidator(errorMessage) as NumberValidator & StandardSchemaV1<number>,\n\n  /** Create a numeric validator */\n  numeric: (errorMessage?: string) =>\n    new NumericValidator(errorMessage) as NumericValidator & StandardSchemaV1<number>,\n\n  /** Create an integer validator */\n  int: (errorMessage?: string) =>\n    new IntValidator(errorMessage) as IntValidator & StandardSchemaV1<number>,\n\n  /** Create a float validator */\n  float: (errorMessage?: string) =>\n    new FloatValidator(errorMessage) as FloatValidator & StandardSchemaV1<number>,\n\n  /** Create a boolean validator */\n  boolean: (errorMessage?: string) =>\n    new BooleanValidator(errorMessage) as BooleanValidator & StandardSchemaV1<boolean>,\n\n  /** Create a scalar validator */\n  scalar: (errorMessage?: string) =>\n    new ScalarValidator(errorMessage) as ScalarValidator &\n      StandardSchemaV1<string | number | boolean>,\n\n  /** Create a union validator - validates against multiple types */\n  union: <T extends BaseValidator[]>(validators: T, errorMessage?: string) =>\n    new UnionValidator().union(validators, errorMessage) as UnionValidator &\n      StandardSchemaV1<Infer<T[number]>>,\n\n  /**\n   * Create a discriminated union — routes payloads by a shared literal\n   * discriminator field. Each branch must be a `v.object(...)` with the\n   * discriminator typed as `v.literal(...)`.\n   *\n   * @example\n   * const email = v.object({ type: v.literal(\"email\"), email: v.string().email() });\n   * const sms   = v.object({ type: v.literal(\"sms\"),   phone: v.string() });\n   * const notif = v.discriminatedUnion(\"type\", [email, sms]);\n   * // type T = Infer<typeof notif>;\n   * // → { type: \"email\", email: string } | { type: \"sms\", phone: string }\n   */\n  discriminatedUnion: <\n    K extends string,\n    Branches extends ReadonlyArray<ObjectValidator<any>>,\n  >(\n    discriminator: K,\n    validators: Branches,\n  ) =>\n    new DiscriminatedUnionValidator(discriminator, validators) as DiscriminatedUnionValidator<\n      K,\n      Branches\n    > &\n      StandardSchemaV1<Infer<Branches[number]>>,\n\n  /** Create a computed field validator - derives value from other validated fields */\n  computed: <TResult = any>(\n    callback: (data: any, context: SchemaContext) => TResult | Promise<TResult>,\n    resultValidator?: BaseValidator,\n  ) =>\n    new ComputedValidator<TResult>(callback, resultValidator) as ComputedValidator<TResult> &\n      StandardSchemaV1<TResult>,\n\n  /** Create a managed field validator - framework-injected value */\n  managed: <TResult = any>(\n    callback: (context: SchemaContext) => TResult | Promise<TResult>,\n    resultValidator?: BaseValidator,\n  ) =>\n    new ManagedValidator<TResult>(callback, resultValidator) as ManagedValidator<TResult> &\n      StandardSchemaV1<TResult>,\n\n  /** Validate data against a schema */\n  validate: validateFunction,\n} as unknown as ValidatorV;\n\nexport type ValidateOptions = {\n  context?: Record<string, any>;\n} & SealConfig;\n\nexport interface ValidatorV {\n  object: <T extends Schema>(\n    schema: T,\n    errorMessage?: string,\n  ) => ObjectValidator<T> & StandardSchemaV1<Infer<ObjectValidator<T>>>;\n  any: () => AnyValidator & StandardSchemaV1<any>;\n  array: <T extends BaseValidator>(\n    validator: T,\n    errorMessage?: string,\n  ) => ArrayValidator & {\n    validator: T;\n  } & StandardSchemaV1<Array<Infer<T>>>;\n  record: <T extends BaseValidator>(\n    validator?: T,\n    errorMessage?: string,\n  ) => RecordValidator & {\n    valueValidator: T;\n  } & StandardSchemaV1<Record<string, Infer<T>>>;\n  tuple: <T extends BaseValidator[]>(\n    validators: T,\n    errorMessage?: string,\n  ) => TupleValidator & {\n    validators: T;\n  } & StandardSchemaV1<{ [K in keyof T]: Infer<T[K]> }>;\n  date: (errorMessage?: string) => DateValidator & StandardSchemaV1<Date>;\n  literal: <T extends readonly [string | number | boolean, ...(string | number | boolean)[]]>(\n    ...values: T\n  ) => LiteralValidator<T> & StandardSchemaV1<T[number]>;\n  instanceof: <T>(\n    ctor: new (...args: any[]) => T,\n    errorMessage?: string,\n  ) => InstanceOfValidator<T> & StandardSchemaV1<T>;\n  lazy: <T extends BaseValidator>(\n    thunk: () => T,\n  ) => LazyValidator<T> & StandardSchemaV1<Infer<T>>;\n  string: (errorMessage?: string) => StringValidator & StandardSchemaV1<string>;\n  email: (errorMessage?: string) => StringValidator & StandardSchemaV1<string>;\n  enum: {\n    <const T extends readonly (string | number | boolean)[]>(\n      values: T,\n      errorMessage?: string,\n    ): ScalarValidator & StandardSchemaV1<T[number]>;\n    <const T extends Record<string, string | number>>(\n      values: T,\n      errorMessage?: string,\n    ): ScalarValidator & StandardSchemaV1<T[keyof T]>;\n  };\n  number: (errorMessage?: string) => NumberValidator & StandardSchemaV1<number>;\n  numeric: (errorMessage?: string) => NumericValidator & StandardSchemaV1<number>;\n  int: (errorMessage?: string) => IntValidator & StandardSchemaV1<number>;\n  float: (errorMessage?: string) => FloatValidator & StandardSchemaV1<number>;\n  boolean: (errorMessage?: string) => BooleanValidator & StandardSchemaV1<boolean>;\n  scalar: (\n    errorMessage?: string,\n  ) => ScalarValidator & StandardSchemaV1<string | number | boolean>;\n  union: <T extends BaseValidator[]>(\n    validators: T,\n    errorMessage?: string,\n  ) => UnionValidator & StandardSchemaV1<Infer<T[number]>>;\n  discriminatedUnion: <\n    K extends string,\n    Branches extends ReadonlyArray<ObjectValidator<any>>,\n  >(\n    discriminator: K,\n    validators: Branches,\n  ) => DiscriminatedUnionValidator<K, Branches> & StandardSchemaV1<Infer<Branches[number]>>;\n  computed: <TResult = any>(\n    callback: (data: any, context: SchemaContext) => TResult | Promise<TResult>,\n    resultValidator?: BaseValidator,\n  ) => ComputedValidator<TResult> & StandardSchemaV1<TResult>;\n  managed: <TResult = any>(\n    callback?: (context: SchemaContext) => TResult | Promise<TResult>,\n    resultValidator?: BaseValidator,\n  ) => ManagedValidator<TResult> & StandardSchemaV1<TResult>;\n  validate: <T extends BaseValidator>(\n    schema: T,\n    data: any,\n    options?: ValidateOptions,\n  ) => Promise<ValidationResult>;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,MAAa,IAAgB;;CAE3B,SAA2B,QAAW,iBACpC,IAAI,gBAAmB,QAAQ,YAAY;;CAI7C,WAAW,IAAI,aAAa;;CAG5B,QAAiC,WAAc,iBAC7C,IAAI,eAAe,WAAW,YAAY;;CAK5C,SAAkC,WAAe,iBAC/C,IAAI,gBAAgB,aAAa,EAAE,IAAI,GAAG,YAAY;;CAKxD,QAAmC,YAAe,iBAChD,IAAI,eAAe,YAAY,YAAY;;CAK7C,OAAO,iBACL,IAAI,cAAc,YAAY;;;;;;;;;CAUhC,UACE,GAAG,WAEH,IAAI,iBAAoB,MAAM;;;;;;;;;CAUhC,aAAgB,MAAiC,iBAC/C,IAAI,oBAAuB,MAAM,YAAY;;;;;;;;;;;;;CAe/C,OAAgC,UAC9B,IAAI,cAAc,KAAK;;CAGzB,SAAS,iBACP,IAAI,gBAAgB,YAAY;;CAGlC,QAAQ,mBAA4B,iBAClC,IAAI,gBAAgB,YAAY,EAAE,MAAM,iBAAiB;;;;;;;;;;;;;;CAgB3D,QAAQ,QAAa,iBACnB,MAAM,QAAQ,MAAM,IAChB,IAAI,gBAAgB,EAAE,MAAM,QAAQ,YAAY,IAChD,IAAI,gBAAgB,EAAE,KAAK,QAAQ,YAAY;;CAGrD,SAAS,iBACP,IAAI,gBAAgB,YAAY;;CAGlC,UAAU,iBACR,IAAI,iBAAiB,YAAY;;CAGnC,MAAM,iBACJ,IAAI,aAAa,YAAY;;CAG/B,QAAQ,iBACN,IAAI,eAAe,YAAY;;CAGjC,UAAU,iBACR,IAAI,iBAAiB,YAAY;;CAGnC,SAAS,iBACP,IAAI,gBAAgB,YAAY;;CAIlC,QAAmC,YAAe,iBAChD,IAAI,eAAe,EAAE,MAAM,YAAY,YAAY;;;;;;;;;;;;;CAerD,qBAIE,eACA,eAEA,IAAI,4BAA4B,eAAe,UAAU;;CAO3D,WACE,UACA,oBAEA,IAAI,kBAA2B,UAAU,eAAe;;CAI1D,UACE,UACA,oBAEA,IAAI,iBAA0B,UAAU,eAAe;;CAI/CA;AACZ"}

package/esm/helpers/date-helpers.d.mts

@@ -0,0 +1,19 @@
+//#region ../../@warlock.js/seal/src/helpers/date-helpers.d.ts
+/**
+ * Detect if value is a date value or field name
+ *
+ * Date values:
+ * - Date instance
+ * - Number (timestamp)
+ * - String with date separators (- or /)
+ *
+ * Field names:
+ * - Strings without - or /
+ *
+ * @param value - Value to check
+ * @returns true if it's a date value, false if it's a field name
+ */
+declare function isDateValue(value: any): boolean;
+//#endregion
+export { isDateValue };
+//# sourceMappingURL=date-helpers.d.mts.map

package/esm/helpers/date-helpers.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-helpers.d.mts","names":[],"sources":["../../../../../../@warlock.js/seal/src/helpers/date-helpers.ts"],"mappings":";;AAcA;;;;AAAsC;;;;;;;;;iBAAtB,WAAA,CAAY,KAAU"}

package/esm/helpers/date-helpers.mjs

@@ -0,0 +1,24 @@
+//#region ../../@warlock.js/seal/src/helpers/date-helpers.ts
+/**
+* Detect if value is a date value or field name
+*
+* Date values:
+* - Date instance
+* - Number (timestamp)
+* - String with date separators (- or /)
+*
+* Field names:
+* - Strings without - or /
+*
+* @param value - Value to check
+* @returns true if it's a date value, false if it's a field name
+*/
+function isDateValue(value) {
+	if (value instanceof Date) return true;
+	const date = new Date(value);
+	return !isNaN(date.getTime());
+}
+
+//#endregion
+export { isDateValue };
+//# sourceMappingURL=date-helpers.mjs.map

package/esm/helpers/date-helpers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-helpers.mjs","names":[],"sources":["../../../../../../@warlock.js/seal/src/helpers/date-helpers.ts"],"sourcesContent":["/**\r\n * Detect if value is a date value or field name\r\n *\r\n * Date values:\r\n * - Date instance\r\n * - Number (timestamp)\r\n * - String with date separators (- or /)\r\n *\r\n * Field names:\r\n * - Strings without - or /\r\n *\r\n * @param value - Value to check\r\n * @returns true if it's a date value, false if it's a field name\r\n */\r\nexport function isDateValue(value: any): boolean {\r\n  if (value instanceof Date) return true;\r\n\r\n  const date = new Date(value);\r\n\r\n  return !isNaN(date.getTime());\r\n}\r\n"],"mappings":";;;;;;;;;;;;;;;AAcA,SAAgB,YAAY,OAAqB;CAC/C,IAAI,iBAAiB,MAAM,OAAO;CAElC,MAAM,OAAO,IAAI,KAAK,KAAK;CAE3B,OAAO,CAAC,MAAM,KAAK,QAAQ,CAAC;AAC9B"}

package/esm/helpers/file.utils.d.mts

@@ -0,0 +1,12 @@
+import { FileSizeOption } from "../types/file.types.mjs";
+
+//#region ../../@warlock.js/seal/src/helpers/file.utils.d.ts
+declare function resolveFileSize(size: number | FileSizeOption): number;
+/**
+ * Convert the given size to a human size
+ * i.e 2MB, 0.5MB, 120KB, 1.5GB..etc
+ */
+declare function humanizeSize(sizeInBits: number): string;
+//#endregion
+export { humanizeSize, resolveFileSize };
+//# sourceMappingURL=file.utils.d.mts.map

package/esm/helpers/file.utils.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file.utils.d.mts","names":[],"sources":["../../../../../../@warlock.js/seal/src/helpers/file.utils.ts"],"mappings":";;;iBAEgB,eAAA,CAAgB,IAA6B,WAAd,cAAc;;AAA7D;;;iBAqBgB,YAAA,CAAa,UAAkB"}

package/esm/helpers/file.utils.mjs

@@ -0,0 +1,33 @@
+//#region ../../@warlock.js/seal/src/helpers/file.utils.ts
+function resolveFileSize(size) {
+	if (typeof size === "number") return size;
+	switch (size.unit) {
+		case "B": return size.size;
+		case "KB": return size.size * 1024;
+		case "MB": return size.size * 1024 * 1024;
+		case "GB": return size.size * 1024 * 1024 * 1024;
+	}
+}
+/**
+* Convert the given size to a human size
+* i.e 2MB, 0.5MB, 120KB, 1.5GB..etc
+*/
+function humanizeSize(sizeInBits) {
+	const units = [
+		"B",
+		"KB",
+		"MB",
+		"GB"
+	];
+	let size = sizeInBits;
+	let unitIndex = 0;
+	while (size >= 1024 && unitIndex < units.length - 1) {
+		size /= 1024;
+		unitIndex++;
+	}
+	return `${Number.isInteger(size) ? size : size.toFixed(2)}${units[unitIndex]}`;
+}
+
+//#endregion
+export { humanizeSize, resolveFileSize };
+//# sourceMappingURL=file.utils.mjs.map

package/esm/helpers/file.utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"file.utils.mjs","names":[],"sources":["../../../../../../@warlock.js/seal/src/helpers/file.utils.ts"],"sourcesContent":["import type { FileSizeOption } from \"../types/file.types\";\n\nexport function resolveFileSize(size: number | FileSizeOption): number {\n  if (typeof size === \"number\") {\n    return size;\n  }\n\n  switch (size.unit) {\n    case \"B\":\n      return size.size;\n    case \"KB\":\n      return size.size * 1024;\n    case \"MB\":\n      return size.size * 1024 * 1024;\n    case \"GB\":\n      return size.size * 1024 * 1024 * 1024;\n  }\n}\n\n/**\n * Convert the given size to a human size\n * i.e 2MB, 0.5MB, 120KB, 1.5GB..etc\n */\nexport function humanizeSize(sizeInBits: number): string {\n  const units = [\"B\", \"KB\", \"MB\", \"GB\"];\n  let size = sizeInBits;\n  let unitIndex = 0;\n\n  while (size >= 1024 && unitIndex < units.length - 1) {\n    size /= 1024;\n    unitIndex++;\n  }\n\n  return `${Number.isInteger(size) ? size : size.toFixed(2)}${units[unitIndex]}`;\n}\n"],"mappings":";AAEA,SAAgB,gBAAgB,MAAuC;CACrE,IAAI,OAAO,SAAS,UAClB,OAAO;CAGT,QAAQ,KAAK,MAAb;EACE,KAAK,KACH,OAAO,KAAK;EACd,KAAK,MACH,OAAO,KAAK,OAAO;EACrB,KAAK,MACH,OAAO,KAAK,OAAO,OAAO;EAC5B,KAAK,MACH,OAAO,KAAK,OAAO,OAAO,OAAO;CACrC;AACF;;;;;AAMA,SAAgB,aAAa,YAA4B;CACvD,MAAM,QAAQ;EAAC;EAAK;EAAM;EAAM;CAAI;CACpC,IAAI,OAAO;CACX,IAAI,YAAY;CAEhB,OAAO,QAAQ,QAAQ,YAAY,MAAM,SAAS,GAAG;EACnD,QAAQ;EACR;CACF;CAEA,OAAO,GAAG,OAAO,UAAU,IAAI,IAAI,OAAO,KAAK,QAAQ,CAAC,IAAI,MAAM;AACpE"}

package/esm/helpers/get-field-value.d.mts

@@ -0,0 +1,42 @@
+import { ContextualSchemaRule } from "../types/rule-types.mjs";
+import { SchemaContext } from "../types/context-types.mjs";
+
+//#region ../../@warlock.js/seal/src/helpers/get-field-value.d.ts
+/**
+ * Get field value based on scope from rule options
+ *
+ * This utility extracts a field value from either the global context or sibling context
+ * based on the `scope` option in the rule's context.
+ *
+ * @param rule - The contextual schema rule containing options with:
+ *   - `field` (or custom fieldKey): The field name to extract
+ *   - `scope` (optional): Either "global" (default) or "sibling"
+ * @param context - The schema validation context containing allValues and parent
+ * @param fieldKey - The key in rule.context.options that contains the field name (defaults to "field")
+ *
+ * @returns The value of the specified field from the appropriate source
+ *
+ * @example
+ * // In a validation rule with scope support:
+ * async validate(value: any, context) {
+ *   const otherFieldValue = getFieldValue(this, context);
+ *   // Extracts from context.allValues if scope is "global"
+ *   // Extracts from context.parent if scope is "sibling"
+ * }
+ *
+ * @example
+ * // Using a custom field key:
+ * async validate(value: any, context) {
+ *   const compareValue = getFieldValue(this, context, "compareField");
+ *   // Looks for rule.context.options.compareField instead of .field
+ * }
+ *
+ * @remarks
+ * - **Global scope** (`scope: "global"`): Searches the entire input data (context.allValues)
+ * - **Sibling scope** (`scope: "sibling"`): Searches only within the parent object (context.parent)
+ * - Uses `@mongez/reinforcements.get()` to support nested paths (e.g., "user.email")
+ */
+declare function getFieldValue(rule: ContextualSchemaRule, context: SchemaContext, fieldKey?: string): any;
+//#endregion
+export { getFieldValue };
+//# sourceMappingURL=get-field-value.d.mts.map

package/esm/helpers/get-field-value.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-field-value.d.mts","names":[],"sources":["../../../../../../@warlock.js/seal/src/helpers/get-field-value.ts"],"mappings":";;;;;;;AAqCA;;;;;;;;;;AAGoB;;;;;;;;;;;;;;;;;;;;;iBAHJ,aAAA,CACd,IAAA,EAAM,oBAAA,EACN,OAAA,EAAS,aAAa,EACtB,QAAA"}

package/esm/helpers/get-field-value.mjs

@@ -0,0 +1,45 @@
+import { get } from "@mongez/reinforcements";
+
+//#region ../../@warlock.js/seal/src/helpers/get-field-value.ts
+/**
+* Get field value based on scope from rule options
+*
+* This utility extracts a field value from either the global context or sibling context
+* based on the `scope` option in the rule's context.
+*
+* @param rule - The contextual schema rule containing options with:
+*   - `field` (or custom fieldKey): The field name to extract
+*   - `scope` (optional): Either "global" (default) or "sibling"
+* @param context - The schema validation context containing allValues and parent
+* @param fieldKey - The key in rule.context.options that contains the field name (defaults to "field")
+*
+* @returns The value of the specified field from the appropriate source
+*
+* @example
+* // In a validation rule with scope support:
+* async validate(value: any, context) {
+*   const otherFieldValue = getFieldValue(this, context);
+*   // Extracts from context.allValues if scope is "global"
+*   // Extracts from context.parent if scope is "sibling"
+* }
+*
+* @example
+* // Using a custom field key:
+* async validate(value: any, context) {
+*   const compareValue = getFieldValue(this, context, "compareField");
+*   // Looks for rule.context.options.compareField instead of .field
+* }
+*
+* @remarks
+* - **Global scope** (`scope: "global"`): Searches the entire input data (context.allValues)
+* - **Sibling scope** (`scope: "sibling"`): Searches only within the parent object (context.parent)
+* - Uses `@mongez/reinforcements.get()` to support nested paths (e.g., "user.email")
+*/
+function getFieldValue(rule, context, fieldKey = "field") {
+	const field = rule.context.options[fieldKey];
+	return get((rule.context.options.scope || "global") === "sibling" ? context.parent : context.allValues, field);
+}
+
+//#endregion
+export { getFieldValue };
+//# sourceMappingURL=get-field-value.mjs.map

package/esm/helpers/get-field-value.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-field-value.mjs","names":[],"sources":["../../../../../../@warlock.js/seal/src/helpers/get-field-value.ts"],"sourcesContent":["import { get } from \"@mongez/reinforcements\";\r\nimport type { ContextualSchemaRule, SchemaContext } from \"../types\";\r\n\r\n/**\r\n * Get field value based on scope from rule options\r\n *\r\n * This utility extracts a field value from either the global context or sibling context\r\n * based on the `scope` option in the rule's context.\r\n *\r\n * @param rule - The contextual schema rule containing options with:\r\n *   - `field` (or custom fieldKey): The field name to extract\r\n *   - `scope` (optional): Either \"global\" (default) or \"sibling\"\r\n * @param context - The schema validation context containing allValues and parent\r\n * @param fieldKey - The key in rule.context.options that contains the field name (defaults to \"field\")\r\n *\r\n * @returns The value of the specified field from the appropriate source\r\n *\r\n * @example\r\n * // In a validation rule with scope support:\r\n * async validate(value: any, context) {\r\n *   const otherFieldValue = getFieldValue(this, context);\r\n *   // Extracts from context.allValues if scope is \"global\"\r\n *   // Extracts from context.parent if scope is \"sibling\"\r\n * }\r\n *\r\n * @example\r\n * // Using a custom field key:\r\n * async validate(value: any, context) {\r\n *   const compareValue = getFieldValue(this, context, \"compareField\");\r\n *   // Looks for rule.context.options.compareField instead of .field\r\n * }\r\n *\r\n * @remarks\r\n * - **Global scope** (`scope: \"global\"`): Searches the entire input data (context.allValues)\r\n * - **Sibling scope** (`scope: \"sibling\"`): Searches only within the parent object (context.parent)\r\n * - Uses `@mongez/reinforcements.get()` to support nested paths (e.g., \"user.email\")\r\n */\r\nexport function getFieldValue(\r\n  rule: ContextualSchemaRule,\r\n  context: SchemaContext,\r\n  fieldKey = \"field\",\r\n) {\r\n  const field = rule.context.options[fieldKey];\r\n  const scope = rule.context.options.scope || \"global\";\r\n  const source = scope === \"sibling\" ? context.parent : context.allValues;\r\n  return get(source, field);\r\n}\r\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,SAAgB,cACd,MACA,SACA,WAAW,SACX;CACA,MAAM,QAAQ,KAAK,QAAQ,QAAQ;CAGnC,OAAO,KAFO,KAAK,QAAQ,QAAQ,SAAS,cACnB,YAAY,QAAQ,SAAS,QAAQ,WAC3C,KAAK;AAC1B"}