json-schema-compatibility-checker 1.0.10 → 1.1.0

package/README.md

@@ -1,70 +1,73 @@
 # JSON Schema Compatibility Checker
 
-> Vérifiez la compatibilité structurelle entre JSON Schemas (Draft-07) grâce à une approche mathématique par intersection ensembliste.
+> Check structural compatibility between JSON Schemas (Draft-07) using a set-theoretic intersection approach.
 
 ---
 
 ## Sommaire
 
 - [Introduction](#introduction)
-- [Principe mathématique](#principe-mathématique)
+- [Mathematical Principle](#mathematical-principle)
 - [Installation](#installation)
-- [Démarrage rapide](#démarrage-rapide)
+- [Quick Start](#quick-start)
 - [API Reference](#api-reference)
-- [Documentation complète](#-documentation-complète)
-- [Limitations connues](#limitations-connues)
-- [Licence](#licence)
+- [Runtime Validation & Custom Constraints](#runtime-validation--custom-constraints)
+- [Full Documentation](#-full-documentation)
+- [Known Limitations](#known-limitations)
+- [License](#license)
 
 ---
 
 ## Introduction
 
-**JSON Schema Compatibility Checker** est une librairie TypeScript qui permet de vérifier la compatibilité structurelle entre deux JSON Schemas au format Draft-07.
+**JSON Schema Compatibility Checker** is a TypeScript library that checks structural compatibility between two JSON Schemas (Draft-07).
 
-### Pourquoi cette librairie ?
+### Why this library?
 
-Dans les systèmes de type workflow, orchestration de nœuds, ou intégration d'API, une question revient constamment :
+In workflow systems, node orchestration, or API integration, a recurring question is:
 
-> *"Est-ce que la sortie du composant A est compatible avec l'entrée du composant B ?"*
+> *"Is the output of component A compatible with the input of component B?"*
 
-Autrement dit : **toute donnée produite par A sera-t-elle acceptée par B ?**
+In other words: **will every value produced by A be accepted by B?**
 
-Cette librairie répond à cette question en vérifiant si un schema est un **sous-ensemble** d'un autre, avec un diagnostic structurel détaillé en cas d'incompatibilité.
+This library answers that question by checking if one schema is a **subset** of another, with detailed structural diagnostics when incompatible.
 
-### Ce que fait la librairie
+### What it does
 
-- ✅ Vérifie si un schema est un sous-ensemble d'un autre (`sub ⊆ sup`)
-- ✅ Produit un diagnostic détaillé avec les différences structurelles
-- ✅ Calcule l'intersection de deux schemas (`allOf` merge)
-- ✅ Accumule des schemas séquentiellement via deep spread (`overlay`)
-- ✅ Résout les conditions `if/then/else` avec des données discriminantes
-- ✅ Gère `anyOf`, `oneOf`, `not`, `format`, `pattern`, `dependencies`, etc.
-- ✅ Gère `oneOf`/`anyOf` imbriqués dans les propriétés d'objets et les items de tableaux
-- ✅ Compare des patterns regex par échantillonnage
-- ✅ Fournit un formatage lisible des résultats pour le debug
+- ✅ Checks if a schema is a subset of another (`sub ⊆ sup`)
+- ✅ Produces detailed diagnostics with structural differences
+- ✅ Computes the intersection of two schemas (`allOf` merge)
+- ✅ Accumulates schemas sequentially via deep spread (`overlay`)
+- ✅ Resolves `if/then/else` conditions with discriminant data
+- ✅ Handles `anyOf`, `oneOf`, `not`, `format`, `pattern`, `dependencies`, etc.
+- ✅ Handles `oneOf`/`anyOf` nested inside object properties and array items
+- ✅ Compares regex patterns via sampling
+- ✅ Validates runtime data against resolved schemas (via [AJV](https://ajv.js.org/))
+- ✅ Supports custom `constraints` keyword with user-provided validators
+- ✅ Provides human-readable formatting of results for debugging
 
 ---
 
-## Principe mathématique
+## Mathematical Principle
 
-Le cœur de la librairie repose sur un principe ensembliste simple :
+The core of the library relies on a simple set-theoretic principle:
 
 ```
 A ⊆ B  ⟺  A ∩ B ≡ A
 ```
 
-**Un schema A est sous-ensemble de B si et seulement si l'intersection de A et B est structurellement identique à A.**
+**A schema A is a subset of B if and only if the intersection of A and B is structurally identical to A.**
 
-En JSON Schema, cela se traduit par :
+In JSON Schema terms:
 
-| Concept mathématique | Traduction JSON Schema |
+| Mathematical concept | JSON Schema translation |
 |---|---|
-| `A ∩ B` | `allOf([A, B])` résolu via merge |
-| `≡` (équivalence) | Comparaison structurelle profonde |
+| `A ∩ B` | `allOf([A, B])` resolved via merge |
+| `≡` (equivalence) | Deep structural comparison |
 
-Si après le merge (intersection), le résultat est identique au schema original `A`, alors `A` n'a pas été "restreint" par `B` — ce qui signifie que `A` est déjà inclus dans `B`.
+If after the merge (intersection) the result is identical to the original schema `A`, then `A` was not "restricted" by `B` — meaning `A` is already contained within `B`.
 
-Si le merge produit un résultat différent de `A`, les différences structurelles constituent le **diagnostic** de l'incompatibilité.
+If the merge produces a result different from `A`, the structural differences constitute the **diagnostic** of the incompatibility.
 
 ---
 
@@ -74,20 +77,29 @@ Si le merge produit un résultat différent de `A`, les différences structurell
 bun add json-schema-compatibility-checker
 ```
 
-> **Prérequis** : TypeScript ≥ 5, runtime compatible ESM (Bun, Node 18+).
+> **Prerequisites**: TypeScript ≥ 5, ESM-compatible runtime (Bun, Node 18+).
+
+### Runtime dependencies
+
+| Package | Role | Size impact |
+|---|---|---|
+| `@x0k/json-schema-merge` | Schema intersection (`allOf` merge) | lightweight |
+| `ajv` + `ajv-formats` | Runtime JSON Schema validation (condition evaluation, data validation) | ~250KB |
+| `class-validator` | Format validation helpers | lightweight |
+| `randexp` | Regex pattern sampling for subset analysis | lightweight |
 
 ---
 
-## Démarrage rapide
+## Quick Start
 
-L'exemple le plus simple : vérifier si un schema strict est compatible avec un schema plus permissif.
+The simplest example: check if a strict schema is compatible with a more permissive one.
 
 ```ts
 import { JsonSchemaCompatibilityChecker } from "json-schema-compatibility-checker";
 
 const checker = new JsonSchemaCompatibilityChecker();
 
-// Schema strict : exige name ET age
+// Strict schema: requires name AND age
 const strict = {
   type: "object",
   properties: {
@@ -97,7 +109,7 @@ const strict = {
   required: ["name", "age"],
 };
 
-// Schema permissif : exige seulement name
+// Permissive schema: requires only name
 const loose = {
   type: "object",
   properties: {
@@ -106,12 +118,12 @@ const loose = {
   required: ["name"],
 };
 
-// Un objet valide pour strict est-il toujours valide pour loose ?
+// Is every value valid for strict also valid for loose?
 console.log(checker.isSubset(strict, loose)); // true ✅
 
-// L'inverse est-il vrai ?
+// Is the reverse true?
 console.log(checker.isSubset(loose, strict)); // false ❌
-// → Un objet { name: "Alice" } (sans age) est valide pour loose mais pas pour strict
+// → An object { name: "Alice" } (no age) is valid for loose but not for strict
 ```
 
 ---
@@ -120,26 +132,27 @@ console.log(checker.isSubset(loose, strict)); // false ❌
 
 ### `JsonSchemaCompatibilityChecker`
 
-Toutes les méthodes de vérification de compatibilité sont exposées par la classe `JsonSchemaCompatibilityChecker`.
+All compatibility checking methods are exposed by the `JsonSchemaCompatibilityChecker` class.
 
 ```ts
 const checker = new JsonSchemaCompatibilityChecker();
 ```
 
-| Méthode | Description | Retour |
+| Method | Description | Returns |
 |---|---|---|
-| `isSubset(sub, sup)` | Vérifie si `sub ⊆ sup` | `boolean` |
-| `check(sub, sup)` | Vérifie avec diagnostic détaillé | `SubsetResult` |
-| `check(sub, sup, options)` | Vérifie avec résolution des conditions `if/then/else` | `ResolvedSubsetResult` |
-| `isEqual(a, b)` | Égalité structurelle après normalisation | `boolean` |
-| `intersect(a, b)` | Intersection de deux schemas | `JSONSchema7Definition \| null` |
-| `resolveConditions(schema, data)` | Résout les `if/then/else` avec des données | `ResolvedConditionResult` |
-| `normalize(schema)` | Normalise un schema (infère types, résout double négation) | `JSONSchema7Definition` |
-| `formatResult(label, result)` | Formate un résultat pour le debug | `string` |
+| `isSubset(sub, sup)` | Checks if `sub ⊆ sup` | `boolean` |
+| `check(sub, sup)` | Checks with detailed diagnostics | `SubsetResult` |
+| `check(sub, sup, options)` | Checks with `if/then/else` condition resolution and runtime validation | `ResolvedSubsetResult` |
+| `isEqual(a, b)` | Structural equality after normalization | `boolean` |
+| `intersect(a, b)` | Intersection of two schemas | `JSONSchema7Definition \| null` |
+| `resolveConditions(schema, data)` | Resolves `if/then/else` with runtime data | `ResolvedConditionResult` |
+| `normalize(schema)` | Normalizes a schema (infers types, resolves double negation, canonicalizes constraints) | `JSONSchema7Definition` |
+| `formatResult(label, result)` | Formats a result for debug output | `string` |
+| `clearValidatorCache()` | Clears the AJV compiled validator caches (useful for long-running processes or tests) | `void` |
 
 ### `MergeEngine`
 
-Opérations bas-niveau sur les schemas : intersection (`allOf` merge) et overlay (deep spread séquentiel).
+Low-level schema operations: intersection (`allOf` merge) and overlay (sequential deep spread).
 
 ```ts
 import { MergeEngine } from "json-schema-compatibility-checker";
@@ -147,15 +160,15 @@ import { MergeEngine } from "json-schema-compatibility-checker";
 const engine = new MergeEngine();
 ```
 
-| Méthode | Description | Retour |
+| Method | Description | Returns |
 |---|---|---|
-| `merge(a, b)` | Intersection `allOf([a, b])` — retourne `null` si incompatible | `JSONSchema7Definition \| null` |
-| `mergeOrThrow(a, b)` | Comme `merge`, mais lève une exception si incompatible | `JSONSchema7Definition` |
-| `overlay(base, override)` | Deep spread séquentiel — last writer wins par propriété | `JSONSchema7Definition` |
-| `compare(a, b)` | Comparaison structurelle (0 = identique) | `number` |
-| `isEqual(a, b)` | Égalité structurelle | `boolean` |
+| `merge(a, b)` | Intersection `allOf([a, b])` — returns `null` if incompatible | `JSONSchema7Definition \| null` |
+| `mergeOrThrow(a, b)` | Like `merge`, but throws if incompatible | `JSONSchema7Definition` |
+| `overlay(base, override)` | Sequential deep spread — last writer wins per property | `JSONSchema7Definition` |
+| `compare(a, b)` | Structural comparison (0 = identical) | `number` |
+| `isEqual(a, b)` | Structural equality | `boolean` |
 
-**Exemple rapide — `check` avec diagnostic :**
+**Quick example — `check` with diagnostics:**
 
 ```ts
 const result = checker.check(
@@ -168,78 +181,140 @@ console.log(result.errors);
 // [{ key: "age", expected: "number", received: "undefined" }]
 ```
 
-**Exemple rapide — résolution de conditions :**
+**Quick example — condition resolution:**
 
 ```ts
 const result = checker.check(sub, conditionalSup, {
-  subData: { kind: "text" },
+  data: { kind: "text" },
 });
 console.log(result.isSubset);          // true ✅
 console.log(result.resolvedSup.branch); // "then"
 ```
 
-**Exemple rapide — `overlay` pour accumulation séquentielle :**
+**Quick example — `overlay` for sequential accumulation:**
 
 ```ts
 import { MergeEngine } from "json-schema-compatibility-checker";
 
 const engine = new MergeEngine();
 
-// Node1 produit accountId avec enum
+// Node1 produces accountId with enum
 const node1Output = {
   type: "object",
   properties: { accountId: { type: "string", enum: ["a", "b"] } },
   required: ["accountId"],
 };
 
-// Node2 redéfinit accountId en string simple (plus large)
+// Node2 redefines accountId as a simple string (wider)
 const node2Output = {
   type: "object",
   properties: { accountId: { type: "string" } },
   required: ["accountId"],
 };
 
-// ❌ merge (intersection) : garde l'enum — FAUX pour un pipeline séquentiel
+// ❌ merge (intersection): keeps the enum — WRONG for a sequential pipeline
 engine.merge(node1Output, node2Output);
 // → { ..., properties: { accountId: { type: "string", enum: ["a", "b"] } } }
 
-// ✅ overlay (deep spread) : le dernier écrivain gagne — CORRECT
+// ✅ overlay (deep spread): last writer wins — CORRECT
 engine.overlay(node1Output, node2Output);
 // → { ..., properties: { accountId: { type: "string" } } }
 ```
 
-👉 Pour la documentation complète de chaque méthode avec tous les exemples, consultez la **[Référence API](./docs/api-reference.md)**.
+👉 For full documentation of every method with examples, see the **[API Reference](./docs/api-reference.md)**.
+
+---
+
+## Runtime Validation & Custom Constraints
+
+### Runtime data validation
+
+When `check()` is called with `{ data }`, the library uses [AJV](https://ajv.js.org/) (JSON Schema validator) to:
+
+1. **Resolve `if/then/else` conditions** — evaluates the `if` schema against the data to determine which branch applies
+2. **Validate data against both resolved schemas** — catches data-level violations (wrong format, out of range, etc.)
+
+```ts
+const result = checker.check(sub, sup, {
+  data: { kind: "email", value: "test@example.com" },
+});
+// result.isSubset — structural compatibility
+// result.errors   — includes runtime validation errors prefixed with $sub / $sup
+```
+
+### Custom `constraints` keyword
+
+The library extends JSON Schema with a custom `constraints` keyword for domain-specific validation rules that go beyond what JSON Schema can express (e.g. "is a valid UUID", "belongs to scope", "minimum age"):
+
+```ts
+import { JsonSchemaCompatibilityChecker } from "json-schema-compatibility-checker";
+
+const checker = new JsonSchemaCompatibilityChecker({
+  constraints: {
+    IsUuid: (value) => ({
+      valid: typeof value === "string" && /^[0-9a-f]{8}-/.test(value),
+      message: "Value must be a valid UUID",
+    }),
+    MinAge: (value, params) => ({
+      valid: typeof value === "number" && value >= (params?.min ?? 0),
+      message: `Value must be at least ${params?.min}`,
+    }),
+  },
+});
+
+// Constraints in schemas
+const sub = {
+  type: "object",
+  properties: {
+    id: { type: "string", constraints: ["IsUuid"] },
+    age: { type: "number", constraints: [{ name: "MinAge", params: { min: 18 } }] },
+  },
+  required: ["id", "age"],
+};
+
+// Static subset checking works with constraints (structural comparison)
+checker.isSubset(sub, sup); // compares constraints via deepEqual after merge
+
+// Runtime validation evaluates constraints against actual data
+checker.check(sub, sup, { data: { id: "not-a-uuid", age: 15 } });
+// → errors include constraint violations
+```
+
+Constraints are handled at three levels:
+- **Structurally**: the merge engine unions them (intersection semantics — `allOf`)
+- **Statically**: the subset checker compares them via `deepEqual` after merge
+- **At runtime**: the constraint validator evaluates them against concrete data
 
 ---
 
-## 📖 Documentation complète
+## 📖 Full Documentation
 
 | Page | Description |
 |---|---|
-| **[Référence API](./docs/api-reference.md)** | Documentation détaillée de chaque méthode (`JsonSchemaCompatibilityChecker` + `MergeEngine`) avec exemples |
-| **[Guide des fonctionnalités](./docs/features-guide.md)** | Tour complet des fonctionnalités : types, `required`, contraintes numériques, `enum`/`const`, `anyOf`/`oneOf`, `not`, `format`, `pattern`, conditions `if/then/else`, `allOf`... |
-| **[Fonctions utilitaires](./docs/utilities.md)** | `isPatternSubset`, `arePatternsEquivalent`, `isTrivialPattern` |
-| **[Cas d'usage concrets](./docs/use-cases.md)** | Connexion de nœuds, pipeline séquentiel (overlay), validation de réponse API, unions discriminées, formulaires conditionnels |
-| **[Types exportés](./docs/types.md)** | `SubsetResult`, `SchemaError`, `ResolvedConditionResult`, `ResolvedSubsetResult`, `CheckConditionsOptions` |
-| **[Limitations connues](./docs/limitations.md)** | Cross-keyword constraints, `oneOf` exclusivité, patterns probabilistes, `$ref` non supporté |
-| **[Architecture interne](./docs/architecture.md)** | Diagramme des modules, flux de vérification, merge vs overlay, dépendances |
+| **[API Reference](./docs/api-reference.md)** | Detailed documentation of every method (`JsonSchemaCompatibilityChecker` + `MergeEngine`) with examples |
+| **[Features Guide](./docs/features-guide.md)** | Complete feature tour: types, `required`, numeric constraints, `enum`/`const`, `anyOf`/`oneOf`, `not`, `format`, `pattern`, `if/then/else` conditions, `allOf`, custom `constraints`... |
+| **[Utility Functions](./docs/utilities.md)** | `isPatternSubset`, `arePatternsEquivalent`, `isTrivialPattern` |
+| **[Use Cases](./docs/use-cases.md)** | Node connection, sequential pipeline (overlay), API response validation, discriminated unions, conditional forms |
+| **[Exported Types](./docs/types.md)** | `SubsetResult`, `SchemaError`, `ResolvedConditionResult`, `ResolvedSubsetResult`, `CheckRuntimeOptions`, `ConstraintValidator`, `CheckerOptions` |
+| **[Known Limitations](./docs/limitations.md)** | Cross-keyword constraints, `oneOf` exclusivity, probabilistic patterns, `$ref` not supported |
+| **[Internal Architecture](./docs/architecture.md)** | Module diagram, verification flow, merge vs overlay, dependencies |
 
 ---
 
-## Limitations connues
+## Known Limitations
 
-- **Cross-keyword constraints** : `exclusiveMinimum` vs `minimum` peut produire des faux négatifs (limitation structurelle)
-- **`oneOf` exclusivité** : traité comme `anyOf` — l'exclusivité sémantique n'est pas vérifiée
-- **Patterns regex** : approche probabiliste par échantillonnage (200 samples), pas une preuve formelle
-- **`if/then/else`** : nécessite des données discriminantes via `check(sub, sup, { subData })`
-- **`$ref`** : non supporté — les schemas doivent être pré-déréférencés
-- **`patternProperties`** : support partiel
-- **Nested branching fallback** : le fallback propriété-par-propriété pour `oneOf`/`anyOf` imbriqués ne vérifie pas les mots-clés au niveau objet (`minProperties`/`maxProperties`) — ceux-ci sont gérés par le merge quand le branching n'est pas impliqué
+- **Cross-keyword constraints**: `exclusiveMinimum` vs `minimum` comparison may produce false negatives (structural limitation)
+- **`oneOf` exclusivity**: treated like `anyOf` — semantic exclusivity is not verified
+- **Regex patterns**: probabilistic approach via sampling (200 samples), not a formal proof
+- **`if/then/else`**: requires discriminant data via `check(sub, sup, { data })`
+- **`$ref`**: not supported — schemas must be pre-dereferenced
+- **`patternProperties`**: partial support only
+- **Nested branching fallback**: the property-by-property fallback for nested `oneOf`/`anyOf` does not check object-level keywords (`minProperties`/`maxProperties`) — those are handled by the merge when branching is not involved
 
-👉 Détails et exemples dans **[Limitations connues](./docs/limitations.md)**.
+👉 Details and examples in **[Known Limitations](./docs/limitations.md)**.
 
 ---
 
-## Licence
+## License
 
 MIT

package/dist/cjs/condition-resolver.d.ts

@@ -2,12 +2,12 @@ import type { JSONSchema7 } from "json-schema";
 import type { MergeEngine } from "./merge-engine.js";
 import type { ResolvedConditionResult } from "./types.js";
 /**
- * Résout les `if/then/else` d'un schema en évaluant le `if` contre
- * des données partielles (discriminants).
+ * Resolves `if/then/else` in a schema by evaluating the `if` against
+ * partial data (discriminants).
  *
- * @param schema  Le schema contenant potentiellement des if/then/else
- * @param data    Données partielles utilisées pour évaluer les conditions
- * @param engine  Le MergeEngine pour merger les branches
+ * @param schema  The schema potentially containing if/then/else
+ * @param data    Partial data used to evaluate the conditions
+ * @param engine  The MergeEngine for merging branches
  *
  * @example
  * ```ts
@@ -20,7 +20,7 @@ import type { ResolvedConditionResult } from "./types.js";
  * };
  *
  * const { resolved } = resolveConditions(form, { accountType: "business" }, engine);
- * // → resolved n'a plus de if/then/else, mais a required: ["companyName"]
+ * // → resolved no longer has if/then/else, but has required: ["companyName"]
  * ```
  */
 export declare function resolveConditions(schema: JSONSchema7, data: Record<string, unknown>, engine: MergeEngine): ResolvedConditionResult;

package/dist/cjs/condition-resolver.js

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"resolveConditions",{enumerable:true,get:function(){return resolveConditions}});const _formatvalidator=require("./format-validator.js");const _normalizer=require("./normalizer.js");const _utils=require("./utils.js");const SPECIAL_MERGE_KEYS=new Set(["required","properties","dependencies"]);const SUB_SCHEMA_KEYS=new Set(["additionalProperties","items","contains","propertyNames","not"]);const MIN_KEYS=new Set(["minimum","exclusiveMinimum","minLength","minItems","minProperties"]);const MAX_KEYS=new Set(["maximum","exclusiveMaximum","maxLength","maxItems","maxProperties"]);function matchesType(value,type){if(type===undefined)return true;const types=Array.isArray(type)?type:[type];const actualType=(0,_normalizer.inferType)(value);return types.some(t=>t===actualType||t==="number"&&actualType==="integer")}function evaluateNumericConstraints(value,prop){if(prop.minimum!==undefined&&!(value>=prop.minimum))return false;if(prop.maximum!==undefined&&!(value<=prop.maximum))return false;if(prop.exclusiveMinimum!==undefined&&!(value>prop.exclusiveMinimum))return false;if(prop.exclusiveMaximum!==undefined&&!(value<prop.exclusiveMaximum))return false;if(prop.multipleOf!==undefined&&value%prop.multipleOf!==0)return false;return true}const patternRegexCache=new Map;function getOrCompileRegex(pattern){let regex=patternRegexCache.get(pattern);if(regex===undefined){regex=new RegExp(pattern);patternRegexCache.set(pattern,regex)}return regex}function evaluateStringConstraints(value,prop){if(prop.minLength!==undefined&&!(value.length>=prop.minLength))return false;if(prop.maxLength!==undefined&&!(value.length<=prop.maxLength))return false;if(prop.pattern!==undefined&&!getOrCompileRegex(prop.pattern).test(value))return false;return true}function evaluateArrayConstraints(value,prop){if(prop.minItems!==undefined&&!(value.length>=prop.minItems))return false;if(prop.maxItems!==undefined&&!(value.length<=prop.maxItems))return false;if(prop.uniqueItems===true){const len=value.length;for(let i=0;i<len;i++){for(let j=i+1;j<len;j++){if((0,_utils.deepEqual)(value[i],value[j]))return false}}}return true}function evaluateCondition(ifSchema,data){if((0,_utils.isPlainObj)(ifSchema.properties)){const propsOk=Object.keys(ifSchema.properties).every(key=>{const propDef=ifSchema.properties?.[key];if(typeof propDef==="boolean")return true;const prop=propDef;const value=data[key];if(value===undefined)return true;if((0,_utils.hasOwn)(prop,"const")){if(!(0,_utils.deepEqual)(value,prop.const))return false}if((0,_utils.hasOwn)(prop,"enum")){if(!prop.enum?.some(v=>(0,_utils.deepEqual)(v,value)))return false}if((0,_utils.hasOwn)(prop,"type")&&value!==undefined){if(!matchesType(value,prop.type))return false}if(typeof value==="number"){if(!evaluateNumericConstraints(value,prop))return false}if(typeof value==="string"){if(!evaluateStringConstraints(value,prop))return false}if(Array.isArray(value)){if(!evaluateArrayConstraints(value,prop))return false}if(prop.format!==undefined&&typeof value==="string"){const formatResult=(0,_formatvalidator.validateFormat)(value,prop.format);if(formatResult===false)return false}if((0,_utils.isPlainObj)(prop.properties)||Array.isArray(prop.required)){if((0,_utils.isPlainObj)(value)){if(!evaluateCondition(prop,value)){return false}}}return true});if(!propsOk)return false}if(Array.isArray(ifSchema.required)){const allRequired=ifSchema.required.every(key=>(0,_utils.hasOwn)(data,key));if(!allRequired)return false}if(Array.isArray(ifSchema.allOf)){const allMatch=ifSchema.allOf.every(entry=>{if(typeof entry==="boolean")return entry;return evaluateCondition(entry,data)});if(!allMatch)return false}if(Array.isArray(ifSchema.anyOf)){const anyMatch=ifSchema.anyOf.some(entry=>{if(typeof entry==="boolean")return entry;return evaluateCondition(entry,data)});if(!anyMatch)return false}if(Array.isArray(ifSchema.oneOf)){let matchCount=0;for(const entry of ifSchema.oneOf){const matches=typeof entry==="boolean"?entry:evaluateCondition(entry,data);if(matches)matchCount++;if(matchCount>1)break}if(matchCount!==1)return false}if((0,_utils.hasOwn)(ifSchema,"not")&&(0,_utils.isPlainObj)(ifSchema.not)&&typeof ifSchema.not!=="boolean"){const notResult=evaluateCondition(ifSchema.not,data);if(notResult)return false}return true}const DISCRIMINANT_INDICATORS=["const","enum","minimum","maximum","exclusiveMinimum","exclusiveMaximum","pattern","minLength","maxLength","multipleOf","minItems","maxItems","format"];function extractDiscriminants(ifSchema,data,out){if(!(0,_utils.isPlainObj)(ifSchema.properties))return;const props=ifSchema.properties;for(const key of Object.keys(props)){const propDef=props[key];if(typeof propDef==="boolean")continue;const prop=propDef;const hasIndicator=DISCRIMINANT_INDICATORS.some(indicator=>(0,_utils.hasOwn)(prop,indicator));if(hasIndicator&&(0,_utils.hasOwn)(data,key)){out[key]=data[key]}}}function mergeBranchInto(resolved,branchDef,engine){if(typeof branchDef==="boolean")return;const branchSchema=branchDef;if(Array.isArray(branchSchema.required)){resolved.required=(0,_utils.unionStrings)(resolved.required??[],branchSchema.required)}if((0,_utils.isPlainObj)(branchSchema.properties)){const branchProps=branchSchema.properties;const mergedProps={...resolved.properties??{}};for(const key of Object.keys(branchProps)){const branchProp=branchProps[key];if(branchProp===undefined)continue;const existing=resolved.properties?.[key];if(existing!==undefined&&typeof existing!=="boolean"&&typeof branchProp!=="boolean"){const merged=engine.merge(existing,branchProp);mergedProps[key]=merged??branchProp}else{mergedProps[key]=branchProp}}resolved.properties=mergedProps}if((0,_utils.isPlainObj)(branchSchema.dependencies)){const resolvedDeps=resolved.dependencies??{};const branchDeps=branchSchema.dependencies;const acc={...resolvedDeps};for(const depKey of Object.keys(branchDeps)){const branchVal=branchDeps[depKey];if(branchVal===undefined)continue;const existingVal=acc[depKey];if(existingVal===undefined){acc[depKey]=branchVal}else if(Array.isArray(existingVal)&&Array.isArray(branchVal)){acc[depKey]=(0,_utils.unionStrings)(existingVal,branchVal)}else if((0,_utils.isPlainObj)(existingVal)&&(0,_utils.isPlainObj)(branchVal)){const merged=engine.merge(existingVal,branchVal);acc[depKey]=merged??branchVal}else{acc[depKey]=branchVal}}resolved.dependencies=acc}for(const key of Object.keys(branchSchema)){if(SPECIAL_MERGE_KEYS.has(key))return;const branchVal=branchSchema[key];const resolvedVal=resolved[key];if(resolvedVal===undefined){resolved[key]=branchVal;return}if((0,_utils.deepEqual)(resolvedVal,branchVal))return;if(SUB_SCHEMA_KEYS.has(key)){const merged=engine.merge(resolvedVal,branchVal);if(merged!==null){resolved[key]=merged}else{resolved[key]=branchVal}return}if(MIN_KEYS.has(key)){if(typeof resolvedVal==="number"&&typeof branchVal==="number"){resolved[key]=Math.max(resolvedVal,branchVal)}else{resolved[key]=branchVal}return}if(MAX_KEYS.has(key)){if(typeof resolvedVal==="number"&&typeof branchVal==="number"){resolved[key]=Math.min(resolvedVal,branchVal)}else{resolved[key]=branchVal}return}if(key==="uniqueItems"){resolved[key]=resolvedVal===true||branchVal===true;return}if(key==="pattern"||key==="format"){resolved[key]=branchVal;return}const base={[key]:resolvedVal};const branch={[key]:branchVal};const merged=engine.merge(base,branch);if(merged&&typeof merged!=="boolean"&&(0,_utils.hasOwn)(merged,key)){resolved[key]=merged[key]}else{resolved[key]=branchVal}}}function resolveConditions(schema,data,engine){let branch=null;const discriminant={};const hasTopLevelIf=schema.if!==undefined;const hasAllOfConditions=Array.isArray(schema.allOf)&&schema.allOf.some(e=>typeof e!=="boolean"&&(0,_utils.hasOwn)(e,"if"));if(!hasTopLevelIf&&!hasAllOfConditions){const resolved=resolveNestedProperties(schema,data,engine,discriminant);return{resolved,branch,discriminant}}let resolved={...schema};if(hasAllOfConditions){resolved=resolveAllOfConditions(resolved,data,engine,discriminant)}if(resolved.if!==undefined){const ifSchema=resolved.if;const matches=evaluateCondition(ifSchema,data);extractDiscriminants(ifSchema,data,discriminant);const applicableBranch=matches?resolved.then:resolved.else;branch=matches?"then":"else";if(applicableBranch){mergeBranchInto(resolved,applicableBranch,engine)}delete resolved.if;delete resolved.then;delete resolved.else}resolved=resolveNestedProperties(resolved,data,engine,discriminant);return{resolved,branch,discriminant}}function resolveAllOfConditions(resolved,data,engine,discriminant){if(!Array.isArray(resolved.allOf))return resolved;const remainingAllOf=[];for(const entry of resolved.allOf){if(typeof entry==="boolean"){remainingAllOf.push(entry);continue}const subSchema=entry;if(subSchema.if===undefined){remainingAllOf.push(entry);continue}const ifSchema=subSchema.if;const matches=evaluateCondition(ifSchema,data);extractDiscriminants(ifSchema,data,discriminant);const applicableBranch=matches?subSchema.then:subSchema.else;if(applicableBranch){mergeBranchInto(resolved,applicableBranch,engine)}const remaining=(0,_utils.omitKeys)(subSchema,["if","then","else"]);if(Object.keys(remaining).length>0){remainingAllOf.push(remaining)}}resolved={...resolved};if(remainingAllOf.length===0){delete resolved.allOf}else{resolved.allOf=remainingAllOf}return resolved}function resolveNestedProperties(resolved,data,engine,discriminant){if(!(0,_utils.isPlainObj)(resolved.properties))return resolved;const props=resolved.properties;const propKeys=Object.keys(props);let changed=false;const resolvedProps={};for(const key of propKeys){const propDef=props[key];if(propDef===undefined)continue;if(typeof propDef==="boolean"){resolvedProps[key]=propDef;continue}const propSchema=propDef;const hasConditions=propSchema.if!==undefined||Array.isArray(propSchema.allOf)&&propSchema.allOf.some(e=>typeof e!=="boolean"&&(0,_utils.hasOwn)(e,"if"));if(!hasConditions){resolvedProps[key]=propDef;continue}const nestedData=(0,_utils.isPlainObj)(data[key])?data[key]:{};const nested=resolveConditions(propSchema,nestedData,engine);for(const dk of Object.keys(nested.discriminant)){discriminant[`${key}.${dk}`]=nested.discriminant[dk]}resolvedProps[key]=nested.resolved;changed=true}return changed?{...resolved,properties:resolvedProps}:resolved}
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"resolveConditions",{enumerable:true,get:function(){return resolveConditions}});const _runtimevalidatorts=require("./runtime-validator.js");const _utilsts=require("./utils.js");const SPECIAL_MERGE_KEYS=new Set(["required","properties","dependencies"]);const SUB_SCHEMA_KEYS=new Set(["additionalProperties","items","contains","propertyNames","not"]);const MIN_KEYS=new Set(["minimum","exclusiveMinimum","minLength","minItems","minProperties"]);const MAX_KEYS=new Set(["maximum","exclusiveMaximum","maxLength","maxItems","maxProperties"]);function evaluateCondition(ifSchema,data){return(0,_runtimevalidatorts.isDataValidForSchema)(ifSchema,data)}const DISCRIMINANT_INDICATORS=["const","enum","minimum","maximum","exclusiveMinimum","exclusiveMaximum","pattern","minLength","maxLength","multipleOf","minItems","maxItems","format"];function extractDiscriminants(ifSchema,data,out){if(!(0,_utilsts.isPlainObj)(ifSchema.properties))return;const props=ifSchema.properties;for(const key of Object.keys(props)){const propDef=props[key];if(typeof propDef==="boolean")continue;const prop=propDef;const hasIndicator=DISCRIMINANT_INDICATORS.some(indicator=>(0,_utilsts.hasOwn)(prop,indicator));if(hasIndicator&&(0,_utilsts.hasOwn)(data,key)){out[key]=data[key]}}}function mergeBranchInto(resolved,branchDef,engine){if(typeof branchDef==="boolean")return;const branchSchema=branchDef;if(Array.isArray(branchSchema.required)){resolved.required=(0,_utilsts.unionStrings)(resolved.required??[],branchSchema.required)}if((0,_utilsts.isPlainObj)(branchSchema.properties)){const branchProps=branchSchema.properties;const mergedProps={...resolved.properties??{}};for(const key of Object.keys(branchProps)){const branchProp=branchProps[key];if(branchProp===undefined)continue;const existing=resolved.properties?.[key];if(existing!==undefined&&typeof existing!=="boolean"&&typeof branchProp!=="boolean"){const merged=engine.merge(existing,branchProp);mergedProps[key]=merged??branchProp}else{mergedProps[key]=branchProp}}resolved.properties=mergedProps}if((0,_utilsts.isPlainObj)(branchSchema.dependencies)){const resolvedDeps=resolved.dependencies??{};const branchDeps=branchSchema.dependencies;const acc={...resolvedDeps};for(const depKey of Object.keys(branchDeps)){const branchVal=branchDeps[depKey];if(branchVal===undefined)continue;const existingVal=acc[depKey];if(existingVal===undefined){acc[depKey]=branchVal}else if(Array.isArray(existingVal)&&Array.isArray(branchVal)){acc[depKey]=(0,_utilsts.unionStrings)(existingVal,branchVal)}else if((0,_utilsts.isPlainObj)(existingVal)&&(0,_utilsts.isPlainObj)(branchVal)){const merged=engine.merge(existingVal,branchVal);acc[depKey]=merged??branchVal}else{acc[depKey]=branchVal}}resolved.dependencies=acc}for(const key of Object.keys(branchSchema)){if(SPECIAL_MERGE_KEYS.has(key))continue;const branchVal=branchSchema[key];const resolvedVal=resolved[key];if(resolvedVal===undefined){resolved[key]=branchVal;continue}if((0,_utilsts.deepEqual)(resolvedVal,branchVal))continue;if(SUB_SCHEMA_KEYS.has(key)){const merged=engine.merge(resolvedVal,branchVal);if(merged!==null){resolved[key]=merged}else{resolved[key]=branchVal}continue}if(MIN_KEYS.has(key)){if(typeof resolvedVal==="number"&&typeof branchVal==="number"){resolved[key]=Math.max(resolvedVal,branchVal)}else{resolved[key]=branchVal}continue}if(MAX_KEYS.has(key)){if(typeof resolvedVal==="number"&&typeof branchVal==="number"){resolved[key]=Math.min(resolvedVal,branchVal)}else{resolved[key]=branchVal}continue}if(key==="uniqueItems"){resolved[key]=resolvedVal===true||branchVal===true;continue}if(key==="pattern"||key==="format"){resolved[key]=branchVal;continue}if(key==="constraints"){const merged=(0,_utilsts.mergeConstraints)(resolvedVal,branchVal);if(merged!==undefined){resolved[key]=merged}continue}const base={[key]:resolvedVal};const branch={[key]:branchVal};const merged=engine.merge(base,branch);if(merged&&typeof merged!=="boolean"&&(0,_utilsts.hasOwn)(merged,key)){resolved[key]=merged[key]}else{resolved[key]=branchVal}}}function resolveConditions(schema,data,engine){let branch=null;const discriminant={};const hasTopLevelIf=schema.if!==undefined;const hasAllOfConditions=Array.isArray(schema.allOf)&&schema.allOf.some(e=>typeof e!=="boolean"&&(0,_utilsts.hasOwn)(e,"if"));if(!hasTopLevelIf&&!hasAllOfConditions){const resolved=resolveNestedProperties(schema,data,engine,discriminant);return{resolved,branch,discriminant}}let resolved={...schema};if(hasAllOfConditions){resolved=resolveAllOfConditions(resolved,data,engine,discriminant)}if(resolved.if!==undefined){const ifSchema=resolved.if;const matches=evaluateCondition(ifSchema,data);extractDiscriminants(ifSchema,data,discriminant);const applicableBranch=matches?resolved.then:resolved.else;branch=matches?"then":"else";if(applicableBranch){mergeBranchInto(resolved,applicableBranch,engine)}delete resolved.if;delete resolved.then;delete resolved.else}resolved=resolveNestedProperties(resolved,data,engine,discriminant);return{resolved,branch,discriminant}}function resolveAllOfConditions(resolved,data,engine,discriminant){if(!Array.isArray(resolved.allOf))return resolved;const remainingAllOf=[];for(const entry of resolved.allOf){if(typeof entry==="boolean"){remainingAllOf.push(entry);continue}const subSchema=entry;if(subSchema.if===undefined){remainingAllOf.push(entry);continue}const ifSchema=subSchema.if;const matches=evaluateCondition(ifSchema,data);extractDiscriminants(ifSchema,data,discriminant);const applicableBranch=matches?subSchema.then:subSchema.else;if(applicableBranch){mergeBranchInto(resolved,applicableBranch,engine)}const remaining=(0,_utilsts.omitKeys)(subSchema,["if","then","else"]);if(Object.keys(remaining).length>0){remainingAllOf.push(remaining)}}resolved={...resolved};if(remainingAllOf.length===0){delete resolved.allOf}else{resolved.allOf=remainingAllOf}return resolved}function resolveNestedProperties(resolved,data,engine,discriminant){if(!(0,_utilsts.isPlainObj)(resolved.properties))return resolved;const props=resolved.properties;const propKeys=Object.keys(props);let changed=false;const resolvedProps={};for(const key of propKeys){const propDef=props[key];if(propDef===undefined)continue;if(typeof propDef==="boolean"){resolvedProps[key]=propDef;continue}const propSchema=propDef;const hasConditions=propSchema.if!==undefined||Array.isArray(propSchema.allOf)&&propSchema.allOf.some(e=>typeof e!=="boolean"&&(0,_utilsts.hasOwn)(e,"if"));if(!hasConditions){resolvedProps[key]=propDef;continue}const nestedData=(0,_utilsts.isPlainObj)(data[key])?data[key]:{};const nested=resolveConditions(propSchema,nestedData,engine);for(const dk of Object.keys(nested.discriminant)){discriminant[`${key}.${dk}`]=nested.discriminant[dk]}resolvedProps[key]=nested.resolved;changed=true}return changed?{...resolved,properties:resolvedProps}:resolved}
 //# sourceMappingURL=condition-resolver.js.map