@warlock.js/seal 3.0.14

package/README.md

@@ -0,0 +1,373 @@
+# 🔮 Warlock Seal
+
+> Cast validation seals on your schemas to protect your data
+
+A powerful, type-safe validation library for TypeScript with an intuitive API and framework-agnostic design.
+
+## 📦 Installation
+
+```bash
+npm install @warlock.js/seal
+```
+
+```bash
+yarn add @warlock.js/seal
+```
+
+```bash
+pnpm add @warlock.js/seal
+```
+
+## 🚀 Quick Start
+
+```typescript
+import { v, type Infer } from "@warlock.js/seal";
+
+// Define your validation schema (cast a seal)
+const userSeal = v.object({
+  name: v.string().required().min(3),
+  email: v.string().email().required(),
+  age: v.int().min(18),
+  status: v.string().in(["active", "inactive"]),
+});
+
+// Extract TypeScript type automatically
+type User = Infer<typeof userSeal>;
+// Result: { name: string; email: string; age: number; status: string }
+
+// Validate data
+const result = await v.validate(userSeal, userData);
+
+if (result.isValid) {
+  console.log("Data is sealed! ✅", result.data);
+} else {
+  console.log("Seal broken! ❌", result.errors);
+  // [
+  //   { error: "The name must be at least 3 characters", path: "name" },
+  //   { error: "The email must be a valid email address", path: "email" }
+  // ]
+}
+```
+
+## 🎯 Core Concepts
+
+### Three-Layer Validation Pipeline
+
+Seal uses a unique **three-layer architecture** that separates concerns:
+
+```
+Input Data
+    ↓
+🔧 MUTATORS (Prep for Validation)
+    - Normalize data before validation
+    - Examples: trim(), lowercase(), toStartOfDay()
+    - Run BEFORE validation rules
+    ↓
+✅ VALIDATORS (Check Constraints)
+    - Validate against rules
+    - Examples: email(), min(), after()
+    - Return errors if validation fails
+    ↓
+🎨 TRANSFORMERS (Format Output)
+    - Format validated data for output
+    - Examples: toISOString(), toFormat()
+    - Run AFTER validation passes
+    ↓
+Output Data
+```
+
+### Example: Date Validation
+
+```typescript
+const schema = v
+  .date()
+  .toStartOfDay() // 🔧 Mutator: normalize to 00:00:00
+  .after("2024-01-01") // ✅ Validator: check Date object
+  .toISOString(); // 🎨 Transformer: output as ISO string
+
+const result = await v.validate(schema, "2024-06-15 14:30:00");
+// result.data = "2024-06-15T00:00:00.000Z"
+```
+
+**Why this matters:**
+
+- Mutators prepare data for validation (no more string comparison issues!)
+- Validators check constraints on normalized data
+- Transformers format output without affecting validation
+
+---
+
+## 🌟 Key Features
+
+### ✅ Type Inference
+
+Automatically extract TypeScript types from your schemas:
+
+```typescript
+const schema = v.object({
+  name: v.string().required(),
+  age: v.int(),
+  tags: v.array(v.string()),
+});
+
+type User = Infer<typeof schema>;
+// { name: string; age: number; tags: string[] }
+```
+
+### ✅ Intuitive API
+
+Readable, chainable methods:
+
+```typescript
+v.string().required().email().min(5).max(100);
+
+v.int().min(0).max(100).positive();
+
+v.array(v.string()).minLength(1).unique();
+```
+
+### ✅ Conditional Validation
+
+Apply different validators based on other field values:
+
+```typescript
+const schema = v.object({
+  type: v.string().required().in(["admin", "user"]),
+  role: v.string().when("type", {
+    is: {
+      admin: v.string().required().in(["super", "moderator"]),
+      user: v.string().required().in(["member", "guest"]),
+    },
+  }),
+});
+
+// If type is "admin", role must be "super" or "moderator"
+// If type is "user", role must be "member" or "guest"
+```
+
+### ✅ Field Comparison
+
+Compare fields against each other (global or sibling scope):
+
+```typescript
+const schema = v.object({
+  password: v.string().required().min(8),
+  confirmPassword: v.string().required().sameAs("password"), // Compare with password field
+
+  startDate: v.date().required(),
+  endDate: v.date().required().after("startDate"), // Compare with startDate field
+});
+```
+
+### ✅ Custom Validation
+
+Add your own validation logic:
+
+```typescript
+v.string().refine(async value => {
+  const exists = await checkUsername(value);
+  if (exists) return "Username already taken";
+});
+```
+
+### ✅ Mutators & Transformers
+
+Normalize input and format output:
+
+```typescript
+// String mutators
+v.string()
+  .trim() // Remove whitespace
+  .lowercase() // Convert to lowercase
+  .email() // Validate email
+  .toJSON(); // Transform to JSON string
+
+// Date mutators & transformers
+v.date()
+  .toStartOfDay() // Normalize to midnight
+  .after("2024-01-01")
+  .toISOString(); // Output as ISO string
+```
+
+---
+
+## 📚 Documentation
+
+For complete documentation, visit: **[https://warlock.js.org/seal](https://warlock.js.org/seal)**
+
+### Available Validators
+
+| Validator     | Purpose            | Example                          |
+| ------------- | ------------------ | -------------------------------- |
+| `v.string()`  | String validation  | `v.string().email().min(3)`      |
+| `v.int()`     | Integer validation | `v.int().min(0).max(100)`        |
+| `v.float()`   | Float validation   | `v.float().positive()`           |
+| `v.number()`  | Number validation  | `v.number().min(0)`              |
+| `v.boolean()` | Boolean validation | `v.boolean().accepted()`         |
+| `v.date()`    | Date validation    | `v.date().after(new Date())`     |
+| `v.array()`   | Array validation   | `v.array(v.string()).min(1)`     |
+| `v.object()`  | Object validation  | `v.object({ name: v.string() })` |
+| `v.scalar()`  | Scalar values      | `v.scalar().in([1, "2", true])`  |
+
+### Common Methods
+
+Available on all validators:
+
+| Method                     | Purpose                          |
+| -------------------------- | -------------------------------- |
+| `.required()`              | Value must be present            |
+| `.optional()`              | Value is optional                |
+| `.forbidden()`             | Value must not be present        |
+| `.equals(value)`           | Must equal specific value        |
+| `.default(value)`          | Set default value                |
+| `.allowsEmpty()`           | Skip validation if empty         |
+| `.when(field, conditions)` | Conditional validation           |
+| `.omit()`                  | Validate but exclude from output |
+| `.refine(callback)`        | Custom validation logic          |
+
+---
+
+## 💡 Examples
+
+### User Registration
+
+```typescript
+const registerSchema = v.object({
+  email: v.string().required().email(),
+  password: v.string().required().min(8).strongPassword(),
+  confirmPassword: v.string().required().sameAs("password"),
+  age: v.int().required().min(18).max(120),
+  terms: v.boolean().required().accepted(),
+});
+```
+
+### Form with Conditional Fields
+
+```typescript
+const formSchema = v.object({
+  accountType: v.string().required().in(["personal", "business"]),
+
+  // Required only if accountType is "business"
+  companyName: v.string().requiredIf("accountType", { is: "business" }),
+
+  // Conditional validation
+  taxId: v.string().when("accountType", {
+    is: {
+      business: v
+        .string()
+        .required()
+        .pattern(/^[0-9]{9}$/),
+      personal: v.string().forbidden(),
+    },
+  }),
+});
+```
+
+### Date Range Validation
+
+```typescript
+const bookingSchema = v.object({
+  checkIn: v.date().required().afterToday(),
+
+  checkOut: v
+    .date()
+    .required()
+    .after("checkIn") // Compare with checkIn field
+    .withinDays(30), // Max 30 days from checkIn
+});
+```
+
+### Array Validation
+
+```typescript
+const tagsSchema = v
+  .array(v.string())
+  .required()
+  .minLength(1)
+  .maxLength(10)
+  .unique();
+
+const usersSchema = v
+  .array(
+    v.object({
+      name: v.string().required(),
+      email: v.string().email(),
+    }),
+  )
+  .minLength(1);
+```
+
+---
+
+## 🔧 Framework Extensions
+
+For Warlock.js projects, framework-specific validators are available:
+
+```typescript
+import { v } from "@warlock.js/core/v";
+
+const schema = v.object({
+  email: v.string().email().unique(User), // Database validation
+  avatar: v.file().image().maxSize(5000000), // File upload validation
+  uploadId: v.string().uploadable(), // Upload hash validation
+});
+```
+
+---
+
+## 🎨 Why "Seal"?
+
+🔮 **Magical Context**  
+Warlocks use seals to protect and verify. Your validation schemas are seals that protect your data integrity.
+
+💻 **Programming Context**  
+A "seal of approval" - data that passes validation is sealed and verified.
+
+✨ **Developer Experience**  
+Clean, intuitive API that feels natural:
+
+```typescript
+const seal = v.object({ ... });  // Cast a seal
+await v.validate(seal, data);     // Verify with the seal
+```
+
+---
+
+## 🤝 Philosophy
+
+**Seal** is designed around three principles:
+
+1. **Type Safety First** - TypeScript support is not an afterthought
+2. **Framework Agnostic** - Works anywhere JavaScript runs
+3. **Intuitive API** - If it feels right, it probably works
+
+---
+
+## 📖 Full Documentation
+
+For complete documentation, visit: **[https://warlock.js.org/seal](https://warlock.js.org/seal)**
+
+The documentation includes:
+
+- 📘 [Getting Started Guide](https://warlock.js.org/seal/getting-started/introduction)
+- 🎯 [Core Concepts](https://warlock.js.org/seal/concepts/three-layer-architecture)
+- 📝 [Validator Reference](https://warlock.js.org/seal/base-validator)
+- 🔍 [All Validation Rules](https://warlock.js.org/seal/string-validator)
+- 🔌 [Plugin System](https://warlock.js.org/seal/advanced/plugins)
+- 🎨 [Custom Rules](https://warlock.js.org/seal/advanced/custom-rules)
+
+---
+
+## 📄 License
+
+MIT
+
+---
+
+## 🤝 Contributing
+
+See main Warlock.js repository
+
+---
+
+**Cast your seals and protect your data! 🔮✨**

package/cjs/config.d.ts

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

package/cjs/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAErE,MAAM,MAAM,qBAAqB,GAAG,CAClC,eAAe,EAAE,eAAe,KAC7B,MAAM,CAAC;AAEZ,MAAM,MAAM,0BAA0B,GAAG,CACvC,oBAAoB,EAAE,oBAAoB,KACvC,MAAM,CAAC;AAEZ,MAAM,MAAM,UAAU,GAAG;IACvB;;;OAGG;IACH,aAAa,CAAC,EAAE,qBAAqB,CAAC;IACtC;;OAEG;IACH,kBAAkB,CAAC,EAAE,0BAA0B,CAAC;IAEhD;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B,CAAC;AASF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,CAAC,UAAU,CAAC,GAAG,IAAI,CAEhE;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,UAAU,CAE1C;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,IAAI,CAKtC"}

package/cjs/config.js

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

package/cjs/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sources":["../src/config.ts"],"sourcesContent":[null],"names":[],"mappings":"aAAA;;;;AAIG;AA8BH;;AAEG;AACH,MAAM,MAAM,GAAe;AACzB,IAAA,cAAc,EAAE,IAAI;CACrB,CAAC;AAEF;;;;;;;;;;;;;AAaG;AACG,SAAU,aAAa,CAAC,OAA4B,EAAA;AACxD,IAAA,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AACjC,CAAC;AAED;;AAEG;SACa,aAAa,GAAA;AAC3B,IAAA,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;AAEG;SACa,eAAe,GAAA;IAC7B,OAAO,MAAM,CAAC,aAAa,CAAC;IAC5B,OAAO,MAAM,CAAC,kBAAkB,CAAC;AAEjC,IAAA,MAAM,CAAC,cAAc,GAAG,IAAI,CAAC;AAC/B"}

package/cjs/factory/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./validate";
+export * from "./validators";
+//# sourceMappingURL=index.d.ts.map

package/cjs/factory/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/factory/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC"}

package/cjs/factory/validate.d.ts

@@ -0,0 +1,8 @@
+import { type SealConfig } from "../config";
+import type { ValidationResult } from "../types";
+import type { BaseValidator } from "../validators";
+/**
+ * Validate data against a schema
+ */
+export declare const validate: <T extends BaseValidator>(schema: T, data: any, configurations?: SealConfig) => Promise<ValidationResult>;
+//# sourceMappingURL=validate.d.ts.map

package/cjs/factory/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/factory/validate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,UAAU,EAAE,MAAM,WAAW,CAAC;AAC3D,OAAO,KAAK,EAAiB,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAChE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD;;GAEG;AACH,eAAO,MAAM,QAAQ,6CAEb,GAAG,mBACO,UAAU,KACzB,QAAQ,gBAAgB,CAiB1B,CAAC"}

package/cjs/factory/validate.js

@@ -0,0 +1,21 @@
+'use strict';var config=require('../config.js');/**
+ * Validate data against a schema
+ */
+const validate = async (schema, data, // Temporarily use any - will fix type inference
+configurations = config.getSealConfig()) => {
+    const context = {
+        allValues: data,
+        parent: null,
+        value: data,
+        key: "",
+        path: "",
+        translateRule(ruleTranslation) {
+            return configurations.translateRule?.(ruleTranslation) ?? "";
+        },
+        translateAttribute(attributeTranslation) {
+            return configurations.translateAttribute?.(attributeTranslation) ?? "";
+        },
+        configurations,
+    };
+    return await schema.validate(data, context);
+};exports.validate=validate;//# sourceMappingURL=validate.js.map

package/cjs/factory/validate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.js","sources":["../../src/factory/validate.ts"],"sourcesContent":[null],"names":["getSealConfig"],"mappings":"gDAIA;;AAEG;AACU,MAAA,QAAQ,GAAG,OACtB,MAAS,EACT,IAAS;AACT,cAA6B,GAAAA,oBAAa,EAAE,KACf;AAC7B,IAAA,MAAM,OAAO,GAAkB;AAC7B,QAAA,SAAS,EAAE,IAAI;AACf,QAAA,MAAM,EAAE,IAAI;AACZ,QAAA,KAAK,EAAE,IAAI;AACX,QAAA,GAAG,EAAE,EAAE;AACP,QAAA,IAAI,EAAE,EAAE;AACR,QAAA,aAAa,CAAC,eAAe,EAAA;YAC3B,OAAO,cAAc,CAAC,aAAa,GAAG,eAAe,CAAC,IAAI,EAAE,CAAC;SAC9D;AACD,QAAA,kBAAkB,CAAC,oBAAoB,EAAA;YACrC,OAAO,cAAc,CAAC,kBAAkB,GAAG,oBAAoB,CAAC,IAAI,EAAE,CAAC;SACxE;QACD,cAAc;KACf,CAAC;IAEF,OAAO,MAAM,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AAC9C"}

package/cjs/factory/validators.d.ts

@@ -0,0 +1,32 @@
+import type { Schema, ValidationResult } from "../types";
+import type { BaseValidator } from "../validators";
+import { AnyValidator, ArrayValidator, BooleanValidator, DateValidator, FloatValidator, IntValidator, NumberValidator, ObjectValidator, ScalarValidator, StringValidator } from "../validators";
+/**
+ * Seal factory object - creates instances of validators
+ *
+ * Use 'v' to create validation schemas (seals) for your data
+ */
+export declare const v: ValidatorV;
+export interface ValidatorV {
+    object: <T extends Schema>(schema: T, errorMessage?: string) => ObjectValidator & {
+        schema: T;
+    };
+    any: () => AnyValidator;
+    forbidden: () => AnyValidator;
+    array: <T extends BaseValidator>(validator: T, errorMessage?: string) => ArrayValidator & {
+        validator: T;
+    };
+    date: (errorMessage?: string) => DateValidator;
+    string: (errorMessage?: string) => StringValidator;
+    enum: (values: any, errorMessage?: string) => ScalarValidator;
+    number: (errorMessage?: string) => NumberValidator;
+    int: (errorMessage?: string) => IntValidator;
+    float: (errorMessage?: string) => FloatValidator;
+    boolean: (errorMessage?: string) => BooleanValidator;
+    scalar: (errorMessage?: string) => ScalarValidator;
+    localized: (valueValidator?: BaseValidator, errorMessage?: string) => ArrayValidator & {
+        validator: BaseValidator;
+    };
+    validate: <T extends BaseValidator>(schema: T, data: any) => Promise<ValidationResult>;
+}
+//# sourceMappingURL=validators.d.ts.map

package/cjs/factory/validators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.d.ts","sourceRoot":"","sources":["../../src/factory/validators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EACL,YAAY,EACZ,cAAc,EACd,gBAAgB,EAChB,aAAa,EACb,cAAc,EACd,YAAY,EACZ,eAAe,EACf,eAAe,EACf,eAAe,EACf,eAAe,EAChB,MAAM,eAAe,CAAC;AAGvB;;;;GAIG;AACH,eAAO,MAAM,CAAC,EAAE,UAwDU,CAAC;AAE3B,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,CAAC,CAAC,SAAS,MAAM,EACvB,MAAM,EAAE,CAAC,EACT,YAAY,CAAC,EAAE,MAAM,KAClB,eAAe,GAAG;QACrB,MAAM,EAAE,CAAC,CAAC;KACX,CAAC;IACF,GAAG,EAAE,MAAM,YAAY,CAAC;IACxB,SAAS,EAAE,MAAM,YAAY,CAAC;IAC9B,KAAK,EAAE,CAAC,CAAC,SAAS,aAAa,EAC7B,SAAS,EAAE,CAAC,EACZ,YAAY,CAAC,EAAE,MAAM,KAClB,cAAc,GAAG;QACpB,SAAS,EAAE,CAAC,CAAC;KACd,CAAC;IACF,IAAI,EAAE,CAAC,YAAY,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;IAC/C,MAAM,EAAE,CAAC,YAAY,CAAC,EAAE,MAAM,KAAK,eAAe,CAAC;IACnD,IAAI,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,YAAY,CAAC,EAAE,MAAM,KAAK,eAAe,CAAC;IAC9D,MAAM,EAAE,CAAC,YAAY,CAAC,EAAE,MAAM,KAAK,eAAe,CAAC;IACnD,GAAG,EAAE,CAAC,YAAY,CAAC,EAAE,MAAM,KAAK,YAAY,CAAC;IAC7C,KAAK,EAAE,CAAC,YAAY,CAAC,EAAE,MAAM,KAAK,cAAc,CAAC;IACjD,OAAO,EAAE,CAAC,YAAY,CAAC,EAAE,MAAM,KAAK,gBAAgB,CAAC;IACrD,MAAM,EAAE,CAAC,YAAY,CAAC,EAAE,MAAM,KAAK,eAAe,CAAC;IACnD,SAAS,EAAE,CACT,cAAc,CAAC,EAAE,aAAa,EAC9B,YAAY,CAAC,EAAE,MAAM,KAClB,cAAc,GAAG;QACpB,SAAS,EAAE,aAAa,CAAC;KAC1B,CAAC;IACF,QAAQ,EAAE,CAAC,CAAC,SAAS,aAAa,EAChC,MAAM,EAAE,CAAC,EACT,IAAI,EAAE,GAAG,KACN,OAAO,CAAC,gBAAgB,CAAC,CAAC;CAChC"}

package/cjs/factory/validators.js

@@ -0,0 +1,38 @@
+'use strict';var anyValidator=require('../validators/any-validator.js'),arrayValidator=require('../validators/array-validator.js');require('@mongez/reinforcements'),require('@mongez/supportive-is'),require('net');var booleanValidator=require('../validators/boolean-validator.js'),dateValidator=require('../validators/date-validator.js'),floatValidator=require('../validators/float-validator.js'),intValidator=require('../validators/int-validator.js'),numberValidator=require('../validators/number-validator.js'),objectValidator=require('../validators/object-validator.js'),scalarValidator=require('../validators/scalar-validator.js'),stringValidator=require('../validators/string-validator.js'),validate=require('./validate.js');/**
+ * Seal factory object - creates instances of validators
+ *
+ * Use 'v' to create validation schemas (seals) for your data
+ */
+const v = {
+    /** Create an object validator */
+    object: (schema, errorMessage) => new objectValidator.ObjectValidator(schema, errorMessage),
+    /** Create an any validator */
+    any: () => new anyValidator.AnyValidator(),
+    /** Create a forbidden validator */
+    forbidden: () => v.any().forbidden(),
+    /** Create an array validator */
+    array: (validator, errorMessage) => new arrayValidator.ArrayValidator(validator, errorMessage),
+    /** Create a date validator */
+    date: (errorMessage) => new dateValidator.DateValidator(errorMessage),
+    /** Create a string validator */
+    string: (errorMessage) => new stringValidator.StringValidator(errorMessage),
+    /** Create an enum validator */
+    enum: (values, errorMessage) => new stringValidator.StringValidator().enum(values, errorMessage),
+    /** Create a number validator */
+    number: (errorMessage) => new numberValidator.NumberValidator(errorMessage),
+    /** Create an integer validator */
+    int: (errorMessage) => new intValidator.IntValidator(errorMessage),
+    /** Create a float validator */
+    float: (errorMessage) => new floatValidator.FloatValidator(errorMessage),
+    /** Create a boolean validator */
+    boolean: (errorMessage) => new booleanValidator.BooleanValidator(errorMessage),
+    /** Create a scalar validator */
+    scalar: (errorMessage) => new scalarValidator.ScalarValidator(errorMessage),
+    /** Create a localized array validator */
+    localized: (valueValidator, errorMessage) => v.array(v.object({
+        localeCode: v.string().required(),
+        value: (valueValidator || v.string()).required(),
+    }), errorMessage),
+    /** Validate data against a schema */
+    validate: validate.validate,
+};exports.v=v;//# sourceMappingURL=validators.js.map

package/cjs/factory/validators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.js","sources":["../../src/factory/validators.ts"],"sourcesContent":[null],"names":["ObjectValidator","AnyValidator","ArrayValidator","DateValidator","StringValidator","NumberValidator","IntValidator","FloatValidator","BooleanValidator","ScalarValidator","validateFunction"],"mappings":"ytBAgBA;;;;AAIG;AACU,MAAA,CAAC,GAAe;;AAE3B,IAAA,MAAM,EAAE,CAAmB,MAAS,EAAE,YAAqB,KACzD,IAAIA,+BAAe,CAAC,MAAM,EAAE,YAAY,CAEvC;;AAGH,IAAA,GAAG,EAAE,MAAM,IAAIC,yBAAY,EAAE;;IAG7B,SAAS,EAAE,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,SAAS,EAAE;;AAGpC,IAAA,KAAK,EAAE,CAA0B,SAAY,EAAE,YAAqB,KAClE,IAAIC,6BAAc,CAAC,SAAS,EAAE,YAAY,CAEzC;;IAGH,IAAI,EAAE,CAAC,YAAqB,KAAK,IAAIC,2BAAa,CAAC,YAAY,CAAC;;IAGhE,MAAM,EAAE,CAAC,YAAqB,KAAK,IAAIC,+BAAe,CAAC,YAAY,CAAC;;AAGpE,IAAA,IAAI,EAAE,CAAC,MAAW,EAAE,YAAqB,KACvC,IAAIA,+BAAe,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,YAAY,CAAC;;IAGlD,MAAM,EAAE,CAAC,YAAqB,KAAK,IAAIC,+BAAe,CAAC,YAAY,CAAC;;IAGpE,GAAG,EAAE,CAAC,YAAqB,KAAK,IAAIC,yBAAY,CAAC,YAAY,CAAC;;IAG9D,KAAK,EAAE,CAAC,YAAqB,KAAK,IAAIC,6BAAc,CAAC,YAAY,CAAC;;IAGlE,OAAO,EAAE,CAAC,YAAqB,KAAK,IAAIC,iCAAgB,CAAC,YAAY,CAAC;;IAGtE,MAAM,EAAE,CAAC,YAAqB,KAAK,IAAIC,+BAAe,CAAC,YAAY,CAAC;;AAGpE,IAAA,SAAS,EAAE,CAAC,cAA8B,EAAE,YAAqB,KAC/D,CAAC,CAAC,KAAK,CACL,CAAC,CAAC,MAAM,CAAC;AACP,QAAA,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QACjC,KAAK,EAAE,CAAC,cAAc,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,QAAQ,EAAE;KACjD,CAAC,EACF,YAAY,CACb;;AAGH,IAAA,QAAQ,EAAEC,iBAAgB;"}

package/cjs/helpers/date-helpers.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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
+ */
+export declare function isDateValue(value: any): boolean;
+//# sourceMappingURL=date-helpers.d.ts.map

package/cjs/helpers/date-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-helpers.d.ts","sourceRoot":"","sources":["../../src/helpers/date-helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO,CAU/C"}

package/cjs/helpers/date-helpers.js

@@ -0,0 +1,25 @@
+'use strict';/**
+ * 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;
+    if (typeof value === "number")
+        return true;
+    if (typeof value === "string" &&
+        (value.includes("-") || value.includes("/"))) {
+        return true;
+    }
+    return false;
+}exports.isDateValue=isDateValue;//# sourceMappingURL=date-helpers.js.map

package/cjs/helpers/date-helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-helpers.js","sources":["../../src/helpers/date-helpers.ts"],"sourcesContent":[null],"names":[],"mappings":"aAAA;;;;;;;;;;;;;AAaG;AACG,SAAU,WAAW,CAAC,KAAU,EAAA;IACpC,IAAI,KAAK,YAAY,IAAI;AAAE,QAAA,OAAO,IAAI,CAAC;IACvC,IAAI,OAAO,KAAK,KAAK,QAAQ;AAAE,QAAA,OAAO,IAAI,CAAC;IAC3C,IACE,OAAO,KAAK,KAAK,QAAQ;AACzB,SAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAC5C;AACA,QAAA,OAAO,IAAI,CAAC;AACb,KAAA;AACD,IAAA,OAAO,KAAK,CAAC;AACf"}