@warlock.js/notifications 4.16.0 → 5.0.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"validators.mjs","names":["validateFunction"],"sources":["../../../../../../../../../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,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;;;;;;;;;;;;;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/seal/src/helpers/date-helpers.mjs

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

@@ -0,0 +1 @@
+{"version":3,"file":"date-helpers.mjs","names":[],"sources":["../../../../../../../../../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/seal/src/helpers/get-field-value.mjs

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-field-value.mjs","names":[],"sources":["../../../../../../../../../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"}

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

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

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

@@ -0,0 +1,10 @@
+import { isEmpty, isObject } from "../../../node_modules/@mongez/supportive-is/esm/index.mjs";
+
+//#region ../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/seal/src/helpers/is-empty-value.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-empty-value.mjs","names":[],"sources":["../../../../../../../../../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/seal/src/helpers/path-helpers.mjs

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

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

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

@@ -0,0 +1,72 @@
+import { getSealConfig } from "../config.mjs";
+
+//#region ../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 attributes = {
+		path: context.path,
+		key: context.key,
+		value: context.value,
+		...rule.context.translationParams,
+		...resolvedParams,
+		input: 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

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

@@ -0,0 +1 @@
+{"version":3,"file":"validation-helpers.mjs","names":[],"sources":["../../../../../../../../../seal/src/helpers/validation-helpers.ts"],"sourcesContent":["import { getSealConfig } from \"../config\";\nimport type { ContextualSchemaRule, RuleResult, RuleTranslation, SchemaContext } from \"../types\";\n\nexport const VALID_RULE: RuleResult = {\n  isValid: true,\n};\n/**\n * Resolve a single attribute value through the full translation priority chain:\n * 1. attributesList[key]       — developer direct text override (highest priority)\n * 2. translatedAttributes[key] — developer explicit translation key\n * 3. translator(rawValue)      — auto-translate the raw value (fallback)\n *\n * Use this in rule bodies when you need per-item translation\n * (e.g. translating each enum value before joining them).\n *\n * @example\n * // Translate each enum value individually then join\n * const enumList = enumValues\n *   .map(v => resolveTranslation(String(v), String(v), this, context))\n *   .join(\", \");\n * this.context.translationParams.enumList = enumList;\n */\nexport const resolveTranslation = ({\n  key,\n  rawValue,\n  rule,\n  context,\n}: {\n  key: string;\n  rawValue: any;\n  rule: ContextualSchemaRule;\n  context: SchemaContext;\n}): string => {\n  const translator = getSealConfig().translateAttribute;\n\n  // 1. Direct text override wins\n  const direct = rule.context.attributesList?.[key];\n  if (direct && typeof direct === \"string\") return direct;\n\n  if (!translator) return String(rawValue ?? key);\n\n  // 2. Explicit translation key\n  const transKey = rule.context.translatedAttributes?.[key];\n  if (transKey) return translator({ attribute: transKey, context, rule });\n\n  // 3. Auto-translate the raw value (fallback)\n  return translator({ attribute: String(rawValue ?? key), context, rule });\n};\n\n// Internal alias — invalidRule uses the same function without re-importing config\nconst resolveAttribute = resolveTranslation;\n\nexport const invalidRule = (rule: ContextualSchemaRule, context: SchemaContext): RuleResult => {\n  // `input` is always translatable — rules may add more (e.g., field references in sameAs)\n  // Rule-defined translatableParams override the default input if the key matches\n  const translatableWithInput: Record<string, string> = {\n    // Fall back to \"schema\" when validating at the root level (no key)\n    input: context.key || \"schema\",\n    ...rule.context.translatableParams,\n  };\n\n  // Resolve all translatable params through the full priority chain\n  const resolvedParams = Object.fromEntries(\n    Object.entries(translatableWithInput).map(([key, rawValue]) => [\n      key,\n      resolveAttribute({ key, rawValue, rule, context }),\n    ]),\n  );\n\n  const attributes: RuleTranslation[\"attributes\"] = {\n    path: context.path,\n    key: context.key,\n    value: context.value,\n    // Raw placeholders (:enumList, :min, :max, etc.) — no translation\n    ...rule.context.translationParams,\n    // Translated placeholders (:input, :field, etc.) — override raws if key collides\n    ...resolvedParams,\n    // Satisfy TypeScript's required field (always present via resolvedParams)\n    input: resolvedParams.input,\n  };\n\n  const rawError =\n    rule.context.errorMessage ||\n    rule.errorMessage ||\n    context.translateRule?.({ rule, context, attributes }) ||\n    rule.defaultErrorMessage!;\n\n  // Fallback interpolation: replace :placeholder patterns from attributes\n  // This kicks in when translateRule is absent or returns \"\" (not configured)\n  const error = rawError.replace(/:([a-zA-Z_]+)/g, (match, key) =>\n    key in attributes ? String(attributes[key as keyof typeof attributes]) : match,\n  );\n\n  return {\n    isValid: false,\n    error,\n    input: attributes.input, // use resolved input, not raw context.key (may be \"\")\n    path: context.path,\n  };\n};\n"],"mappings":";;;AAGA,MAAa,aAAyB,EACpC,SAAS,KACX;;;;;;;;;;;;;;;;;AAiBA,MAAa,sBAAsB,EACjC,KACA,UACA,MACA,cAMY;CACZ,MAAM,aAAa,cAAc,CAAC,CAAC;CAGnC,MAAM,SAAS,KAAK,QAAQ,iBAAiB;CAC7C,IAAI,UAAU,OAAO,WAAW,UAAU,OAAO;CAEjD,IAAI,CAAC,YAAY,OAAO,OAAO,YAAY,GAAG;CAG9C,MAAM,WAAW,KAAK,QAAQ,uBAAuB;CACrD,IAAI,UAAU,OAAO,WAAW;EAAE,WAAW;EAAU;EAAS;CAAK,CAAC;CAGtE,OAAO,WAAW;EAAE,WAAW,OAAO,YAAY,GAAG;EAAG;EAAS;CAAK,CAAC;AACzE;AAGA,MAAM,mBAAmB;AAEzB,MAAa,eAAe,MAA4B,YAAuC;CAG7F,MAAM,wBAAgD;EAEpD,OAAO,QAAQ,OAAO;EACtB,GAAG,KAAK,QAAQ;CAClB;CAGA,MAAM,iBAAiB,OAAO,YAC5B,OAAO,QAAQ,qBAAqB,CAAC,CAAC,KAAK,CAAC,KAAK,cAAc,CAC7D,KACA,iBAAiB;EAAE;EAAK;EAAU;EAAM;CAAQ,CAAC,CACnD,CAAC,CACH;CAEA,MAAM,aAA4C;EAChD,MAAM,QAAQ;EACd,KAAK,QAAQ;EACb,OAAO,QAAQ;EAEf,GAAG,KAAK,QAAQ;EAEhB,GAAG;EAEH,OAAO,eAAe;CACxB;CAcA,OAAO;EACL,SAAS;EACT,QAbA,KAAK,QAAQ,gBACb,KAAK,gBACL,QAAQ,gBAAgB;GAAE;GAAM;GAAS;EAAW,CAAC,KACrD,KAAK,oBAIe,CAAC,QAAQ,mBAAmB,OAAO,QACvD,OAAO,aAAa,OAAO,WAAW,IAA+B,IAAI,KAKrE;EACJ,OAAO,WAAW;EAClB,MAAM,QAAQ;CAChB;AACF"}

package/esm/seal/src/index.mjs

@@ -0,0 +1,87 @@
+import { applyNullable, getRuleOptions, wrapNullableStrict } from "./standard-schema/json-schema.mjs";
+import { getSealConfig } from "./config.mjs";
+import { validate } from "./factory/validate.mjs";
+import { isDateValue } from "./helpers/date-helpers.mjs";
+import { getFieldValue } from "./helpers/get-field-value.mjs";
+import { setKeyPath } from "./helpers/path-helpers.mjs";
+import { VALID_RULE, invalidRule, resolveTranslation } from "./helpers/validation-helpers.mjs";
+import "./helpers/index.mjs";
+import { presentRule, requiredRule } from "./rules/core/required.mjs";
+import { mapToStandardResult } from "./standard-schema/map-result.mjs";
+import { BaseValidator } from "./validators/base-validator.mjs";
+import { AnyValidator } from "./validators/any-validator.mjs";
+import { flipArrayMutator, sortArrayMutator, uniqueArrayMutator } from "./mutators/array-mutators.mjs";
+import { addDaysMutator, addHoursMutator, addMonthsMutator, addYearsMutator, dateMutator, toEndOfDayMutator, toEndOfMonthMutator, toEndOfYearMutator, toStartOfDayMutator, toStartOfMonthMutator, toStartOfYearMutator, toUTCMutator } from "./mutators/date-mutators.mjs";
+import { absMutator, ceilMutator, floorMutator, numberMutator, numericMutator, roundMutator, toFixedMutator } from "./mutators/number-mutators.mjs";
+import { objectTrimMutator, stripUnknownMutator } from "./mutators/object-mutators.mjs";
+import { stringMutator } from "./mutators/scalar-mutators.mjs";
+import { alphaOnlyMutator, alphanumericOnlyMutator, appendMutator, base64DecodeMutator, base64EncodeMutator, camelCaseMutator, capitalizeMutator, htmlEscapeMutator, kebabCaseMutator, lowercaseMutator, ltrimMutator, maskMutator, padEndMutator, padStartMutator, pascalCaseMutator, prependMutator, removeNumbersMutator, removeSpecialCharactersMutator, repeatMutator, replaceAllMutator, replaceMutator, reverseMutator, rtrimMutator, slugMutator, snakeCaseMutator, stringifyMutator, stripTagsMutator, titleCaseMutator, trimMultipleWhitespaceMutator, trimMutator, truncateMutator, unescapeHtmlMutator, uppercaseMutator, urlDecodeMutator, urlEncodeMutator } from "./mutators/string-mutators.mjs";
+import "./mutators/index.mjs";
+import { equalRule } from "./rules/core/equal.mjs";
+import { forbiddenRule } from "./rules/core/forbidden.mjs";
+import { unionRule } from "./rules/core/union.mjs";
+import { whenRule } from "./rules/core/when.mjs";
+import { alphaNumericRule, alphaRule, isNumericRule } from "./rules/string/alpha.mjs";
+import { isCreditCardRule } from "./rules/string/credit-card.mjs";
+import { emailRule } from "./rules/string/email.mjs";
+import { cuidRule, nanoidRule, ulidRule, uuidRule } from "./rules/string/id-formats.mjs";
+import { ip4Rule, ip6Rule, ipRule, isIP, isIPv4, isIPv6 } from "./rules/string/ip.mjs";
+import { patternRule } from "./rules/string/pattern.mjs";
+import { containsRule, endsWithRule, notContainsRule, startsWithRule } from "./rules/string/string-comparison.mjs";
+import { strongPasswordRule } from "./rules/string/strong-password-rule.mjs";
+import { urlRule } from "./rules/string/url.mjs";
+import { withoutWhitespaceRule } from "./rules/string/without-whitespace.mjs";
+import { betweenNumbersRule, evenRule, greaterThanRule, lessThanRule, maxRule, minRule, moduloRule, negativeRule, oddRule, positiveRule } from "./rules/number/number-rules.mjs";
+import { betweenLengthRule, lengthRule, maxLengthRule, maxWordsRule, minLengthRule, minWordsRule, wordsRule } from "./rules/length/length-rules.mjs";
+import { sortedArrayRule, uniqueArrayRule } from "./rules/array/array-rules.mjs";
+import { WEEK_DAYS } from "./types/date-types.mjs";
+import { ageRule, beforeHourRule, beforeMinuteRule, beforeTodayRule, betweenHoursRule, betweenMinutesRule, dateRule, fromHourRule, fromMinuteRule, fromTodayRule, maxAgeRule, maxDateRule, minAgeRule, minDateRule, weekDayRule } from "./rules/date/date.mjs";
+import { afterTodayRule, betweenDatesRule, futureRule, pastRule, todayRule } from "./rules/date/date-comparison-rules.mjs";
+import { businessDayRule, weekdaysRule, weekendRule } from "./rules/date/date-day-rules.mjs";
+import { afterFieldRule, beforeFieldRule, sameAsFieldDateRule } from "./rules/date/date-field-comparison-rules.mjs";
+import { betweenDaysRule, betweenMonthsRule, betweenTimesRule, betweenYearsRule, maxDayRule, maxMonthRule, maxYearRule, minDayRule, minMonthRule, minYearRule, monthRule, quarterRule, yearRule } from "./rules/date/date-period-rules.mjs";
+import { withinDaysRule, withinFutureDaysRule, withinPastDaysRule } from "./rules/date/date-relative-rules.mjs";
+import { betweenAgeRule, birthdayRule, leapYearRule } from "./rules/date/date-special-rules.mjs";
+import { colorRule, darkColorRule, hexColorRule, hslColorRule, lightColorRule, rgbColorRule, rgbaColorRule } from "./rules/color/color-rules.mjs";
+import { requiredIfAllEmptyRule, requiredIfAllNotEmptyRule, requiredIfAnyEmptyRule, requiredIfAnyNotEmptyRule, requiredIfEmptyRule, requiredIfInRule, requiredIfNotEmptyRule, requiredIfNotInRule, requiredIfRule } from "./rules/conditional/required-if-rules.mjs";
+import { requiredUnlessRule } from "./rules/conditional/required-unless-rules.mjs";
+import { requiredWhenRule } from "./rules/conditional/required-when-rule.mjs";
+import { requiredWithAllRule, requiredWithAnyRule, requiredWithRule } from "./rules/conditional/required-with-rules.mjs";
+import { requiredWithoutAllRule, requiredWithoutAnyRule, requiredWithoutRule } from "./rules/conditional/required-without-rules.mjs";
+import { presentIfEmptyRule, presentIfInRule, presentIfNotEmptyRule, presentIfNotInRule, presentIfRule } from "./rules/conditional/present-if-rules.mjs";
+import { presentUnlessRule } from "./rules/conditional/present-unless-rules.mjs";
+import { presentWithAllRule, presentWithAnyRule, presentWithRule } from "./rules/conditional/present-with-rules.mjs";
+import { presentWithoutAllRule, presentWithoutAnyRule, presentWithoutRule } from "./rules/conditional/present-without-rules.mjs";
+import { forbiddenIfEmptyRule, forbiddenIfInRule, forbiddenIfNotEmptyRule, forbiddenIfNotInRule, forbiddenIfNotRule, forbiddenIfRule } from "./rules/conditional/forbidden-if-rules.mjs";
+import { allowedValuesRule, enumRule, inRule, notAllowedValuesRule } from "./rules/common/enum.mjs";
+import { equalsFieldRule, notEqualsFieldRule } from "./rules/common/equals-field-rules.mjs";
+import { instanceofRule } from "./rules/common/instanceof.mjs";
+import { literalRule } from "./rules/common/literal.mjs";
+import { arrayRule, booleanRule, floatRule, intRule, numberRule, objectRule, plainObjectRule, stringRule } from "./rules/common/type-rules.mjs";
+import { unknownKeyRule } from "./rules/common/unknown-key.mjs";
+import "./rules/index.mjs";
+import { ArrayValidator } from "./validators/array-validator.mjs";
+import { PrimitiveValidator } from "./validators/primitive-validator.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";
+import "./validators/index.mjs";
+import { v } from "./factory/validators.mjs";
+import "./factory/index.mjs";
+
+export {  };

package/esm/seal/src/mutators/array-mutators.mjs

@@ -0,0 +1,32 @@
+import { get } from "../../../node_modules/@mongez/reinforcements/esm/object/get.mjs";
+import "../../../node_modules/@mongez/reinforcements/esm/index.mjs";
+
+//#region ../seal/src/mutators/array-mutators.ts
+/** Reverse array order */
+const flipArrayMutator = async (value) => {
+	return value.reverse();
+};
+/** Sort array */
+const sortArrayMutator = async (value, context) => {
+	if (!Array.isArray(value)) return value;
+	const sortDirection = context?.options.direction ?? "asc";
+	const sortByKey = context?.options.key ?? null;
+	return value.sort((a, b) => {
+		if (sortByKey) {
+			const aValue = get(a, sortByKey);
+			const bValue = get(b, sortByKey);
+			if (sortDirection === "asc") return aValue - bValue;
+			return bValue - aValue;
+		}
+		if (sortDirection === "asc") return a - b;
+		return b - a;
+	});
+};
+/** Make array have only unique values */
+const uniqueArrayMutator = async (value) => {
+	return [...new Set(value)];
+};
+
+//#endregion
+export { flipArrayMutator, sortArrayMutator, uniqueArrayMutator };
+//# sourceMappingURL=array-mutators.mjs.map

package/esm/seal/src/mutators/array-mutators.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-mutators.mjs","names":[],"sources":["../../../../../../../../../seal/src/mutators/array-mutators.ts"],"sourcesContent":["import { get } from \"@mongez/reinforcements\";\r\nimport { isEmptyValue } from \"../helpers/is-empty-value\";\r\nimport type { Mutator } from \"../types\";\r\n\r\n/** Reverse array order */\r\nexport const flipArrayMutator: Mutator = async (value) => {\r\n  return value.reverse();\r\n};\r\n\r\n/** Reverse array order (alias) */\r\nexport const reverseArrayMutator: Mutator = async (value) => {\r\n  return value.reverse();\r\n};\r\n\r\n/** Sort array */\r\nexport const sortArrayMutator: Mutator = async (value, context) => {\r\n  if (!Array.isArray(value)) return value;\r\n\r\n  const sortDirection = context?.options.direction ?? \"asc\";\r\n  const sortByKey = context?.options.key ?? null;\r\n\r\n  return value.sort((a: any, b: any) => {\r\n    if (sortByKey) {\r\n      const aValue = get(a, sortByKey);\r\n      const bValue = get(b, sortByKey);\r\n\r\n      if (sortDirection === \"asc\") {\r\n        return aValue - bValue;\r\n      }\r\n      return bValue - aValue;\r\n    }\r\n\r\n    if (sortDirection === \"asc\") {\r\n      return a - b;\r\n    }\r\n    return b - a;\r\n  });\r\n};\r\n\r\n/** Make array have only unique values */\r\nexport const uniqueArrayMutator: Mutator = async (value) => {\r\n  return [...new Set(value)];\r\n};\r\n\r\n/** Remove empty elements from array */\r\nexport const removeEmptyArrayElementsMutator: Mutator = async (value) => {\r\n  return value.filter((item: any) => !isEmptyValue(item));\r\n};\r\n"],"mappings":";;;;;AAKA,MAAa,mBAA4B,OAAO,UAAU;CACxD,OAAO,MAAM,QAAQ;AACvB;;AAQA,MAAa,mBAA4B,OAAO,OAAO,YAAY;CACjE,IAAI,CAAC,MAAM,QAAQ,KAAK,GAAG,OAAO;CAElC,MAAM,gBAAgB,SAAS,QAAQ,aAAa;CACpD,MAAM,YAAY,SAAS,QAAQ,OAAO;CAE1C,OAAO,MAAM,MAAM,GAAQ,MAAW;EACpC,IAAI,WAAW;GACb,MAAM,SAAS,IAAI,GAAG,SAAS;GAC/B,MAAM,SAAS,IAAI,GAAG,SAAS;GAE/B,IAAI,kBAAkB,OACpB,OAAO,SAAS;GAElB,OAAO,SAAS;EAClB;EAEA,IAAI,kBAAkB,OACpB,OAAO,IAAI;EAEb,OAAO,IAAI;CACb,CAAC;AACH;;AAGA,MAAa,qBAA8B,OAAO,UAAU;CAC1D,OAAO,CAAC,GAAG,IAAI,IAAI,KAAK,CAAC;AAC3B"}

package/esm/seal/src/mutators/date-mutators.mjs

@@ -0,0 +1,94 @@
+import { __toESM } from "../../../_virtual/_rolldown/runtime.mjs";
+import { require_dayjs_min } from "../../../node_modules/dayjs/dayjs.min.mjs";
+
+//#region ../seal/src/mutators/date-mutators.ts
+var import_dayjs_min = /* @__PURE__ */ __toESM(require_dayjs_min(), 1);
+/**
+* Convert value to Date object
+* Returns Invalid Date if value cannot be converted
+*/
+const dateMutator = async (value) => {
+	if (!value) return;
+	if (value instanceof Date) return value;
+	return new Date(value);
+};
+/** Convert date to start of day (00:00:00) */
+const toStartOfDayMutator = async (value) => {
+	const date = new Date(value);
+	date.setHours(0, 0, 0, 0);
+	return date;
+};
+/** Convert date to end of day (23:59:59.999) */
+const toEndOfDayMutator = async (value) => {
+	const date = new Date(value);
+	date.setHours(23, 59, 59, 999);
+	return date;
+};
+/** Add or subtract days from date */
+const addDaysMutator = async (value, context) => {
+	const date = new Date(value);
+	const days = context?.options.days ?? 0;
+	date.setDate(date.getDate() + days);
+	return date;
+};
+/** Add or subtract months from date */
+const addMonthsMutator = async (value, context) => {
+	const date = new Date(value);
+	const months = context?.options.months ?? 0;
+	date.setMonth(date.getMonth() + months);
+	return date;
+};
+/** Add or subtract years from date */
+const addYearsMutator = async (value, context) => {
+	const date = new Date(value);
+	const years = context?.options.years ?? 0;
+	date.setFullYear(date.getFullYear() + years);
+	return date;
+};
+/** Add or subtract hours from date */
+const addHoursMutator = async (value, context) => {
+	const date = new Date(value);
+	const hours = context?.options.hours ?? 0;
+	date.setHours(date.getHours() + hours);
+	return date;
+};
+/** Convert date to UTC */
+const toUTCMutator = async (value) => {
+	const date = new Date(value);
+	return new Date(date.toUTCString());
+};
+/** Set to start of month */
+const toStartOfMonthMutator = async (value) => {
+	const date = new Date(value);
+	date.setDate(1);
+	date.setHours(0, 0, 0, 0);
+	return date;
+};
+/** Set to end of month */
+const toEndOfMonthMutator = async (value) => {
+	const date = new Date(value);
+	date.setMonth(date.getMonth() + 1);
+	date.setDate(0);
+	date.setHours(23, 59, 59, 999);
+	return date;
+};
+/** Set to start of year */
+const toStartOfYearMutator = async (value) => {
+	const date = new Date(value);
+	date.setMonth(0);
+	date.setDate(1);
+	date.setHours(0, 0, 0, 0);
+	return date;
+};
+/** Set to end of year */
+const toEndOfYearMutator = async (value) => {
+	const date = new Date(value);
+	date.setMonth(11);
+	date.setDate(31);
+	date.setHours(23, 59, 59, 999);
+	return date;
+};
+
+//#endregion
+export { addDaysMutator, addHoursMutator, addMonthsMutator, addYearsMutator, dateMutator, toEndOfDayMutator, toEndOfMonthMutator, toEndOfYearMutator, toStartOfDayMutator, toStartOfMonthMutator, toStartOfYearMutator, toUTCMutator };
+//# sourceMappingURL=date-mutators.mjs.map

package/esm/seal/src/mutators/date-mutators.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-mutators.mjs","names":[],"sources":["../../../../../../../../../seal/src/mutators/date-mutators.ts"],"sourcesContent":["import dayjs from \"dayjs\";\r\nimport type { Mutator } from \"../types\";\r\n\r\n/**\r\n * Convert value to Date object\r\n * Returns Invalid Date if value cannot be converted\r\n */\r\nexport const dateMutator: Mutator = async (value) => {\r\n  // Handle null/undefined\r\n  if (!value) {\r\n    return;\r\n  }\r\n\r\n  // Already a Date object\r\n  if (value instanceof Date) {\r\n    return value;\r\n  }\r\n\r\n  // Try to convert to Date\r\n  const date = new Date(value);\r\n\r\n  // Return the date (valid or Invalid Date)\r\n  // dateRule will validate and fail if invalid\r\n  return date;\r\n};\r\n\r\n/** Convert date to ISO string format */\r\nexport const toISOStringMutator: Mutator = async (value) => {\r\n  const date = new Date(value);\r\n  return date.toISOString();\r\n};\r\n\r\n/** Convert date to Unix timestamp (milliseconds) */\r\nexport const toTimestampMutator: Mutator = async (value) => {\r\n  const date = new Date(value);\r\n  return date.getTime();\r\n};\r\n\r\n/** Convert date to start of day (00:00:00) */\r\nexport const toStartOfDayMutator: Mutator = async (value) => {\r\n  const date = new Date(value);\r\n  date.setHours(0, 0, 0, 0);\r\n  return date;\r\n};\r\n\r\n/** Convert date to end of day (23:59:59.999) */\r\nexport const toEndOfDayMutator: Mutator = async (value) => {\r\n  const date = new Date(value);\r\n  date.setHours(23, 59, 59, 999);\r\n  return date;\r\n};\r\n\r\n/** Add or subtract days from date */\r\nexport const addDaysMutator: Mutator = async (value, context) => {\r\n  const date = new Date(value);\r\n  const days = context?.options.days ?? 0;\r\n  date.setDate(date.getDate() + days);\r\n  return date;\r\n};\r\n\r\n/** Add or subtract months from date */\r\nexport const addMonthsMutator: Mutator = async (value, context) => {\r\n  const date = new Date(value);\r\n  const months = context?.options.months ?? 0;\r\n  date.setMonth(date.getMonth() + months);\r\n  return date;\r\n};\r\n\r\n/** Add or subtract years from date */\r\nexport const addYearsMutator: Mutator = async (value, context) => {\r\n  const date = new Date(value);\r\n  const years = context?.options.years ?? 0;\r\n  date.setFullYear(date.getFullYear() + years);\r\n  return date;\r\n};\r\n\r\n/** Add or subtract hours from date */\r\nexport const addHoursMutator: Mutator = async (value, context) => {\r\n  const date = new Date(value);\r\n  const hours = context?.options.hours ?? 0;\r\n  date.setHours(date.getHours() + hours);\r\n  return date;\r\n};\r\n\r\n/** Convert date to UTC */\r\nexport const toUTCMutator: Mutator = async (value) => {\r\n  const date = new Date(value);\r\n  return new Date(date.toUTCString());\r\n};\r\n\r\n/** Convert date to specific format using dayjs */\r\nexport const toFormatMutator: Mutator = async (value, context) => {\r\n  const format = context?.options.format ?? \"YYYY-MM-DD\";\r\n  return dayjs(value).format(format);\r\n};\r\n\r\n/** Convert to date only (remove time) */\r\nexport const toDateOnlyMutator: Mutator = async (value) => {\r\n  const date = new Date(value);\r\n  return date.toISOString().split(\"T\")[0];\r\n};\r\n\r\n/** Convert to time only (HH:MM:SS) */\r\nexport const toTimeOnlyMutator: Mutator = async (value) => {\r\n  const date = new Date(value);\r\n  return date.toTimeString().split(\" \")[0];\r\n};\r\n\r\n/** Set to start of month */\r\nexport const toStartOfMonthMutator: Mutator = async (value) => {\r\n  const date = new Date(value);\r\n  date.setDate(1);\r\n  date.setHours(0, 0, 0, 0);\r\n  return date;\r\n};\r\n\r\n/** Set to end of month */\r\nexport const toEndOfMonthMutator: Mutator = async (value) => {\r\n  const date = new Date(value);\r\n  date.setMonth(date.getMonth() + 1);\r\n  date.setDate(0);\r\n  date.setHours(23, 59, 59, 999);\r\n  return date;\r\n};\r\n\r\n/** Set to start of year */\r\nexport const toStartOfYearMutator: Mutator = async (value) => {\r\n  const date = new Date(value);\r\n  date.setMonth(0);\r\n  date.setDate(1);\r\n  date.setHours(0, 0, 0, 0);\r\n  return date;\r\n};\r\n\r\n/** Set to end of year */\r\nexport const toEndOfYearMutator: Mutator = async (value) => {\r\n  const date = new Date(value);\r\n  date.setMonth(11);\r\n  date.setDate(31);\r\n  date.setHours(23, 59, 59, 999);\r\n  return date;\r\n};\r\n"],"mappings":";;;;;;;;;AAOA,MAAa,cAAuB,OAAO,UAAU;CAEnD,IAAI,CAAC,OACH;CAIF,IAAI,iBAAiB,MACnB,OAAO;CAQT,OAAO,IAJU,KAAK,KAIZ;AACZ;;AAeA,MAAa,sBAA+B,OAAO,UAAU;CAC3D,MAAM,OAAO,IAAI,KAAK,KAAK;CAC3B,KAAK,SAAS,GAAG,GAAG,GAAG,CAAC;CACxB,OAAO;AACT;;AAGA,MAAa,oBAA6B,OAAO,UAAU;CACzD,MAAM,OAAO,IAAI,KAAK,KAAK;CAC3B,KAAK,SAAS,IAAI,IAAI,IAAI,GAAG;CAC7B,OAAO;AACT;;AAGA,MAAa,iBAA0B,OAAO,OAAO,YAAY;CAC/D,MAAM,OAAO,IAAI,KAAK,KAAK;CAC3B,MAAM,OAAO,SAAS,QAAQ,QAAQ;CACtC,KAAK,QAAQ,KAAK,QAAQ,IAAI,IAAI;CAClC,OAAO;AACT;;AAGA,MAAa,mBAA4B,OAAO,OAAO,YAAY;CACjE,MAAM,OAAO,IAAI,KAAK,KAAK;CAC3B,MAAM,SAAS,SAAS,QAAQ,UAAU;CAC1C,KAAK,SAAS,KAAK,SAAS,IAAI,MAAM;CACtC,OAAO;AACT;;AAGA,MAAa,kBAA2B,OAAO,OAAO,YAAY;CAChE,MAAM,OAAO,IAAI,KAAK,KAAK;CAC3B,MAAM,QAAQ,SAAS,QAAQ,SAAS;CACxC,KAAK,YAAY,KAAK,YAAY,IAAI,KAAK;CAC3C,OAAO;AACT;;AAGA,MAAa,kBAA2B,OAAO,OAAO,YAAY;CAChE,MAAM,OAAO,IAAI,KAAK,KAAK;CAC3B,MAAM,QAAQ,SAAS,QAAQ,SAAS;CACxC,KAAK,SAAS,KAAK,SAAS,IAAI,KAAK;CACrC,OAAO;AACT;;AAGA,MAAa,eAAwB,OAAO,UAAU;CACpD,MAAM,OAAO,IAAI,KAAK,KAAK;CAC3B,OAAO,IAAI,KAAK,KAAK,YAAY,CAAC;AACpC;;AAqBA,MAAa,wBAAiC,OAAO,UAAU;CAC7D,MAAM,OAAO,IAAI,KAAK,KAAK;CAC3B,KAAK,QAAQ,CAAC;CACd,KAAK,SAAS,GAAG,GAAG,GAAG,CAAC;CACxB,OAAO;AACT;;AAGA,MAAa,sBAA+B,OAAO,UAAU;CAC3D,MAAM,OAAO,IAAI,KAAK,KAAK;CAC3B,KAAK,SAAS,KAAK,SAAS,IAAI,CAAC;CACjC,KAAK,QAAQ,CAAC;CACd,KAAK,SAAS,IAAI,IAAI,IAAI,GAAG;CAC7B,OAAO;AACT;;AAGA,MAAa,uBAAgC,OAAO,UAAU;CAC5D,MAAM,OAAO,IAAI,KAAK,KAAK;CAC3B,KAAK,SAAS,CAAC;CACf,KAAK,QAAQ,CAAC;CACd,KAAK,SAAS,GAAG,GAAG,GAAG,CAAC;CACxB,OAAO;AACT;;AAGA,MAAa,qBAA8B,OAAO,UAAU;CAC1D,MAAM,OAAO,IAAI,KAAK,KAAK;CAC3B,KAAK,SAAS,EAAE;CAChB,KAAK,QAAQ,EAAE;CACf,KAAK,SAAS,IAAI,IAAI,IAAI,GAAG;CAC7B,OAAO;AACT"}

package/esm/seal/src/mutators/index.mjs

@@ -0,0 +1,8 @@
+import { flipArrayMutator, sortArrayMutator, uniqueArrayMutator } from "./array-mutators.mjs";
+import { addDaysMutator, addHoursMutator, addMonthsMutator, addYearsMutator, dateMutator, toEndOfDayMutator, toEndOfMonthMutator, toEndOfYearMutator, toStartOfDayMutator, toStartOfMonthMutator, toStartOfYearMutator, toUTCMutator } from "./date-mutators.mjs";
+import { absMutator, ceilMutator, floorMutator, numberMutator, numericMutator, roundMutator, toFixedMutator } from "./number-mutators.mjs";
+import { objectTrimMutator, stripUnknownMutator } from "./object-mutators.mjs";
+import { stringMutator } from "./scalar-mutators.mjs";
+import { alphaOnlyMutator, alphanumericOnlyMutator, appendMutator, base64DecodeMutator, base64EncodeMutator, camelCaseMutator, capitalizeMutator, htmlEscapeMutator, kebabCaseMutator, lowercaseMutator, ltrimMutator, maskMutator, padEndMutator, padStartMutator, pascalCaseMutator, prependMutator, removeNumbersMutator, removeSpecialCharactersMutator, repeatMutator, replaceAllMutator, replaceMutator, reverseMutator, rtrimMutator, slugMutator, snakeCaseMutator, stringifyMutator, stripTagsMutator, titleCaseMutator, trimMultipleWhitespaceMutator, trimMutator, truncateMutator, unescapeHtmlMutator, uppercaseMutator, urlDecodeMutator, urlEncodeMutator } from "./string-mutators.mjs";
+
+export {  };

package/esm/seal/src/mutators/number-mutators.mjs

@@ -0,0 +1,52 @@
+import { round } from "../../../node_modules/@mongez/reinforcements/esm/number/round.mjs";
+import "../../../node_modules/@mongez/reinforcements/esm/index.mjs";
+import { isNumeric } from "../../../node_modules/@mongez/supportive-is/esm/index.mjs";
+
+//#region ../seal/src/mutators/number-mutators.ts
+/** Convert value to number */
+const numberMutator = async (value) => {
+	if (!value) return value;
+	return Number(value);
+};
+const numericMutator = async (value) => {
+	if (!isNumeric(value)) return value;
+	return Number(value);
+};
+/** Absolute value mutator */
+const absMutator = async (value) => {
+	return Math.abs(Number(value));
+};
+/** Ceil mutator */
+const ceilMutator = async (value) => {
+	return Math.ceil(Number(value));
+};
+/** Floor mutator */
+const floorMutator = async (value) => {
+	return Math.floor(Number(value));
+};
+/**
+* Round mutator
+* Supports decimal precision via options.decimals
+*/
+const roundMutator = async (value, context) => {
+	const decimals = context?.options?.decimals ?? 0;
+	if (decimals === 0) return Math.round(Number(value));
+	return round(Number(value), decimals);
+};
+/**
+* To fixed mutator — rounds to a fixed number of decimal places, as a number.
+*
+* `Number.prototype.toFixed` returns a *string*, which the number validator's
+* own type rule then rejected: `v.number().toFixed(2)` could never produce a
+* valid result. Coercing back to a number keeps the method usable where it
+* lives. For the fixed-point string form, format at the edge instead of asking
+* a number schema to output a string.
+*/
+const toFixedMutator = async (value, context) => {
+	const decimals = context?.options?.decimals ?? 2;
+	return Number(Number(value).toFixed(decimals));
+};
+
+//#endregion
+export { absMutator, ceilMutator, floorMutator, numberMutator, numericMutator, roundMutator, toFixedMutator };
+//# sourceMappingURL=number-mutators.mjs.map

package/esm/seal/src/mutators/number-mutators.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"number-mutators.mjs","names":[],"sources":["../../../../../../../../../seal/src/mutators/number-mutators.ts"],"sourcesContent":["import { round } from \"@mongez/reinforcements\";\r\nimport { isNumeric } from \"@mongez/supportive-is\";\r\nimport type { Mutator } from \"../types\";\r\n\r\n/** Convert value to number */\r\nexport const numberMutator: Mutator = async (value) => {\r\n  if (!value) return value;\r\n  return Number(value);\r\n};\r\n\r\n/** Round number to specified decimals */\r\nexport const roundNumberMutator: Mutator = async (value, context) => {\r\n  return round(value, context?.options?.decimals ?? 2);\r\n};\r\n\r\n/** Convert to boolean */\r\nexport const booleanMutator: Mutator = async (value) => {\r\n  if (value === \"true\") return true;\r\n  if (value === \"false\") return false;\r\n  return Boolean(value);\r\n};\r\n\r\nexport const numericMutator: Mutator = async (value) => {\r\n  if (!isNumeric(value)) return value;\r\n  return Number(value);\r\n};\r\n\r\n/** Absolute value mutator */\r\nexport const absMutator: Mutator = async (value) => {\r\n  return Math.abs(Number(value));\r\n};\r\n\r\n/** Ceil mutator */\r\nexport const ceilMutator: Mutator = async (value) => {\r\n  return Math.ceil(Number(value));\r\n};\r\n\r\n/** Floor mutator */\r\nexport const floorMutator: Mutator = async (value) => {\r\n  return Math.floor(Number(value));\r\n};\r\n\r\n/**\r\n * Round mutator\r\n * Supports decimal precision via options.decimals\r\n */\r\nexport const roundMutator: Mutator = async (value, context) => {\r\n  const decimals = context?.options?.decimals ?? 0;\r\n  // If decimals is 0, use standard Math.round for integers\r\n  if (decimals === 0) {\r\n    return Math.round(Number(value));\r\n  }\r\n  // Otherwise use reinforcements round helper for precision\r\n  return round(Number(value), decimals);\r\n};\r\n\r\n/**\r\n * To fixed mutator — rounds to a fixed number of decimal places, as a number.\r\n *\r\n * `Number.prototype.toFixed` returns a *string*, which the number validator's\r\n * own type rule then rejected: `v.number().toFixed(2)` could never produce a\r\n * valid result. Coercing back to a number keeps the method usable where it\r\n * lives. For the fixed-point string form, format at the edge instead of asking\r\n * a number schema to output a string.\r\n */\r\nexport const toFixedMutator: Mutator = async (value, context) => {\r\n  const decimals = context?.options?.decimals ?? 2;\r\n  return Number(Number(value).toFixed(decimals));\r\n};\r\n"],"mappings":";;;;;;AAKA,MAAa,gBAAyB,OAAO,UAAU;CACrD,IAAI,CAAC,OAAO,OAAO;CACnB,OAAO,OAAO,KAAK;AACrB;AAcA,MAAa,iBAA0B,OAAO,UAAU;CACtD,IAAI,CAAC,UAAU,KAAK,GAAG,OAAO;CAC9B,OAAO,OAAO,KAAK;AACrB;;AAGA,MAAa,aAAsB,OAAO,UAAU;CAClD,OAAO,KAAK,IAAI,OAAO,KAAK,CAAC;AAC/B;;AAGA,MAAa,cAAuB,OAAO,UAAU;CACnD,OAAO,KAAK,KAAK,OAAO,KAAK,CAAC;AAChC;;AAGA,MAAa,eAAwB,OAAO,UAAU;CACpD,OAAO,KAAK,MAAM,OAAO,KAAK,CAAC;AACjC;;;;;AAMA,MAAa,eAAwB,OAAO,OAAO,YAAY;CAC7D,MAAM,WAAW,SAAS,SAAS,YAAY;CAE/C,IAAI,aAAa,GACf,OAAO,KAAK,MAAM,OAAO,KAAK,CAAC;CAGjC,OAAO,MAAM,OAAO,KAAK,GAAG,QAAQ;AACtC;;;;;;;;;;AAWA,MAAa,iBAA0B,OAAO,OAAO,YAAY;CAC/D,MAAM,WAAW,SAAS,SAAS,YAAY;CAC/C,OAAO,OAAO,OAAO,KAAK,CAAC,CAAC,QAAQ,QAAQ,CAAC;AAC/C"}

package/esm/seal/src/mutators/object-mutators.mjs

@@ -0,0 +1,30 @@
+import { trim } from "../../../node_modules/@mongez/reinforcements/esm/string/trim.mjs";
+import "../../../node_modules/@mongez/reinforcements/esm/index.mjs";
+import { isPlainObject } from "../../../node_modules/@mongez/supportive-is/esm/index.mjs";
+
+//#region ../seal/src/mutators/object-mutators.ts
+/** Strip unknown keys from object */
+const stripUnknownMutator = async (value, context) => {
+	const allowedKeys = [...context?.ctx.schema ? Object.keys(context.ctx.schema) : [], ...context?.options.allowedKeys ?? []];
+	const result = {};
+	for (const key in value) if (allowedKeys.includes(key)) result[key] = value[key];
+	return result;
+};
+/** Trim all string values in object */
+const objectTrimMutator = async (value, context) => {
+	if (!isPlainObject(value)) return value;
+	const result = {};
+	const recursive = context?.options.recursive ?? false;
+	for (const key in value) {
+		const item = value[key];
+		if (recursive) if (Array.isArray(item)) result[key] = await Promise.all(item.map(async (i) => typeof i === "string" ? trim(i) : await objectTrimMutator(i, context)));
+		else if (isPlainObject(item)) result[key] = await objectTrimMutator(item, context);
+		else result[key] = typeof item === "string" ? trim(item) : item;
+		else result[key] = typeof item === "string" ? trim(item) : item;
+	}
+	return result;
+};
+
+//#endregion
+export { objectTrimMutator, stripUnknownMutator };
+//# sourceMappingURL=object-mutators.mjs.map

package/esm/seal/src/mutators/object-mutators.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-mutators.mjs","names":[],"sources":["../../../../../../../../../seal/src/mutators/object-mutators.ts"],"sourcesContent":["import { trim } from \"@mongez/reinforcements\";\r\nimport { isPlainObject } from \"@mongez/supportive-is\";\r\nimport type { Mutator } from \"../types\";\r\n\r\n/** Strip unknown keys from object */\r\nexport const stripUnknownMutator: Mutator = async (value, context) => {\r\n  const allowedKeys = [\r\n    ...(context?.ctx.schema ? Object.keys(context.ctx.schema) : []),\r\n    ...(context?.options.allowedKeys ?? []),\r\n  ];\r\n\r\n  const result: Record<string, any> = {};\r\n\r\n  for (const key in value) {\r\n    if (allowedKeys.includes(key)) {\r\n      result[key] = value[key];\r\n    }\r\n  }\r\n\r\n  return result;\r\n};\r\n\r\n/** Trim all string values in object */\r\nexport const objectTrimMutator: Mutator = async (value, context) => {\r\n  if (!isPlainObject(value)) return value;\r\n\r\n  const result: Record<string, any> = {};\r\n  const recursive = context?.options.recursive ?? false;\r\n\r\n  for (const key in value) {\r\n    const item = value[key];\r\n\r\n    if (recursive) {\r\n      if (Array.isArray(item)) {\r\n        result[key] = await Promise.all(\r\n          item.map(async (i: any) =>\r\n            typeof i === \"string\" ? trim(i) : await objectTrimMutator(i, context),\r\n          ),\r\n        );\r\n      } else if (isPlainObject(item)) {\r\n        result[key] = await objectTrimMutator(item, context);\r\n      } else {\r\n        result[key] = typeof item === \"string\" ? trim(item) : item;\r\n      }\r\n    } else {\r\n      result[key] = typeof item === \"string\" ? trim(item) : item;\r\n    }\r\n  }\r\n\r\n  return result;\r\n};\r\n\r\n/** Parse JSON string */\r\nexport const jsonMutator: Mutator = async (value) => {\r\n  try {\r\n    return JSON.parse(value);\r\n  } catch {\r\n    return value;\r\n  }\r\n};\r\n"],"mappings":";;;;;;AAKA,MAAa,sBAA+B,OAAO,OAAO,YAAY;CACpE,MAAM,cAAc,CAClB,GAAI,SAAS,IAAI,SAAS,OAAO,KAAK,QAAQ,IAAI,MAAM,IAAI,CAAC,GAC7D,GAAI,SAAS,QAAQ,eAAe,CAAC,CACvC;CAEA,MAAM,SAA8B,CAAC;CAErC,KAAK,MAAM,OAAO,OAChB,IAAI,YAAY,SAAS,GAAG,GAC1B,OAAO,OAAO,MAAM;CAIxB,OAAO;AACT;;AAGA,MAAa,oBAA6B,OAAO,OAAO,YAAY;CAClE,IAAI,CAAC,cAAc,KAAK,GAAG,OAAO;CAElC,MAAM,SAA8B,CAAC;CACrC,MAAM,YAAY,SAAS,QAAQ,aAAa;CAEhD,KAAK,MAAM,OAAO,OAAO;EACvB,MAAM,OAAO,MAAM;EAEnB,IAAI,WACF,IAAI,MAAM,QAAQ,IAAI,GACpB,OAAO,OAAO,MAAM,QAAQ,IAC1B,KAAK,IAAI,OAAO,MACd,OAAO,MAAM,WAAW,KAAK,CAAC,IAAI,MAAM,kBAAkB,GAAG,OAAO,CACtE,CACF;OACK,IAAI,cAAc,IAAI,GAC3B,OAAO,OAAO,MAAM,kBAAkB,MAAM,OAAO;OAEnD,OAAO,OAAO,OAAO,SAAS,WAAW,KAAK,IAAI,IAAI;OAGxD,OAAO,OAAO,OAAO,SAAS,WAAW,KAAK,IAAI,IAAI;CAE1D;CAEA,OAAO;AACT"}

package/esm/seal/src/mutators/scalar-mutators.mjs

@@ -0,0 +1,9 @@
+//#region ../seal/src/mutators/scalar-mutators.ts
+const stringMutator = async (value) => {
+	if ([void 0, null].includes(value)) return value;
+	return String(value);
+};
+
+//#endregion
+export { stringMutator };
+//# sourceMappingURL=scalar-mutators.mjs.map

package/esm/seal/src/mutators/scalar-mutators.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"scalar-mutators.mjs","names":[],"sources":["../../../../../../../../../seal/src/mutators/scalar-mutators.ts"],"sourcesContent":["import type { Mutator } from \"../types\";\r\n\r\nexport const stringMutator: Mutator = async (value) => {\r\n  if ([undefined, null].includes(value)) {\r\n    return value;\r\n  }\r\n\r\n  return String(value);\r\n};\r\n"],"mappings":";AAEA,MAAa,gBAAyB,OAAO,UAAU;CACrD,IAAI,CAAC,QAAW,IAAI,CAAC,CAAC,SAAS,KAAK,GAClC,OAAO;CAGT,OAAO,OAAO,KAAK;AACrB"}