@warlock.js/notifications 5.31.0 → 5.33.0

package/esm/packages/herald/src/utils/connect-to-broker.mjs

@@ -1,168 +0,0 @@
-import { brokerRegistry } from "../communicators/broker-registry.mjs";
-import "../communicators/index.mjs";
-
-//#region ../../packages/herald/src/utils/connect-to-broker.ts
-/**
-* Connect to a message broker and register it.
-*
-* This is a high-level utility function that simplifies connection setup
-* for most projects. It handles driver instantiation, connection,
-* broker creation, and automatic registration.
-*
-* **Supported Drivers:**
-* - `rabbitmq` (default) - RabbitMQ/AMQP driver
-* - `kafka` - Apache Kafka driver (coming soon)
-*
-* @param options - Connection configuration options
-* @returns A connected and registered Broker instance
-* @throws {Error} If connection fails or driver is not implemented
-*
-* @example
-* ```typescript
-* // RabbitMQ connection
-* const broker = await connectToBroker({
-*   driver: "rabbitmq",
-*   host: "localhost",
-*   port: 5672,
-*   username: "guest",
-*   password: "guest",
-* });
-*
-* // Use the broker
-* await broker.channel("user.created").publish({ userId: 1 });
-* ```
-*
-* @example
-* ```typescript
-* // Multiple brokers
-* await connectToBroker({
-*   driver: "rabbitmq",
-*   name: "notifications",
-*   isDefault: true,
-*   host: process.env.RABBITMQ_HOST,
-* });
-*
-* await connectToBroker({
-*   driver: "rabbitmq",
-*   name: "analytics",
-*   host: process.env.ANALYTICS_RABBITMQ_HOST,
-* });
-*
-* // Use default broker
-* herald().channel("notifications").publish({ ... });
-*
-* // Use specific broker
-* herald("analytics").channel("events").publish({ ... });
-* ```
-*/
-async function connectToBroker(options) {
-	const driverType = options.driver ?? "rabbitmq";
-	const brokerName = options.name ?? "default";
-	const isDefault = options.isDefault ?? true;
-	let driver;
-	switch (driverType) {
-		case "rabbitmq": {
-			const rabbitOptions = options;
-			const { RabbitMQDriver } = await import("../drivers/rabbitmq/rabbitmq-driver.mjs");
-			driver = new RabbitMQDriver(rabbitOptions);
-			break;
-		}
-		case "kafka": throw new Error("Kafka driver is not yet implemented. Coming soon! For now, please use RabbitMQ.");
-		default: throw new Error(`Unknown driver: "${driverType}". Supported drivers: rabbitmq, kafka`);
-	}
-	const broker = brokerRegistry.register({
-		name: brokerName,
-		driver,
-		isDefault
-	});
-	try {
-		await driver.connect();
-	} catch (error) {
-		throw new Error(`Failed to connect to ${driverType}: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	return broker;
-}
-/**
-* Get a broker by name or the default one.
-*
-* This is the main entry point for using brokers in your application.
-* Named after the package — `herald()` carries your messages!
-*
-* @param name - Optional broker name (uses default if not provided)
-* @returns Broker instance
-* @throws MissingBrokerError if broker not found
-*
-* @example
-* // Get default broker
-* const channel = herald().channel("user.created");
-* await channel.publish({ userId: 1 });
-*
-* // Get specific broker
-* const analyticsChannel = herald("analytics").channel("events");
-* await analyticsChannel.publish({ event: "page_view" });
-*
-* // Subscribe to messages
-* herald()
-*   .channel<UserPayload>("user.created")
-*   .subscribe(async (message, ctx) => {
-*     console.log("User created:", message.payload);
-*     await ctx.ack();
-*   });
-* ```
-*/
-function herald(name) {
-	return brokerRegistry.get(name);
-}
-/**
-* Get channel instance for the given name from default broker.
-*
-* Shorthand for `herald().channel(name, options)`.
-*
-* @param name - Channel name
-* @param options - Optional channel options
-* @returns Channel instance
-* @throws MissingBrokerError if broker not found
-*
-* @example
-* ```typescript
-* const channel = heraldChannel("user.created");
-* await channel.publish({ userId: 1 });
-* ```
-*/
-function heraldChannel(name, options) {
-	return herald().channel(name, options);
-}
-/**
-* Publish an EventMessage to the default broker.
-*
-* @param event - Event message to publish
-* @returns Promise that resolves when the event is published
-* @throws Error if the broker is not connected
-*
-* @example
-* ```typescript
-* await publishEvent(new UserUpdatedEvent({ id: 1, name: "John Doe" }));
-* ```
-*/
-async function publishEvent(event) {
-	return herald().publish(event);
-}
-/**
-* Subscribe an EventConsumer class to the default broker.
-*
-* @param Consumer - Event consumer class
-* @returns Unsubscribe function
-* @throws MissingBrokerError if broker not found
-*
-* @example
-* ```typescript
-* await subscribeConsumer(UserUpdatedConsumer);
-* ```
-*/
-async function subscribeConsumer(Consumer) {
-	return herald().subscribe(Consumer);
-}
-
-//#endregion
-export { connectToBroker, herald, heraldChannel, publishEvent, subscribeConsumer };
-//# sourceMappingURL=connect-to-broker.mjs.map

package/esm/packages/herald/src/utils/connect-to-broker.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"connect-to-broker.mjs","names":[],"sources":["../../../../../../../../../../../packages/herald/src/utils/connect-to-broker.ts"],"sourcesContent":["import { Broker, brokerRegistry } from \"../communicators\";\nimport type { BrokerDriverContract, ChannelContract } from \"../contracts\";\nimport { type EventConsumerClass, EventMessage } from \"../message-managers\";\nimport type { ChannelOptions, ConnectionOptions, RabbitMQConnectionOptions } from \"../types\";\n\n/**\n * Connect to a message broker and register it.\n *\n * This is a high-level utility function that simplifies connection setup\n * for most projects. It handles driver instantiation, connection,\n * broker creation, and automatic registration.\n *\n * **Supported Drivers:**\n * - `rabbitmq` (default) - RabbitMQ/AMQP driver\n * - `kafka` - Apache Kafka driver (coming soon)\n *\n * @param options - Connection configuration options\n * @returns A connected and registered Broker instance\n * @throws {Error} If connection fails or driver is not implemented\n *\n * @example\n * ```typescript\n * // RabbitMQ connection\n * const broker = await connectToBroker({\n *   driver: \"rabbitmq\",\n *   host: \"localhost\",\n *   port: 5672,\n *   username: \"guest\",\n *   password: \"guest\",\n * });\n *\n * // Use the broker\n * await broker.channel(\"user.created\").publish({ userId: 1 });\n * ```\n *\n * @example\n * ```typescript\n * // Multiple brokers\n * await connectToBroker({\n *   driver: \"rabbitmq\",\n *   name: \"notifications\",\n *   isDefault: true,\n *   host: process.env.RABBITMQ_HOST,\n * });\n *\n * await connectToBroker({\n *   driver: \"rabbitmq\",\n *   name: \"analytics\",\n *   host: process.env.ANALYTICS_RABBITMQ_HOST,\n * });\n *\n * // Use default broker\n * herald().channel(\"notifications\").publish({ ... });\n *\n * // Use specific broker\n * herald(\"analytics\").channel(\"events\").publish({ ... });\n * ```\n */\nexport async function connectToBroker(options: ConnectionOptions): Promise<Broker> {\n  // Default values\n  const driverType = options.driver ?? \"rabbitmq\";\n  const brokerName = options.name ?? \"default\";\n  const isDefault = options.isDefault ?? true;\n\n  // Create driver based on type\n  let driver: BrokerDriverContract;\n\n  switch (driverType) {\n    case \"rabbitmq\": {\n      const rabbitOptions = options as RabbitMQConnectionOptions;\n      // Dynamic import to avoid requiring amqplib if not used\n      const { RabbitMQDriver } = await import(\"../drivers/rabbitmq/rabbitmq-driver\");\n      driver = new RabbitMQDriver(rabbitOptions);\n      break;\n    }\n\n    case \"kafka\": {\n      // const kafkaOptions = options as KafkaConnectionOptions;\n      // Dynamic import to avoid requiring kafkajs if not used\n      throw new Error(\n        \"Kafka driver is not yet implemented. Coming soon! For now, please use RabbitMQ.\",\n      );\n    }\n\n    default:\n      throw new Error(`Unknown driver: \"${driverType}\". Supported drivers: rabbitmq, kafka`);\n  }\n\n  // Create broker\n  const broker = brokerRegistry.register({\n    name: brokerName,\n    driver,\n    isDefault,\n  });\n\n  // Connect to the message broker\n  try {\n    await driver.connect();\n  } catch (error) {\n    throw new Error(\n      `Failed to connect to ${driverType}: ${error instanceof Error ? error.message : String(error)}`,\n    );\n  }\n\n  return broker;\n}\n\n/**\n * Get a broker by name or the default one.\n *\n * This is the main entry point for using brokers in your application.\n * Named after the package — `herald()` carries your messages!\n *\n * @param name - Optional broker name (uses default if not provided)\n * @returns Broker instance\n * @throws MissingBrokerError if broker not found\n *\n * @example\n * // Get default broker\n * const channel = herald().channel(\"user.created\");\n * await channel.publish({ userId: 1 });\n *\n * // Get specific broker\n * const analyticsChannel = herald(\"analytics\").channel(\"events\");\n * await analyticsChannel.publish({ event: \"page_view\" });\n *\n * // Subscribe to messages\n * herald()\n *   .channel<UserPayload>(\"user.created\")\n *   .subscribe(async (message, ctx) => {\n *     console.log(\"User created:\", message.payload);\n *     await ctx.ack();\n *   });\n * ```\n */\nexport function herald(name?: string): Broker {\n  return brokerRegistry.get(name);\n}\n\n/**\n * Get channel instance for the given name from default broker.\n *\n * Shorthand for `herald().channel(name, options)`.\n *\n * @param name - Channel name\n * @param options - Optional channel options\n * @returns Channel instance\n * @throws MissingBrokerError if broker not found\n *\n * @example\n * ```typescript\n * const channel = heraldChannel(\"user.created\");\n * await channel.publish({ userId: 1 });\n * ```\n */\nexport function heraldChannel<TPayload = unknown>(\n  name: string,\n  options?: ChannelOptions<TPayload>,\n): ChannelContract<TPayload> {\n  return herald().channel<TPayload>(name, options);\n}\n\n/**\n * Publish an EventMessage to the default broker.\n *\n * @param event - Event message to publish\n * @returns Promise that resolves when the event is published\n * @throws Error if the broker is not connected\n *\n * @example\n * ```typescript\n * await publishEvent(new UserUpdatedEvent({ id: 1, name: \"John Doe\" }));\n * ```\n */\nexport async function publishEvent<TPayload = Record<string, any>>(event: EventMessage<TPayload>) {\n  return herald().publish(event);\n}\n\n/**\n * Subscribe an EventConsumer class to the default broker.\n *\n * @param Consumer - Event consumer class\n * @returns Unsubscribe function\n * @throws MissingBrokerError if broker not found\n *\n * @example\n * ```typescript\n * await subscribeConsumer(UserUpdatedConsumer);\n * ```\n */\nexport async function subscribeConsumer<TPayload = Record<string, any>>(\n  Consumer: EventConsumerClass<TPayload>,\n) {\n  return herald().subscribe(Consumer);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DA,eAAsB,gBAAgB,SAA6C;CAEjF,MAAM,aAAa,QAAQ,UAAU;CACrC,MAAM,aAAa,QAAQ,QAAQ;CACnC,MAAM,YAAY,QAAQ,aAAa;CAGvC,IAAI;CAEJ,QAAQ,YAAR;EACE,KAAK,YAAY;GACf,MAAM,gBAAgB;GAEtB,MAAM,EAAE,mBAAmB,MAAM,OAAO;GACxC,SAAS,IAAI,eAAe,aAAa;GACzC;EACF;EAEA,KAAK,SAGH,MAAM,IAAI,MACR,iFACF;EAGF,SACE,MAAM,IAAI,MAAM,oBAAoB,WAAW,sCAAsC;CACzF;CAGA,MAAM,SAAS,eAAe,SAAS;EACrC,MAAM;EACN;EACA;CACF,CAAC;CAGD,IAAI;EACF,MAAM,OAAO,QAAQ;CACvB,SAAS,OAAO;EACd,MAAM,IAAI,MACR,wBAAwB,WAAW,IAAI,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,GAC9F;CACF;CAEA,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,SAAgB,OAAO,MAAuB;CAC5C,OAAO,eAAe,IAAI,IAAI;AAChC;;;;;;;;;;;;;;;;;AAkBA,SAAgB,cACd,MACA,SAC2B;CAC3B,OAAO,OAAO,CAAC,CAAC,QAAkB,MAAM,OAAO;AACjD;;;;;;;;;;;;;AAcA,eAAsB,aAA6C,OAA+B;CAChG,OAAO,OAAO,CAAC,CAAC,QAAQ,KAAK;AAC/B;;;;;;;;;;;;;AAcA,eAAsB,kBACpB,UACA;CACA,OAAO,OAAO,CAAC,CAAC,UAAU,QAAQ;AACpC"}

package/esm/packages/herald/src/utils/index.mjs

@@ -1,3 +0,0 @@
-import { connectToBroker, herald, heraldChannel, publishEvent, subscribeConsumer } from "./connect-to-broker.mjs";
-
-export {  };

package/esm/packages/seal/src/config.mjs

@@ -1,15 +0,0 @@
-//#region ../../packages/seal/src/config.ts
-/**
-* Global Seal configuration
-*/
-const config = { firstErrorOnly: true };
-/**
-* Get current Seal configuration
-*/
-function getSealConfig() {
-	return config;
-}
-
-//#endregion
-export { getSealConfig };
-//# sourceMappingURL=config.mjs.map

package/esm/packages/seal/src/config.mjs.map

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

package/esm/packages/seal/src/factory/index.mjs

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

package/esm/packages/seal/src/factory/validate.mjs

@@ -1,42 +0,0 @@
-import { getSealConfig } from "../config.mjs";
-
-//#region ../../packages/seal/src/factory/validate.ts
-/**
-* Validate data against a schema.
-*
-* The result narrows on `isValid`: on success `data` is the schema's
-* `Infer.Output`, on failure it is `undefined`.
-*/
-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
-	};
-	const result = await schema.validate(data, context);
-	if (!result.isValid) return {
-		isValid: false,
-		errors: result.errors,
-		data: void 0
-	};
-	return {
-		isValid: true,
-		errors: result.errors,
-		data: result.data
-	};
-};
-
-//#endregion
-export { validate };
-//# sourceMappingURL=validate.mjs.map

package/esm/packages/seal/src/factory/validate.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"validate.mjs","names":[],"sources":["../../../../../../../../../../../packages/seal/src/factory/validate.ts"],"sourcesContent":["import { getSealConfig } from \"../config\";\nimport type { SchemaContext, TypedValidationResult, ValidatedOutput } from \"../types\";\nimport type { BaseValidator } from \"../validators\";\nimport type { ValidateOptions } from \"./validators\";\n\n/**\n * Validate data against a schema.\n *\n * The result narrows on `isValid`: on success `data` is the schema's\n * `Infer.Output`, on failure it is `undefined`.\n */\nexport const validate = async <T extends BaseValidator>(\n  schema: T,\n  data: unknown,\n  { context: extendedContext, ...configurations }: ValidateOptions = getSealConfig() || {},\n): Promise<TypedValidationResult<ValidatedOutput<T>>> => {\n  const context: SchemaContext = {\n    allValues: data,\n    parent: null,\n    value: data,\n    key: \"\",\n    path: \"\",\n    context: extendedContext,\n    rootContext: extendedContext,\n    translateRule(ruleTranslation) {\n      return configurations.translateRule?.(ruleTranslation) ?? \"\";\n    },\n    translateAttribute(attributeTranslation) {\n      return configurations.translateAttribute?.(attributeTranslation) ?? \"\";\n    },\n    configurations,\n  };\n\n  const result = await schema.validate(data, context);\n\n  // A failed validation never hands back the input it just rejected.\n  //\n  // `object` used to return the raw input on failure while `discriminatedUnion`\n  // returned `undefined` — the same call shape with two different contracts.\n  // The object behaviour was the dangerous one: validating an outbound DTO\n  // specifically to keep internal fields out of a response, then doing the\n  // natural `const { data } = await v.validate(dto, record); reply.send(data)`,\n  // shipped every field the schema existed to exclude. A guard that returns the\n  // unsafe value on failure reads as safe and isn't.\n  if (!result.isValid) {\n    return { isValid: false, errors: result.errors, data: undefined };\n  }\n\n  return { isValid: true, errors: result.errors, data: result.data };\n};\n"],"mappings":";;;;;;;;;AAWA,MAAa,WAAW,OACtB,QACA,MACA,EAAE,SAAS,iBAAiB,GAAG,mBAAoC,cAAc,KAAK,CAAC,MAChC;CACvD,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,MAAM,SAAS,MAAM,OAAO,SAAS,MAAM,OAAO;CAWlD,IAAI,CAAC,OAAO,SACV,OAAO;EAAE,SAAS;EAAO,QAAQ,OAAO;EAAQ,MAAM;CAAU;CAGlE,OAAO;EAAE,SAAS;EAAM,QAAQ,OAAO;EAAQ,MAAM,OAAO;CAAK;AACnE"}

package/esm/packages/seal/src/factory/validators.mjs

@@ -1,139 +0,0 @@
-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 { 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 { object } from "../object.mjs";
-import { string } from "../string.mjs";
-
-//#region ../../packages/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,
-	/** 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.
-	*
-	* The `| []` in the constraint makes TypeScript infer a literal list as a tuple, so
-	* `v.tuple([v.string(), v.int()])` is typed `[string, number]` rather than
-	* `(string | number)[]`; a `BaseValidator[]` variable is still accepted.
-	*/
-	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,
-	/** 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 ScalarValidator().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/packages/seal/src/factory/validators.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"validators.mjs","names":["validateFunction"],"sources":["../../../../../../../../../../../packages/seal/src/factory/validators.ts"],"sourcesContent":["import type { SealConfig } from \"../config\";\nimport { object } from \"../object\";\nimport { string } from \"../string\";\nimport type { StandardSchemaV1 } from \"../standard-schema/types\";\nimport type { Schema, SchemaContext, TypedValidationResult, ValidatedOutput } 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,\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.Input<T>>, Array<Infer.Output<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 StandardSchemaV1<\n      Record<string, Infer.Input<T>>,\n      Record<string, Infer.Output<T>>\n    > &\n      RecordValidator & { valueValidator: T },\n\n  /**\n   * Create a tuple validator - fixed-length array with position-specific types.\n   *\n   * The `| []` in the constraint makes TypeScript infer a literal list as a tuple, so\n   * `v.tuple([v.string(), v.int()])` is typed `[string, number]` rather than\n   * `(string | number)[]`; a `BaseValidator[]` variable is still accepted.\n   */\n  tuple: <T extends BaseValidator[] | []>(validators: T, errorMessage?: string) =>\n    new TupleValidator(validators, errorMessage) as TupleValidator & {\n      validators: T;\n    } & StandardSchemaV1<\n        { [K in keyof T]: Infer.Input<T[K]> },\n        { [K in keyof T]: Infer.Output<T[K]> }\n      >,\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  ) => 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> & 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> &\n      StandardSchemaV1<Infer.Input<T>, Infer.Output<T>>,\n\n  /** Create a string validator */\n  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 ScalarValidator().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 StandardSchemaV1<\n      Infer.Input<T[number]>,\n      Infer.Output<T[number]>\n    > &\n      UnionValidator,\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: <K extends string, Branches extends ReadonlyArray<ObjectValidator<any>>>(\n    discriminator: K,\n    validators: Branches,\n  ) =>\n    new DiscriminatedUnionValidator(discriminator, validators) as DiscriminatedUnionValidator<\n      K,\n      Branches\n    > &\n      StandardSchemaV1<Infer.Input<Branches[number]>, Infer.Output<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  /**\n   * Rendered as `:value` in every error message — translated or custom —\n   * instead of the submitted input. Unset keeps the raw value.\n   */\n  redactValue?: string;\n} & SealConfig;\n\n// Standard Schema comes first on record/union intersections so direct calls\n// select the precise validate() output overload rather than BaseValidator's.\nexport interface ValidatorV {\n  object: <T extends Schema>(schema: T, errorMessage?: string) => 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.Input<T>>, Array<Infer.Output<T>>>;\n  record: <T extends BaseValidator>(\n    validator?: T,\n    errorMessage?: string,\n  ) => StandardSchemaV1<Record<string, Infer.Input<T>>, Record<string, Infer.Output<T>>> &\n    RecordValidator & { valueValidator: T };\n  tuple: <T extends BaseValidator[] | []>(\n    validators: T,\n    errorMessage?: string,\n  ) => TupleValidator & {\n    validators: T;\n  } & StandardSchemaV1<\n      { [K in keyof T]: Infer.Input<T[K]> },\n      { [K in keyof T]: Infer.Output<T[K]> }\n    >;\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.Input<T>, Infer.Output<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: (errorMessage?: string) => ScalarValidator & StandardSchemaV1<string | number | boolean>;\n  union: <T extends BaseValidator[]>(\n    validators: T,\n    errorMessage?: string,\n  ) => StandardSchemaV1<Infer.Input<T[number]>, Infer.Output<T[number]>> & UnionValidator;\n  discriminatedUnion: <K extends string, Branches extends ReadonlyArray<ObjectValidator<any>>>(\n    discriminator: K,\n    validators: Branches,\n  ) => DiscriminatedUnionValidator<K, Branches> &\n    StandardSchemaV1<Infer.Input<Branches[number]>, Infer.Output<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: unknown,\n    options?: ValidateOptions,\n  ) => Promise<TypedValidationResult<ValidatedOutput<T>>>;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,MAAa,IAAgB;;CAE3B;;CAGA,WAAW,IAAI,aAAa;;CAG5B,QAAiC,WAAc,iBAC7C,IAAI,eAAe,WAAW,YAAY;;CAK5C,SAAkC,WAAe,iBAC/C,IAAI,gBAAgB,aAAa,EAAE,IAAI,GAAG,YAAY;;;;;;;;CAaxD,QAAwC,YAAe,iBACrD,IAAI,eAAe,YAAY,YAAY;;CAQ7C,OAAO,iBACL,IAAI,cAAc,YAAY;;;;;;;;;CAUhC,UACE,GAAG,WACA,IAAI,iBAAoB,MAAM;;;;;;;;;CAUnC,aAAgB,MAAiC,iBAC/C,IAAI,oBAAuB,MAAM,YAAY;;;;;;;;;;;;;CAc/C,OAAgC,UAC9B,IAAI,cAAc,KAAK;;CAIzB;;CAGA,QAAQ,mBAA4B,iBAClC,IAAI,gBAAgB,YAAY,CAAC,CAAC,MAAM,iBAAiB;;;;;;;;;;;;;;CAgB3D,QAAQ,QAAa,iBACnB,MAAM,QAAQ,MAAM,IAChB,IAAI,gBAAgB,CAAC,CAAC,MAAM,QAAQ,YAAY,IAChD,IAAI,gBAAgB,CAAC,CAAC,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,CAAC,CAAC,MAAM,YAAY,YAAY;;;;;;;;;;;;;CAkBrD,qBACE,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/packages/seal/src/helpers/date-helpers.mjs

@@ -1,24 +0,0 @@
-//#region ../../packages/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/packages/seal/src/helpers/date-helpers.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"date-helpers.mjs","names":[],"sources":["../../../../../../../../../../../packages/seal/src/helpers/date-helpers.ts"],"sourcesContent":["/**\n * Detect if value is a date value or field name\n *\n * Date values:\n * - Date instance\n * - Number (timestamp)\n * - String with date separators (- or /)\n *\n * Field names:\n * - Strings without - or /\n *\n * @param value - Value to check\n * @returns true if it's a date value, false if it's a field name\n */\nexport function isDateValue(value: any): boolean {\n  if (value instanceof Date) return true;\n\n  const date = new Date(value);\n\n  return !isNaN(date.getTime());\n}\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/packages/seal/src/helpers/get-field-value.mjs

@@ -1,46 +0,0 @@
-import { get } from "../../../../node_modules/.pnpm/@mongez_reinforcements@4.0.2/node_modules/@mongez/reinforcements/esm/object/get.mjs";
-import "../../../../node_modules/.pnpm/@mongez_reinforcements@4.0.2/node_modules/@mongez/reinforcements/esm/index.mjs";
-
-//#region ../../packages/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/packages/seal/src/helpers/get-field-value.mjs.map

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

package/esm/packages/seal/src/helpers/index.mjs

@@ -1,6 +0,0 @@
-import { VALID_RULE, invalidRule, resolveTranslation } from "./validation-helpers.mjs";
-import { isDateValue } from "./date-helpers.mjs";
-import { getFieldValue } from "./get-field-value.mjs";
-import { setKeyPath } from "./path-helpers.mjs";
-
-export {  };

package/esm/packages/seal/src/helpers/is-empty-value.mjs

@@ -1,10 +0,0 @@
-import { isEmpty, isObject } from "../../../../node_modules/.pnpm/@mongez_supportive-is@3.0.0/node_modules/@mongez/supportive-is/esm/index.mjs";
-
-//#region ../../packages/seal/src/helpers/is-empty-value.ts
-function isEmptyValue(value) {
-	return isEmpty(value) && !isObject(value);
-}
-
-//#endregion
-export { isEmptyValue };
-//# sourceMappingURL=is-empty-value.mjs.map

package/esm/packages/seal/src/helpers/is-empty-value.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-empty-value.mjs","names":[],"sources":["../../../../../../../../../../../packages/seal/src/helpers/is-empty-value.ts"],"sourcesContent":["import { isEmpty, isObject } from \"@mongez/supportive-is\";\n\nexport function isEmptyValue(value: any) {\n  return isEmpty(value) && !isObject(value);\n}\n"],"mappings":";;;AAEA,SAAgB,aAAa,OAAY;CACvC,OAAO,QAAQ,KAAK,KAAK,CAAC,SAAS,KAAK;AAC1C"}

package/esm/packages/seal/src/helpers/path-helpers.mjs

@@ -1,12 +0,0 @@
-//#region ../../packages/seal/src/helpers/path-helpers.ts
-/**
-* Set the key path for nested validation
-*/
-const setKeyPath = (path, key) => {
-	if (!path) return key;
-	return `${path}.${key}`;
-};
-
-//#endregion
-export { setKeyPath };
-//# sourceMappingURL=path-helpers.mjs.map

package/esm/packages/seal/src/helpers/path-helpers.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"path-helpers.mjs","names":[],"sources":["../../../../../../../../../../../packages/seal/src/helpers/path-helpers.ts"],"sourcesContent":["/**\n * Set the key path for nested validation\n */\nexport const setKeyPath = (path: string, key: string): string => {\n  if (!path) return key;\n  return `${path}.${key}`;\n};\n"],"mappings":";;;;AAGA,MAAa,cAAc,MAAc,QAAwB;CAC/D,IAAI,CAAC,MAAM,OAAO;CAClB,OAAO,GAAG,KAAK,GAAG;AACpB"}

package/esm/packages/seal/src/helpers/validation-helpers.mjs

@@ -1,78 +0,0 @@
-import { getSealConfig } from "../config.mjs";
-
-//#region ../../packages/seal/src/helpers/validation-helpers.ts
-const VALID_RULE = { isValid: true };
-/**
-* Resolve a single attribute value through the full translation priority chain:
-* 1. attributesList[key]       — developer direct text override (highest priority)
-* 2. translatedAttributes[key] — developer explicit translation key
-* 3. translator(rawValue)      — auto-translate the raw value (fallback)
-*
-* Use this in rule bodies when you need per-item translation
-* (e.g. translating each enum value before joining them).
-*
-* @example
-* // Translate each enum value individually then join
-* const enumList = enumValues
-*   .map(v => resolveTranslation(String(v), String(v), this, context))
-*   .join(", ");
-* this.context.translationParams.enumList = enumList;
-*/
-const resolveTranslation = ({ key, rawValue, rule, context }) => {
-	const translator = getSealConfig().translateAttribute;
-	const direct = rule.context.attributesList?.[key];
-	if (direct && typeof direct === "string") return direct;
-	if (!translator) return String(rawValue ?? key);
-	const transKey = rule.context.translatedAttributes?.[key];
-	if (transKey) return translator({
-		attribute: transKey,
-		context,
-		rule
-	});
-	return translator({
-		attribute: String(rawValue ?? key),
-		context,
-		rule
-	});
-};
-const resolveAttribute = resolveTranslation;
-const invalidRule = (rule, context) => {
-	const translatableWithInput = {
-		input: context.key || "schema",
-		...rule.context.translatableParams
-	};
-	const resolvedParams = Object.fromEntries(Object.entries(translatableWithInput).map(([key, rawValue]) => [key, resolveAttribute({
-		key,
-		rawValue,
-		rule,
-		context
-	})]));
-	const input = resolveAttribute({
-		key: "input",
-		rawValue: translatableWithInput.input ?? "schema",
-		rule,
-		context
-	});
-	const attributes = {
-		path: context.path,
-		key: context.key,
-		value: context.configurations?.redactValue ?? context.value,
-		...rule.context.translationParams,
-		...resolvedParams,
-		input
-	};
-	return {
-		isValid: false,
-		error: (rule.context.errorMessage || rule.errorMessage || context.translateRule?.({
-			rule,
-			context,
-			attributes
-		}) || rule.defaultErrorMessage).replace(/:([a-zA-Z_]+)/g, (match, key) => key in attributes ? String(attributes[key]) : match),
-		input: attributes.input,
-		path: context.path
-	};
-};
-
-//#endregion
-export { VALID_RULE, invalidRule, resolveTranslation };
-//# sourceMappingURL=validation-helpers.mjs.map