json-schema-compatibility-checker 1.0.1 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-schema-compatibility-checker",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "license": "MIT",
   "description": "A tool to check compatibility between two JSON Schemas.",
   "author": {
@@ -23,7 +23,7 @@
     "README.md"
   ],
   "scripts": {
-    "postinstall": "lefthook install",
+    "prepare": "lefthook install",
     "build:bun": "bun build src/*.ts --outdir ./dist --production --minify --root src --sourcemap --splitting --target node --format esm --packages external --chunk-naming='chunk-[hash].js'",
     "build:tsc": "tsc --project tsconfig.build.json",
     "build": "bun --parallel build:bun build:tsc",

package/dist/chunk-2vpph7cy.js

@@ -1,5 +0,0 @@
-import{r as g}from"./chunk-g0pfcnm5.js";import{createComparator as E,createMerger as V,createShallowAllOfMerge as F}from"@x0k/json-schema-merge";import{createDeduplicator as j,createIntersector as M}from"@x0k/json-schema-merge/lib/array";import v from"lodash/get";import X from"lodash/has";import H from"lodash/isArray";import T from"lodash/isEqual";import w from"lodash/isPlainObject";import K from"lodash/keys";import L from"lodash/some";function u(z,B){if(typeof z==="boolean"||typeof B==="boolean")return!1;let J=X(z,"const"),Q=X(B,"const"),U=v(z,"const"),$=v(B,"const"),Y=v(z,"enum"),N=v(B,"enum");if(J&&Q)return!T(U,$);if(J&&H(N))return!N.some((Z)=>T(Z,U));if(Q&&H(Y))return!Y.some((Z)=>T(Z,$));return!1}var D=["items","additionalProperties","contains","propertyNames","not"],O=["properties","patternProperties"];function _(z,B){if(u(z,B))return!0;if(typeof z==="boolean"||typeof B==="boolean")return!1;if(L(D,(J)=>{let Q=v(z,J),U=v(B,J);return w(Q)&&w(U)&&_(Q,U)}))return!0;if(L(O,(J)=>{let Q=v(z,J),U=v(B,J);if(!w(Q)||!w(U))return!1;let $=Q,Y=U;return L(K($),(N)=>{let Z=$[N],W=Y[N];return Z!==void 0&&W!==void 0&&X(U,N)&&_(Z,W)})}))return!0;if(H(z.items)&&H(B.items)){let J=B.items;if(L(z.items,(Q,U)=>{let $=J[U];return $!==void 0&&U<J.length&&_(Q,$)}))return!0}return!1}function A(z,B){if(typeof z==="boolean"||typeof B==="boolean")return!1;let J=w(z.properties)?z.properties:void 0,Q=w(B.properties)?B.properties:void 0;if(!J&&!Q)return!1;let U=J?K(J):[],$=Q?K(Q):[],Y=H(z.required)?z.required:[],N=H(B.required)?B.required:[];if(z.additionalProperties===!1&&J&&Q){if(L(N,(W)=>!X(J,W)&&X(Q,W))&&U.length>0)return!0}if(w(z.additionalProperties)&&typeof z.additionalProperties!=="boolean"&&J&&Q){let Z=z.additionalProperties;if(X(Z,"type")){let W=Z.type;if(L(N,(x)=>{if(X(J,x))return!1;if(!X(Q,x))return!1;let R=Q[x];if(typeof R==="boolean")return!1;let G=R;if(!X(G,"type"))return!1;if(typeof W==="string"&&typeof G.type==="string")return W!==G.type&&!(W==="number"&&G.type==="integer")&&!(W==="integer"&&G.type==="number");return!1}))return!0}}if(B.additionalProperties===!1&&Q&&J){if(L(Y,(W)=>!X(Q,W)&&X(J,W))&&$.length>0)return!0}if(w(B.additionalProperties)&&typeof B.additionalProperties!=="boolean"&&Q&&J){let Z=B.additionalProperties;if(X(Z,"type")){let W=Z.type;if(L(Y,(x)=>{if(X(Q,x))return!1;if(!X(J,x))return!1;let R=J[x];if(typeof R==="boolean")return!1;let G=R;if(!X(G,"type"))return!1;if(typeof W==="string"&&typeof G.type==="string")return W!==G.type&&!(W==="number"&&G.type==="integer")&&!(W==="integer"&&G.type==="number");return!1}))return!0}}if(J&&Q){if(L(U,(Z)=>{if(!X(Q,Z))return!1;let W=J[Z],I=Q[Z];if(typeof W==="boolean"||typeof I==="boolean")return!1;return A(W,I)}))return!0}return!1}function q(z,B){if(typeof z==="boolean"||typeof B==="boolean")return!1;if(X(z,"format")&&X(B,"format")){let J=z.format,Q=B.format;if(J!==Q){if(g(J,Q)!==!0){if(g(Q,J)!==!0)return!0}}}if(w(z.properties)&&w(B.properties)){let J=z.properties,Q=B.properties;if(L(K(J),(U)=>{let $=J[U],Y=Q[U];return $!==void 0&&Y!==void 0&&X(Q,U)&&q($,Y)}))return!0}if(w(z.items)&&w(B.items)){if(q(z.items,B.items))return!0}if(w(z.additionalProperties)&&w(B.additionalProperties)){if(q(z.additionalProperties,B.additionalProperties))return!0}return!1}class S{compareFn;shallowAllOfMergeFn;constructor(){let{compareSchemaDefinitions:z,compareSchemaValues:B}=E(),J=(U,$)=>{if(U===null&&$===null)return 0;return B(U,$)},{mergeArrayOfSchemaDefinitions:Q}=V({intersectJson:M(J),deduplicateJsonSchemaDef:j(z)});this.compareFn=z,this.shallowAllOfMergeFn=F(Q)}merge(z,B){if(_(z,B))return null;if(q(z,B))return null;if(A(z,B))return null;try{return this.shallowAllOfMergeFn({allOf:[z,B]})}catch{return null}}mergeOrThrow(z,B){if(_(z,B))throw Error("Incompatible const values: schemas have conflicting const constraints");if(q(z,B))throw Error("Incompatible format values: schemas have conflicting format constraints");if(A(z,B))throw Error("Incompatible additionalProperties: required properties conflict with additionalProperties constraint");return this.shallowAllOfMergeFn({allOf:[z,B]})}compare(z,B){return this.compareFn(z,B)}isEqual(z,B){return this.compareFn(z,B)===0}}
-export{S as m};
-
-//# debugId=43562DCBF631899F64756E2164756E21
-//# sourceMappingURL=chunk-2vpph7cy.js.map

package/dist/chunk-2vpph7cy.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/merge-engine.ts"],
-  "sourcesContent": [
-    "import {\n\tcreateComparator,\n\tcreateMerger,\n\tcreateShallowAllOfMerge,\n} from \"@x0k/json-schema-merge\";\nimport {\n\tcreateDeduplicator,\n\tcreateIntersector,\n} from \"@x0k/json-schema-merge/lib/array\";\n\nimport type {\n\tJSONSchema7,\n\tJSONSchema7Definition,\n\tJSONSchema7Type,\n} from \"json-schema\";\nimport get from \"lodash/get\";\nimport has from \"lodash/has\";\nimport isArray from \"lodash/isArray\";\nimport isEqual from \"lodash/isEqual\";\nimport isPlainObject from \"lodash/isPlainObject\";\nimport keys from \"lodash/keys\";\nimport some from \"lodash/some\";\n\nimport { isFormatSubset } from \"./format-validator\";\n\n// ─── Merge Engine ────────────────────────────────────────────────────────────\n//\n// Encapsule la librairie `@x0k/json-schema-merge` et expose une API simple\n// pour merger et comparer des JSON Schemas.\n//\n// Principe mathématique :\n//   A ∩ B  =  allOf([A, B])  résolu via shallow merge\n//   A ≡ B  ⟺  compare(A, B) === 0\n//\n// Pré-checks avant merge :\n//   - `hasDeepConstConflict` : détecte les conflits de `const`/`enum`\n//   - `hasAdditionalPropertiesConflict` : détecte les conflits `additionalProperties`\n//   - `hasFormatConflict` : détecte les conflits de `format` entre deux schemas\n\n// ─── Const conflict detection ────────────────────────────────────────────────\n\n/**\n * Détecte un conflit de `const` entre deux schemas.\n *\n * Cas 1 — const vs const : les deux schemas ont un `const` avec des valeurs\n *   différentes → intersection vide.\n *\n * Cas 2 — const vs enum : un schema a `const`, l'autre a `enum`.\n *   Si la valeur de `const` n'est pas dans l'`enum` → intersection vide.\n *\n * Utilise `lodash/isEqual` pour la comparaison profonde (objets, tableaux).\n */\nfunction hasConstConflict(\n\ta: JSONSchema7Definition,\n\tb: JSONSchema7Definition,\n): boolean {\n\tif (typeof a === \"boolean\" || typeof b === \"boolean\") return false;\n\n\tconst aHasConst = has(a, \"const\");\n\tconst bHasConst = has(b, \"const\");\n\tconst aConst = get(a, \"const\");\n\tconst bConst = get(b, \"const\");\n\tconst aEnum: unknown[] | undefined = get(a, \"enum\");\n\tconst bEnum: unknown[] | undefined = get(b, \"enum\");\n\n\t// Cas 1 — const vs const\n\tif (aHasConst && bHasConst) {\n\t\treturn !isEqual(aConst, bConst);\n\t}\n\n\t// Cas 2 — const vs enum\n\tif (aHasConst && isArray(bEnum)) {\n\t\treturn !bEnum.some((v) => isEqual(v, aConst));\n\t}\n\tif (bHasConst && isArray(aEnum)) {\n\t\treturn !aEnum.some((v) => isEqual(v, bConst));\n\t}\n\n\treturn false;\n}\n\n/** Mots-clés contenant un unique sous-schema à vérifier récursivement */\nconst SINGLE_SCHEMA_CONFLICT_KEYS = [\n\t\"items\",\n\t\"additionalProperties\",\n\t\"contains\",\n\t\"propertyNames\",\n\t\"not\",\n] as const;\n\n/** Mots-clés contenant un Record<string, JSONSchema7Definition> */\nconst PROPERTIES_MAP_CONFLICT_KEYS = [\n\t\"properties\",\n\t\"patternProperties\",\n] as const;\n\n/**\n * Détecte récursivement les conflits de `const` dans les sous-schemas.\n *\n * Quand la librairie de merge fait un shallow merge, les sous-schemas\n * imbriqués peuvent aussi avoir des conflits de `const` masqués\n * (elle utilise `identity` pour `const`).\n *\n * Récurse dans :\n *   - `properties`, `patternProperties` (clés communes)\n *   - `items` (single schema), tuple `items` (par index)\n *   - `additionalProperties`, `contains`, `propertyNames`, `not`\n */\nfunction hasDeepConstConflict(\n\ta: JSONSchema7Definition,\n\tb: JSONSchema7Definition,\n): boolean {\n\tif (hasConstConflict(a, b)) return true;\n\n\tif (typeof a === \"boolean\" || typeof b === \"boolean\") return false;\n\n\t// ── Single sub-schema keywords ──\n\tif (\n\t\tsome(SINGLE_SCHEMA_CONFLICT_KEYS, (key) => {\n\t\t\tconst aVal = get(a, key) as JSONSchema7Definition | undefined;\n\t\t\tconst bVal = get(b, key) as JSONSchema7Definition | undefined;\n\t\t\treturn (\n\t\t\t\tisPlainObject(aVal) &&\n\t\t\t\tisPlainObject(bVal) &&\n\t\t\t\thasDeepConstConflict(\n\t\t\t\t\taVal as JSONSchema7Definition,\n\t\t\t\t\tbVal as JSONSchema7Definition,\n\t\t\t\t)\n\t\t\t);\n\t\t})\n\t)\n\t\treturn true;\n\n\t// ── Properties-like maps (properties, patternProperties) ──\n\tif (\n\t\tsome(PROPERTIES_MAP_CONFLICT_KEYS, (key) => {\n\t\t\tconst aMap = get(a, key) as\n\t\t\t\t| Record<string, JSONSchema7Definition>\n\t\t\t\t| undefined;\n\t\t\tconst bMap = get(b, key) as\n\t\t\t\t| Record<string, JSONSchema7Definition>\n\t\t\t\t| undefined;\n\t\t\tif (!isPlainObject(aMap) || !isPlainObject(bMap)) return false;\n\t\t\tconst aMapSafe = aMap as Record<string, JSONSchema7Definition>;\n\t\t\tconst bMapSafe = bMap as Record<string, JSONSchema7Definition>;\n\t\t\treturn some(keys(aMapSafe), (propKey) => {\n\t\t\t\tconst aVal = aMapSafe[propKey];\n\t\t\t\tconst bVal = bMapSafe[propKey];\n\t\t\t\treturn (\n\t\t\t\t\taVal !== undefined &&\n\t\t\t\t\tbVal !== undefined &&\n\t\t\t\t\thas(bMap, propKey) &&\n\t\t\t\t\thasDeepConstConflict(aVal, bVal)\n\t\t\t\t);\n\t\t\t});\n\t\t})\n\t)\n\t\treturn true;\n\n\t// ── Tuple items (array of schemas, compared by index) ──\n\tif (isArray(a.items) && isArray(b.items)) {\n\t\tconst bItems = b.items as JSONSchema7Definition[];\n\t\tif (\n\t\t\tsome(a.items as JSONSchema7Definition[], (aItem, idx) => {\n\t\t\t\tconst bItem = bItems[idx];\n\t\t\t\treturn (\n\t\t\t\t\tbItem !== undefined &&\n\t\t\t\t\tidx < bItems.length &&\n\t\t\t\t\thasDeepConstConflict(aItem, bItem)\n\t\t\t\t);\n\t\t\t})\n\t\t)\n\t\t\treturn true;\n\t}\n\n\treturn false;\n}\n\n// ─── additionalProperties conflict detection ─────────────────────────────────\n\n/**\n * Détecte un conflit entre `additionalProperties` et les propriétés extra\n * **requises** de l'autre schema.\n *\n * ⚠️  Cette fonction est **ultra-conservatrice** : elle ne détecte que les\n * conflits où une propriété est à la fois :\n *   - INTERDITE par `additionalProperties: false` d'un côté\n *   - REQUISE (`required`) par l'autre côté\n *   - ABSENTE des `properties` du côté restrictif\n *   - ET le côté restrictif AUSSI a un `required` qui rend l'objet non-vide\n *     (sinon la librairie gère déjà le cas en excluant les propriétés extra)\n *\n * La librairie de merge (`@x0k/json-schema-merge`) gère DÉJÀ correctement\n * le cas `additionalProperties: false` avec des propriétés simplement DÉFINIES\n * (non requises) dans l'autre schema — elle les exclut du résultat.\n * On ne détecte donc QUE les contradictions `required` impossibles à résoudre.\n *\n * Cas gérés :\n *   1. `a` a `additionalProperties: false` et `b` REQUIERT des propriétés\n *      absentes de `a.properties`, ET ces propriétés sont dans `b.properties`\n *      → conflit certain (intersection vide car b exige, a interdit)\n *   2. Symétrique pour `b.additionalProperties: false`\n *   3. `additionalProperties` comme schema → vérifier la compatibilité de type\n *      des propriétés extra REQUISES uniquement\n *   4. Récursion dans les propriétés communes (sous-objets)\n *\n * ⚠️  Ne vérifie que les clés de `properties`, pas les `patternProperties`\n * (trop complexe à résoudre statiquement).\n *\n * Retourne `true` si un conflit évident est détecté, `false` sinon.\n * En cas de doute → `false` (conservateur, laisser le merge décider).\n *\n * Utilise `_.keys`, `_.some`, `_.every`, `_.has`, `_.get`, `_.isPlainObject`,\n * `_.includes` pour des vérifications concises.\n */\nfunction hasAdditionalPropertiesConflict(\n\ta: JSONSchema7Definition,\n\tb: JSONSchema7Definition,\n): boolean {\n\tif (typeof a === \"boolean\" || typeof b === \"boolean\") return false;\n\n\tconst aProps = isPlainObject(a.properties)\n\t\t? (a.properties as Record<string, JSONSchema7Definition>)\n\t\t: undefined;\n\tconst bProps = isPlainObject(b.properties)\n\t\t? (b.properties as Record<string, JSONSchema7Definition>)\n\t\t: undefined;\n\n\t// Si aucun des deux n'a de properties, on ne peut rien déterminer\n\tif (!aProps && !bProps) return false;\n\n\tconst aKeys = aProps ? keys(aProps) : [];\n\tconst bKeys = bProps ? keys(bProps) : [];\n\tconst aRequired = isArray(a.required) ? (a.required as string[]) : [];\n\tconst bRequired = isArray(b.required) ? (b.required as string[]) : [];\n\n\t// ── Vérifier additionalProperties: false de a vs propriétés REQUISES extra de b ──\n\t// Condition stricte : b doit DÉFINIR la propriété dans b.properties ET la\n\t// REQUÉRIR dans b.required, ET cette propriété doit être ABSENTE de a.properties.\n\t// De plus, a doit lui-même avoir des propriétés (sinon on ne peut rien dire).\n\tif (a.additionalProperties === false && aProps && bProps) {\n\t\tconst hasRequiredExtra = some(\n\t\t\tbRequired,\n\t\t\t(k) => !has(aProps, k) && has(bProps, k),\n\t\t);\n\t\t// Ne détecter le conflit que si a a aussi un required qui rend l'objet\n\t\t// structurellement contraint (pas un schema vague)\n\t\tif (hasRequiredExtra && aKeys.length > 0) return true;\n\t}\n\n\t// ── Vérification du cas additionalProperties comme schema ──\n\t// Si a.additionalProperties est un schema avec un type, et que b REQUIERT\n\t// une propriété extra dont le type est incompatible → conflit\n\tif (\n\t\tisPlainObject(a.additionalProperties) &&\n\t\ttypeof a.additionalProperties !== \"boolean\" &&\n\t\taProps &&\n\t\tbProps\n\t) {\n\t\tconst addPropsSchema = a.additionalProperties as JSONSchema7;\n\t\tif (has(addPropsSchema, \"type\")) {\n\t\t\tconst addPropsType = addPropsSchema.type;\n\t\t\tconst hasTypeConflict = some(bRequired, (k) => {\n\t\t\t\tif (has(aProps, k)) return false;\n\t\t\t\tif (!has(bProps, k)) return false;\n\t\t\t\tconst bPropDef = bProps[k];\n\t\t\t\tif (typeof bPropDef === \"boolean\") return false;\n\t\t\t\tconst bProp = bPropDef as JSONSchema7;\n\t\t\t\tif (!has(bProp, \"type\")) return false;\n\t\t\t\tif (\n\t\t\t\t\ttypeof addPropsType === \"string\" &&\n\t\t\t\t\ttypeof bProp.type === \"string\"\n\t\t\t\t) {\n\t\t\t\t\treturn (\n\t\t\t\t\t\taddPropsType !== bProp.type &&\n\t\t\t\t\t\t!(addPropsType === \"number\" && bProp.type === \"integer\") &&\n\t\t\t\t\t\t!(addPropsType === \"integer\" && bProp.type === \"number\")\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t\treturn false;\n\t\t\t});\n\t\t\tif (hasTypeConflict) return true;\n\t\t}\n\t}\n\n\t// ── Vérification symétrique : additionalProperties de b vs propriétés REQUISES extra de a ──\n\tif (b.additionalProperties === false && bProps && aProps) {\n\t\tconst hasRequiredExtra = some(\n\t\t\taRequired,\n\t\t\t(k) => !has(bProps, k) && has(aProps, k),\n\t\t);\n\t\tif (hasRequiredExtra && bKeys.length > 0) return true;\n\t}\n\n\t// Symétrique pour additionalProperties comme schema\n\tif (\n\t\tisPlainObject(b.additionalProperties) &&\n\t\ttypeof b.additionalProperties !== \"boolean\" &&\n\t\tbProps &&\n\t\taProps\n\t) {\n\t\tconst addPropsSchema = b.additionalProperties as JSONSchema7;\n\t\tif (has(addPropsSchema, \"type\")) {\n\t\t\tconst addPropsType = addPropsSchema.type;\n\t\t\tconst hasTypeConflict = some(aRequired, (k) => {\n\t\t\t\tif (has(bProps, k)) return false;\n\t\t\t\tif (!has(aProps, k)) return false;\n\t\t\t\tconst aPropDef = aProps[k];\n\t\t\t\tif (typeof aPropDef === \"boolean\") return false;\n\t\t\t\tconst aProp = aPropDef as JSONSchema7;\n\t\t\t\tif (!has(aProp, \"type\")) return false;\n\t\t\t\tif (\n\t\t\t\t\ttypeof addPropsType === \"string\" &&\n\t\t\t\t\ttypeof aProp.type === \"string\"\n\t\t\t\t) {\n\t\t\t\t\treturn (\n\t\t\t\t\t\taddPropsType !== aProp.type &&\n\t\t\t\t\t\t!(addPropsType === \"number\" && aProp.type === \"integer\") &&\n\t\t\t\t\t\t!(addPropsType === \"integer\" && aProp.type === \"number\")\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t\treturn false;\n\t\t\t});\n\t\t\tif (hasTypeConflict) return true;\n\t\t}\n\t}\n\n\t// ── Récursion dans les propriétés communes ──\n\t// Si les deux schemas ont des propriétés communes qui sont des objets,\n\t// vérifier récursivement les conflits additionalProperties\n\tif (aProps && bProps) {\n\t\tif (\n\t\t\tsome(aKeys, (k) => {\n\t\t\t\tif (!has(bProps, k)) return false;\n\t\t\t\tconst aPropDef = aProps[k];\n\t\t\t\tconst bPropDef = bProps[k];\n\t\t\t\tif (typeof aPropDef === \"boolean\" || typeof bPropDef === \"boolean\")\n\t\t\t\t\treturn false;\n\t\t\t\treturn hasAdditionalPropertiesConflict(\n\t\t\t\t\taPropDef as JSONSchema7Definition,\n\t\t\t\t\tbPropDef as JSONSchema7Definition,\n\t\t\t\t);\n\t\t\t})\n\t\t)\n\t\t\treturn true;\n\t}\n\n\treturn false;\n}\n\n// ─── Format conflict detection ───────────────────────────────────────────────\n\n/**\n * Détecte un conflit de format entre deux schemas.\n *\n * ⚠️  Ne se déclenche QUE quand les DEUX schemas ont un `format`.\n * Si un seul schema a un `format`, il n'y a PAS de conflit — le merge\n * engine gère nativement ce cas (le format est conservé dans l'intersection,\n * et la comparaison `merged ≡ sub` détermine correctement la relation ⊆).\n *\n * Deux schemas avec des formats différents et sans relation d'inclusion\n * connue ont une intersection vide (ex: \"email\" ∩ \"ipv4\" = ∅).\n *\n * Utilise `isFormatSubset` de `format-validator.ts` pour vérifier la hiérarchie.\n *\n * Récurse dans les sous-schemas (`properties`, `items`, etc.) pour détecter\n * les conflits de format imbriqués.\n *\n * @returns `true` si un conflit de format est détecté, `false` sinon\n */\nfunction hasFormatConflict(\n\ta: JSONSchema7Definition,\n\tb: JSONSchema7Definition,\n): boolean {\n\tif (typeof a === \"boolean\" || typeof b === \"boolean\") return false;\n\n\t// ── Seulement quand LES DEUX ont un format ──\n\t// Si un seul a un format → pas de conflit, le merge gère nativement\n\tif (has(a, \"format\") && has(b, \"format\")) {\n\t\tconst aFormat = a.format as string;\n\t\tconst bFormat = b.format as string;\n\n\t\t// Même format → pas de conflit\n\t\tif (aFormat !== bFormat) {\n\t\t\t// Vérifier si l'un est un sous-ensemble de l'autre via la hiérarchie\n\t\t\tconst subsetCheck = isFormatSubset(aFormat, bFormat);\n\t\t\tif (subsetCheck !== true) {\n\t\t\t\tconst reverseCheck = isFormatSubset(bFormat, aFormat);\n\t\t\t\tif (reverseCheck !== true) {\n\t\t\t\t\t// Formats différents sans relation connue → conflit\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// ── Récursion dans les sous-schemas ──\n\t// Vérifier les conflits de format dans les propriétés communes\n\tif (isPlainObject(a.properties) && isPlainObject(b.properties)) {\n\t\tconst aMap = a.properties as Record<string, JSONSchema7Definition>;\n\t\tconst bMap = b.properties as Record<string, JSONSchema7Definition>;\n\t\tif (\n\t\t\tsome(keys(aMap), (k) => {\n\t\t\t\tconst aVal = aMap[k];\n\t\t\t\tconst bVal = bMap[k];\n\t\t\t\treturn (\n\t\t\t\t\taVal !== undefined &&\n\t\t\t\t\tbVal !== undefined &&\n\t\t\t\t\thas(bMap, k) &&\n\t\t\t\t\thasFormatConflict(aVal, bVal)\n\t\t\t\t);\n\t\t\t})\n\t\t)\n\t\t\treturn true;\n\t}\n\n\t// Vérifier items (single schema)\n\tif (isPlainObject(a.items) && isPlainObject(b.items)) {\n\t\tif (\n\t\t\thasFormatConflict(\n\t\t\t\ta.items as JSONSchema7Definition,\n\t\t\t\tb.items as JSONSchema7Definition,\n\t\t\t)\n\t\t)\n\t\t\treturn true;\n\t}\n\n\t// Vérifier additionalProperties\n\tif (\n\t\tisPlainObject(a.additionalProperties) &&\n\t\tisPlainObject(b.additionalProperties)\n\t) {\n\t\tif (\n\t\t\thasFormatConflict(\n\t\t\t\ta.additionalProperties as JSONSchema7Definition,\n\t\t\t\tb.additionalProperties as JSONSchema7Definition,\n\t\t\t)\n\t\t)\n\t\t\treturn true;\n\t}\n\n\treturn false;\n}\n\n// ─── MergeEngine class ───────────────────────────────────────────────────────\n\nexport class MergeEngine {\n\tprivate readonly compareFn: (\n\t\ta: JSONSchema7Definition,\n\t\tb: JSONSchema7Definition,\n\t) => number;\n\n\tprivate readonly shallowAllOfMergeFn: (\n\t\tschema: JSONSchema7 & { allOf: JSONSchema7Definition[] },\n\t) => JSONSchema7Definition;\n\n\tconstructor() {\n\t\tconst { compareSchemaDefinitions, compareSchemaValues } =\n\t\t\tcreateComparator();\n\n\t\t// ── Null-safe wrapper for compareSchemaValues ──\n\t\t// The library's compareSchemaValues has a bug: when both a and b are null,\n\t\t// it returns -1 instead of 0 (the null check for `a` fires before checking\n\t\t// if `b` is also null). This causes createIntersector to lose null values\n\t\t// during enum intersection (the sort-merge join relies on compare(x,x)===0).\n\t\tconst safeCompareSchemaValues = (\n\t\t\ta: JSONSchema7Type,\n\t\t\tb: JSONSchema7Type,\n\t\t): number => {\n\t\t\tif (a === null && b === null) return 0;\n\t\t\treturn compareSchemaValues(a, b);\n\t\t};\n\n\t\tconst { mergeArrayOfSchemaDefinitions } = createMerger({\n\t\t\tintersectJson: createIntersector(safeCompareSchemaValues),\n\t\t\tdeduplicateJsonSchemaDef: createDeduplicator(compareSchemaDefinitions),\n\t\t});\n\n\t\tthis.compareFn = compareSchemaDefinitions;\n\t\tthis.shallowAllOfMergeFn = createShallowAllOfMerge(\n\t\t\tmergeArrayOfSchemaDefinitions,\n\t\t);\n\t}\n\n\t/**\n\t * Merge deux schemas via `allOf([a, b])`.\n\t * Retourne `null` si les schemas sont incompatibles.\n\t *\n\t * Post-merge : détecte les conflits de `const` que la librairie\n\t * ne capture pas (elle utilise `identity` pour `const`).\n\t */\n\tmerge(\n\t\ta: JSONSchema7Definition,\n\t\tb: JSONSchema7Definition,\n\t): JSONSchema7Definition | null {\n\t\t// Pré-check : conflit de const détectable avant le merge\n\t\tif (hasDeepConstConflict(a, b)) {\n\t\t\treturn null;\n\t\t}\n\n\t\t// Pré-check : conflit de format (les DEUX ont un format incompatible)\n\t\tif (hasFormatConflict(a, b)) {\n\t\t\treturn null;\n\t\t}\n\n\t\t// Pré-check : conflit additionalProperties vs propriétés REQUISES extra\n\t\t// Ne détecte que les cas où une propriété est à la fois interdite\n\t\t// (additionalProperties: false) et requise (required) → intersection vide.\n\t\t// Les cas où les propriétés sont simplement définies sans être requises\n\t\t// sont gérés correctement par la librairie de merge elle-même.\n\t\tif (hasAdditionalPropertiesConflict(a, b)) {\n\t\t\treturn null;\n\t\t}\n\n\t\ttry {\n\t\t\treturn this.shallowAllOfMergeFn({ allOf: [a, b] });\n\t\t} catch {\n\t\t\treturn null;\n\t\t}\n\t}\n\n\t/**\n\t * Merge via `shallowAllOfMerge` — lève une exception si incompatible.\n\t * Utile quand on veut capturer l'erreur pour le diagnostic.\n\t *\n\t * Post-merge : détecte les conflits de `const` et lève une exception.\n\t */\n\tmergeOrThrow(\n\t\ta: JSONSchema7Definition,\n\t\tb: JSONSchema7Definition,\n\t): JSONSchema7Definition {\n\t\t// Pré-check : conflit de const\n\t\tif (hasDeepConstConflict(a, b)) {\n\t\t\tthrow new Error(\n\t\t\t\t\"Incompatible const values: schemas have conflicting const constraints\",\n\t\t\t);\n\t\t}\n\n\t\t// Pré-check : conflit de format\n\t\tif (hasFormatConflict(a, b)) {\n\t\t\tthrow new Error(\n\t\t\t\t\"Incompatible format values: schemas have conflicting format constraints\",\n\t\t\t);\n\t\t}\n\n\t\t// Pré-check : conflit additionalProperties vs propriétés REQUISES extra\n\t\tif (hasAdditionalPropertiesConflict(a, b)) {\n\t\t\tthrow new Error(\n\t\t\t\t\"Incompatible additionalProperties: required properties conflict with additionalProperties constraint\",\n\t\t\t);\n\t\t}\n\n\t\treturn this.shallowAllOfMergeFn({ allOf: [a, b] });\n\t}\n\n\t/**\n\t * Compare structurellement deux schema definitions.\n\t * Retourne 0 si elles sont identiques, sinon un entier non nul.\n\t */\n\tcompare(a: JSONSchema7Definition, b: JSONSchema7Definition): number {\n\t\treturn this.compareFn(a, b);\n\t}\n\n\t/**\n\t * Vérifie l'égalité structurelle entre deux schema definitions.\n\t */\n\tisEqual(a: JSONSchema7Definition, b: JSONSchema7Definition): boolean {\n\t\treturn this.compareFn(a, b) === 0;\n\t}\n}\n"
-  ],
-  "mappings": "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",
-  "debugId": "43562DCBF631899F64756E2164756E21",
-  "names": []
-}

package/dist/chunk-cspd2zw4.js

@@ -1,6 +0,0 @@
-import z from"lodash/isEmpty";import A from"lodash/map";function B(j){switch(j.type){case"added":return`  + ${j.path}: ${JSON.stringify(j.actual)}`;case"removed":return`  - ${j.path}: was ${JSON.stringify(j.expected)}`;default:return`  ~ ${j.path}: ${JSON.stringify(j.expected)} → ${JSON.stringify(j.actual)}`}}function H(j,k){let v=[`${k.isSubset?"✅":"❌"} ${j}: ${k.isSubset}`];if(!k.isSubset&&!z(k.diffs)){v.push("   Diffs:");let w=A(k.diffs,(x)=>`     ${B(x)}`);v.push(...w)}return v.join(`
-`)}
-export{H as l};
-
-//# debugId=C49CD60F9FB46AC664756E2164756E21
-//# sourceMappingURL=chunk-cspd2zw4.js.map

package/dist/chunk-cspd2zw4.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/formatter.ts"],
-  "sourcesContent": [
-    "import isEmpty from \"lodash/isEmpty\";\nimport map from \"lodash/map\";\nimport type { SubsetResult } from \"./types\";\n\n// ─── Result Formatter ────────────────────────────────────────────────────────\n//\n// Formate un `SubsetResult` en chaîne lisible pour logs / debug.\n//\n// Utilise lodash :\n//   - `_.map`     pour transformer les diffs en lignes formatées\n//   - `_.isEmpty` pour vérifier la présence de diffs\n\n/**\n * Formate un diff individuel en ligne lisible avec préfixe iconique.\n *\n * @param d  Le diff à formater\n * @returns  Ligne formatée avec +, - ou ~ selon le type\n */\nfunction formatDiffLine(d: {\n\ttype: string;\n\tpath: string;\n\texpected: unknown;\n\tactual: unknown;\n}): string {\n\tswitch (d.type) {\n\t\tcase \"added\":\n\t\t\treturn `  + ${d.path}: ${JSON.stringify(d.actual)}`;\n\t\tcase \"removed\":\n\t\t\treturn `  - ${d.path}: was ${JSON.stringify(d.expected)}`;\n\t\tdefault:\n\t\t\treturn `  ~ ${d.path}: ${JSON.stringify(d.expected)} → ${JSON.stringify(d.actual)}`;\n\t}\n}\n\n/**\n * Formate un SubsetResult en chaîne lisible (utile pour logs/debug).\n *\n * @param label   Label descriptif du check (ex: \"strict ⊆ loose\")\n * @param result  Le résultat du check à formater\n * @returns       Chaîne multi-lignes formatée avec icônes et diffs\n *\n * @example\n * ```\n * ✅ strict ⊆ loose: true\n * ```\n *\n * @example\n * ```\n * ❌ loose ⊆ strict: false\n *    Diffs:\n *      ~ required: [\"name\"] → [\"name\",\"age\"]\n *      + properties.age: {\"type\":\"number\"}\n * ```\n */\nexport function formatResult(label: string, result: SubsetResult): string {\n\tconst icon = result.isSubset ? \"✅\" : \"❌\";\n\tconst lines: string[] = [`${icon} ${label}: ${result.isSubset}`];\n\n\tif (!result.isSubset && !isEmpty(result.diffs)) {\n\t\tlines.push(\"   Diffs:\");\n\n\t\t// Utilise `_.map` pour transformer chaque diff en ligne formatée\n\t\tconst diffLines = map(result.diffs, (d) => `     ${formatDiffLine(d)}`);\n\t\tlines.push(...diffLines);\n\t}\n\n\treturn lines.join(\"\\n\");\n}\n"
-  ],
-  "mappings": "AAAA,8BACA,0BAiBA,SAAS,CAAc,CAAC,EAKb,CACV,OAAQ,EAAE,UACJ,QACJ,MAAO,OAAO,EAAE,SAAS,KAAK,UAAU,EAAE,MAAM,QAC5C,UACJ,MAAO,OAAO,EAAE,aAAa,KAAK,UAAU,EAAE,QAAQ,YAEtD,MAAO,OAAO,EAAE,SAAS,KAAK,UAAU,EAAE,QAAQ,OAAM,KAAK,UAAU,EAAE,MAAM,KAwB3E,SAAS,CAAY,CAAC,EAAe,EAA8B,CAEzE,IAAM,EAAkB,CAAC,GADZ,EAAO,SAAW,IAAK,OACA,MAAU,EAAO,UAAU,EAE/D,GAAI,CAAC,EAAO,UAAY,CAAC,EAAQ,EAAO,KAAK,EAAG,CAC/C,EAAM,KAAK,WAAW,EAGtB,IAAM,EAAY,EAAI,EAAO,MAAO,CAAC,IAAM,QAAQ,EAAe,CAAC,GAAG,EACtE,EAAM,KAAK,GAAG,CAAS,EAGxB,OAAO,EAAM,KAAK;AAAA,CAAI",
-  "debugId": "C49CD60F9FB46AC664756E2164756E21",
-  "names": []
-}

package/dist/chunk-e4501gq7.js

@@ -1,5 +0,0 @@
-import{g as F}from"./chunk-vcwsxmk4.js";import{k as S}from"./chunk-v5tqyc67.js";import{r as v}from"./chunk-g0pfcnm5.js";import{t as A}from"./chunk-pw49kj6f.js";import z from"lodash/every";import B from"lodash/get";import Q from"lodash/has";import E from"lodash/includes";import K from"lodash/isArray";import g from"lodash/isEmpty";import w from"lodash/isEqual";import L from"lodash/isPlainObject";import T from"lodash/keys";import q from"lodash/omit";import I from"lodash/some";function m(x){if(typeof x==="boolean")return{branches:[x],type:"none"};if(Q(x,"anyOf")&&K(x.anyOf))return{branches:x.anyOf,type:"anyOf"};if(Q(x,"oneOf")&&K(x.oneOf))return{branches:x.oneOf,type:"oneOf"};return{branches:[x],type:"none"}}function M(x,X){if(typeof x==="boolean"||typeof X==="boolean")return null;if(Q(X,"not")&&L(X.not)){let G=X.not;if(L(G.properties)&&K(G.required)){let{properties:H,required:J}=G;if(L(x.properties)){let U=x.properties,W=K(x.required)?x.required:[],Y=T(H);if(I(Y,(Z)=>{let R=H[Z];if(typeof R==="boolean")return!1;let C=R;if(E(J,Z)&&!E(W,Z)&&!Q(U,Z))return!0;if(!Q(U,Z))return!1;let N=U[Z];if(typeof N==="boolean")return!1;let $=N;if(Q(C,"const")&&Q($,"const")){if(!w(C.const,$.const))return!0}if(Q(C,"enum")&&K(C.enum)){if(Q($,"const")){if(!I(C.enum,(O)=>w(O,$.const)))return!0}if(Q($,"enum")&&K($.enum)){if(z($.enum,(O)=>!I(C.enum,(d)=>w(O,d))))return!0}}return!1}))return!0;if(z(Y,(Z)=>{let R=H[Z];if(typeof R==="boolean")return!0;let C=R;if(E(J,Z)&&!E(W,Z))return!1;if(!Q(U,Z))return!1;let N=U[Z];if(typeof N==="boolean")return!0;let $=N;if(Q(C,"const")&&Q($,"const"))return w(C.const,$.const);if(Q(C,"enum")&&K(C.enum)){if(Q($,"const"))return I(C.enum,(j)=>w(j,$.const));if(Q($,"enum")&&K($.enum))return z($.enum,(j)=>I(C.enum,(O)=>w(j,O)))}return!1}))return!1}}if(Q(G,"const")&&Q(x,"const")){let H=B(G,"const"),J=B(x,"const");if(w(J,H))return!1;return!0}if(Q(G,"enum")&&K(G.enum)&&Q(x,"enum")&&K(x.enum)){if(z(x.enum,(J)=>!I(G.enum,(U)=>w(J,U))))return!0}if(Q(G,"type")&&Q(x,"type")){let H=B(G,"type"),J=B(x,"type");if(typeof H==="string"&&typeof J==="string"){if(!Q(G,"const")&&!Q(G,"enum")&&!L(G.properties)){if(J===H)return!1;return!0}}if(K(H)&&typeof J==="string"){if(E(H,J))return!1;return!0}}if(Q(G,"anyOf")&&K(G.anyOf)){let H=G.anyOf;if(z(H,(W)=>{if(typeof W==="boolean")return!W;return M(x,{not:W})===!0}))return!0;if(I(H,(W)=>{if(typeof W==="boolean")return W;return M(x,{not:W})===!1}))return!1}if(Q(G,"oneOf")&&K(G.oneOf)){let H=G.oneOf;if(z(H,(W)=>{if(typeof W==="boolean")return!W;return M(x,{not:W})===!0}))return!0;if(I(H,(W)=>{if(typeof W==="boolean")return W;return M(x,{not:W})===!1}))return!1}if(Q(G,"format")&&Q(x,"format")){let H=x.format,J=G.format;if(H===J)return!1;return!0}}if(Q(x,"not")&&Q(X,"not")){if(w(x.not,X.not))return!0}return null}function D(x,X,G=!0){if(typeof X==="boolean"||typeof x==="boolean")return X;let H=X;if(G&&Q(H,"not"))H=q(H,["not"]);if(L(H.properties)&&L(x.properties)){let J=x.properties,U=H.properties,W=!1,Y={...U};for(let _ of T(U)){let V=U[_],Z=J[_];if(Z!==void 0&&typeof V!=="boolean"&&typeof Z!=="boolean"&&Q(V,"not")){if(M(Z,V)===!0)Y[_]=q(V,["not"]),W=!0}}if(W)H={...H,properties:Y}}return H}function k(x,X){if(typeof x==="boolean"||typeof X==="boolean")return X;let G={...X};if(Q(G,"pattern")&&Q(x,"pattern")&&G.pattern!==x.pattern){if(F(x.pattern,G.pattern)===!0)G=q(G,["pattern"])}if(L(G.properties)&&L(x.properties)){let H=x.properties,J=G.properties,U=!1,W={...J};for(let Y of T(J)){let _=J[Y],V=H[Y];if(V!==void 0&&typeof _!=="boolean"&&typeof V!=="boolean"&&Q(_,"pattern")&&Q(V,"pattern")&&_.pattern!==V.pattern){if(F(V.pattern,_.pattern)===!0)W[Y]=q(_,["pattern"]),U=!0}}if(U)G={...G,properties:W}}if(L(G.items)&&typeof G.items!=="boolean"&&L(x.items)&&typeof x.items!=="boolean"){let H=x.items,J=G.items;if(Q(J,"pattern")&&Q(H,"pattern")&&J.pattern!==H.pattern){if(F(H.pattern,J.pattern)===!0)G={...G,items:q(J,["pattern"])}}}return G}function y(x,X,G){let{branches:H}=m(X);if(H.length===1&&H[0]===X){let J=M(x,X);if(J===!1)return!1;if(typeof x!=="boolean"&&typeof X!=="boolean"&&Q(x,"format")&&Q(X,"format")&&x.format!==X.format){if(v(x.format,X.format)!==!0)return!1}if(typeof x!=="boolean"&&typeof X!=="boolean"&&Q(x,"pattern")&&Q(X,"pattern")&&x.pattern!==X.pattern){if(F(x.pattern,X.pattern)===!1)return!1}let U=X;if(typeof X!=="boolean"){if(J===!0){if(U=D(x,X,!0),typeof U!=="boolean"&&g(T(U)))return!0}else U=D(x,X,!1);U=k(x,U)}let W=G.merge(x,U);return W!==null&&G.isEqual(A(W),x)}return I(H,(J)=>{let U=M(x,J);if(U===!1)return!1;if(typeof x!=="boolean"&&typeof J!=="boolean"&&Q(x,"pattern")&&Q(J,"pattern")&&x.pattern!==J.pattern){if(F(x.pattern,J.pattern)===!1)return!1}let W=J;if(typeof J!=="boolean"){if(U===!0){if(W=D(x,J,!0),typeof W!=="boolean"&&g(T(W)))return!0}else W=D(x,J,!1);W=k(x,W)}let Y=G.merge(x,W);return Y!==null&&G.isEqual(A(Y),x)})}function s(x,X,G,H="anyOf"){let J=[],U=!0,W=H==="none"?"anyOf":H;for(let Y=0;Y<x.length;Y++){let _=x[Y];if(_===void 0)continue;if(!y(_,X,G))U=!1,J.push({path:`${W}[${Y}]`,type:"changed",expected:_,actual:"Branch not accepted by superset"})}return{isSubset:U,merged:U?H==="oneOf"?{oneOf:x}:{anyOf:x}:null,diffs:J}}function xx(x,X,G,H="anyOf"){for(let U of X){let W=U;if(typeof x!=="boolean"&&typeof U!=="boolean")W=k(x,U);let Y=G.merge(x,W);if(Y!==null&&G.isEqual(A(Y),x))return{isSubset:!0,merged:Y,diffs:[]}}return{isSubset:!1,merged:null,diffs:[{path:"$",type:"changed",expected:x,actual:`No branch in superset's ${H==="none"?"anyOf":H} accepts this schema`}]}}function Gx(x,X,G){let H=X;if(typeof x!=="boolean"&&typeof X!=="boolean")H=k(x,X);try{let J=G.mergeOrThrow(x,H),U=A(J);if(G.compare(U,x)===0)return{isSubset:!0,merged:U,diffs:[]};let Y=S(x,U,"");return{isSubset:!1,merged:U,diffs:Y}}catch(J){return{isSubset:!1,merged:null,diffs:[{path:"$",type:"changed",expected:x,actual:`Incompatible: ${J instanceof Error?J.message:String(J)}`}]}}}
-export{m as b,y as c,s as d,xx as e,Gx as f};
-
-//# debugId=14C2312108595FF864756E2164756E21
-//# sourceMappingURL=chunk-e4501gq7.js.map

package/dist/chunk-e4501gq7.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/subset-checker.ts"],
-  "sourcesContent": [
-    "import type { JSONSchema7, JSONSchema7Definition } from \"json-schema\";\nimport every from \"lodash/every\";\nimport get from \"lodash/get\";\nimport has from \"lodash/has\";\nimport includes from \"lodash/includes\";\nimport isArray from \"lodash/isArray\";\nimport isEmpty from \"lodash/isEmpty\";\nimport isEqual from \"lodash/isEqual\";\nimport isPlainObject from \"lodash/isPlainObject\";\nimport keys from \"lodash/keys\";\nimport omit from \"lodash/omit\";\nimport some from \"lodash/some\";\nimport { computeDiffs } from \"./differ\";\nimport { isFormatSubset } from \"./format-validator\";\nimport type { MergeEngine } from \"./merge-engine\";\nimport { normalize } from \"./normalizer\";\nimport { isPatternSubset } from \"./pattern-subset\";\nimport type { SchemaDiff, SubsetResult } from \"./types\";\n\n// ─── Subset Checker ──────────────────────────────────────────────────────────\n//\n// Logique de vérification sub ⊆ sup via l'approche :\n//   A ⊆ B  ⟺  A ∩ B ≡ A\n//\n// Gère les cas :\n//   - Schemas atomiques (pas de anyOf/oneOf)\n//   - anyOf/oneOf dans sub → chaque branche doit être acceptée par sup\n//   - anyOf/oneOf dans sup → au moins une branche doit accepter sub\n//   - Point 6 : Distinction anyOf / oneOf dans les messages de diff\n//   - Point 7 : Raisonnement étendu sur `not` (evaluateNot)\n//     - not.type, not.const, not.enum (existants)\n//     - not avec properties+required (1.1)\n//     - not avec anyOf/oneOf (1.2)\n//     - not dans sub (1.3)\n//     - not.format (format-vs-format)\n//\n// Utilise lodash massivement :\n//   - `_.some` / `_.every`      pour les prédicats sur les branches\n//   - `_.has` / `_.get`         pour l'accès sûr aux propriétés\n//   - `_.isArray`               pour distinguer les types de branches\n//   - `_.isPlainObject`         pour vérifier les sous-schemas\n//   - `_.map` / `_.flatMap`     pour transformer les collections\n//   - `_.includes`              pour vérifier l'appartenance\n//   - `_.keys`                  pour extraire les clés d'un objet\n//   - `_.isEmpty`               pour vérifier les objets vides\n//   - `_.isEqual`               pour la comparaison profonde\n//   - `_.omit`                  pour retirer `not` avant le merge\n//   - `_.compact`               pour nettoyer les résultats\n\n// ─── Branch type ─────────────────────────────────────────────────────────────\n\n/**\n * Type de branchement détecté dans un schema.\n *\n * Point 6 — Distingue `anyOf` de `oneOf` pour produire des messages\n * de diff plus précis. `\"none\"` indique un schema atomique (pas de branches).\n *\n * Note : la sémantique d'exclusivité de `oneOf` n'est pas vérifiée\n * (ce serait un problème NP-hard en général). Le checker traite `oneOf`\n * comme `anyOf` pour le subset checking, ce qui est correct pour le cas\n * `sub ⊆ sup` mais peut produire des faux-positifs si les branches\n * du sub se chevauchent.\n */\nexport type BranchType = \"anyOf\" | \"oneOf\" | \"none\";\n\nexport interface BranchResult {\n\t/** Les branches extraites du schema */\n\tbranches: JSONSchema7Definition[];\n\t/** Le type de branchement détecté */\n\ttype: BranchType;\n}\n\n// ─── Branch extraction ───────────────────────────────────────────────────────\n\n/**\n * Extrait les branches d'un schema et le type de branchement.\n *\n * Retourne les éléments de `anyOf`/`oneOf` s'ils existent, sinon retourne\n * le schema lui-même dans un tableau avec type `\"none\"`.\n *\n * Point 6 — Distingue `anyOf` de `oneOf` dans les paths de diff.\n */\nexport function getBranchesTyped(def: JSONSchema7Definition): BranchResult {\n\tif (typeof def === \"boolean\") {\n\t\treturn { branches: [def], type: \"none\" };\n\t}\n\tif (has(def, \"anyOf\") && isArray(def.anyOf)) {\n\t\treturn { branches: def.anyOf, type: \"anyOf\" };\n\t}\n\tif (has(def, \"oneOf\") && isArray(def.oneOf)) {\n\t\treturn { branches: def.oneOf, type: \"oneOf\" };\n\t}\n\treturn { branches: [def], type: \"none\" };\n}\n\n// ─── `not` reasoning (Point 7 — étendu) ─────────────────────────────────────\n\n/**\n * Raisonnement étendu sur `not` pour les cas courants.\n *\n * Point 7 — Vérifie la compatibilité quand `sup` et/ou `sub` contiennent `not` :\n *\n * **Cas existants (not dans sup) :**\n *   - `not.type` : type exclu vs type de sub\n *   - `not.const` : const exclu vs const de sub\n *   - `not.enum` : valeurs exclues vs enum de sub\n *\n * **Cas ajoutés :**\n *   - 1.1 — `not` avec `properties` + `required` : vérifier que les propriétés\n *     de sub sont incompatibles avec celles du `not` (const/enum différents)\n *   - 1.2 — `not` avec `anyOf`/`oneOf` : `not(anyOf([A,B]))` ≡ `allOf([not(A), not(B)])`,\n *     donc sub doit être incompatible avec CHAQUE branche\n *   - 1.3 — `not` dans `sub` (pas seulement dans `sup`) : un sub avec `not`\n *     accepte un ensemble trop large pour être un sous-ensemble d'un sup concret\n *   - `not.format` : format-vs-format via `isFormatSubset`\n *\n * Contrat ternaire conservateur :\n *   - `true`  → compatible (certain)\n *   - `false` → incompatible (certain)\n *   - `null`  → indéterminé (laisser le merge engine décider)\n *\n * En cas de doute → `null`. Ne JAMAIS retourner `true` sans certitude.\n *\n * Utilise `_.has`, `_.get`, `_.isEqual`, `_.includes`, `_.every`, `_.some`,\n * `_.keys`, `_.isPlainObject`, `_.isArray` pour des vérifications concises.\n */\nfunction evaluateNot(\n\tsub: JSONSchema7Definition,\n\tsup: JSONSchema7Definition,\n): boolean | null {\n\tif (typeof sub === \"boolean\" || typeof sup === \"boolean\") return null;\n\n\t// ── 1.3 — `not` dans sub (pas dans sup) ──\n\t// Un `not` dans sub est une restriction supplémentaire : il exclut des\n\t// valeurs de l'ensemble accepté par sub, ce qui le rend potentiellement\n\t// plus petit — donc plus susceptible d'être ⊆ sup, pas moins.\n\t// On laisse le merge engine décider : allOf(sub, sup) préservera le `not`\n\t// de sub, et la comparaison merged ≡ sub donnera le bon résultat.\n\t// Exception : si les deux ont `not`, on traite l'identité plus bas.\n\n\t// Vérifier `not` dans sup\n\tif (has(sup, \"not\") && isPlainObject(sup.not)) {\n\t\tconst notSchema = sup.not as JSONSchema7;\n\n\t\t// ── 1.1 — Cas not avec properties + required ──\n\t\t// IMPORTANT : ce check est placé AVANT le check not.type car quand\n\t\t// le not a à la fois `type` et `properties`, le check not.type seul\n\t\t// produirait un faux négatif (ex: sub type=object et not type=object\n\t\t// retournerait false, mais les properties pourraient être incompatibles\n\t\t// ce qui rendrait sub compatible avec le not).\n\t\t// Si not contient des properties avec const/enum et required,\n\t\t// vérifier que les propriétés de sub sont incompatibles avec celles du not.\n\t\tif (isPlainObject(notSchema.properties) && isArray(notSchema.required)) {\n\t\t\tconst notProps = notSchema.properties as Record<\n\t\t\t\tstring,\n\t\t\t\tJSONSchema7Definition\n\t\t\t>;\n\t\t\tconst notRequired = notSchema.required as string[];\n\n\t\t\t// sub doit avoir des properties pour qu'on puisse comparer\n\t\t\tif (isPlainObject(sub.properties)) {\n\t\t\t\tconst subProps = sub.properties as Record<\n\t\t\t\t\tstring,\n\t\t\t\t\tJSONSchema7Definition\n\t\t\t\t>;\n\t\t\t\tconst subRequired = isArray(sub.required)\n\t\t\t\t\t? (sub.required as string[])\n\t\t\t\t\t: [];\n\t\t\t\tconst notPropKeys = keys(notProps);\n\n\t\t\t\t// Pour que sub soit compatible avec not(schema),\n\t\t\t\t// il suffit qu'au moins UNE propriété du not soit incompatible avec sub.\n\t\t\t\t// Cela signifie que sub ne peut jamais valider le schema inside not.\n\t\t\t\tconst hasIncompatibleProp = some(notPropKeys, (key) => {\n\t\t\t\t\tconst notPropDef = notProps[key];\n\t\t\t\t\tif (typeof notPropDef === \"boolean\") return false;\n\t\t\t\t\tconst notProp = notPropDef as JSONSchema7;\n\n\t\t\t\t\t// Si la propriété est required dans not mais PAS dans sub.required\n\t\t\t\t\t// et qu'elle n'existe pas dans sub.properties → sub peut ne pas\n\t\t\t\t\t// avoir cette propriété → le not schema ne matcherait pas → compatible\n\t\t\t\t\tif (\n\t\t\t\t\t\tincludes(notRequired, key) &&\n\t\t\t\t\t\t!includes(subRequired, key) &&\n\t\t\t\t\t\t!has(subProps, key)\n\t\t\t\t\t) {\n\t\t\t\t\t\treturn true; // Propriété absente de sub → not ne matche pas\n\t\t\t\t\t}\n\n\t\t\t\t\t// Comparer les const/enum de la propriété\n\t\t\t\t\tif (!has(subProps, key)) return false;\n\t\t\t\t\tconst subPropDef = subProps[key];\n\t\t\t\t\tif (typeof subPropDef === \"boolean\") return false;\n\t\t\t\t\tconst subProp = subPropDef as JSONSchema7;\n\n\t\t\t\t\t// not.prop a un const, sub.prop a un const différent → incompatible pour cette prop\n\t\t\t\t\tif (has(notProp, \"const\") && has(subProp, \"const\")) {\n\t\t\t\t\t\tif (!isEqual(notProp.const, subProp.const)) {\n\t\t\t\t\t\t\treturn true; // Consts différents → sub ne matche pas le not\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// not.prop a un enum, sub.prop a un const ou enum dont aucune valeur\n\t\t\t\t\t// n'est dans not.enum → incompatible pour cette prop\n\t\t\t\t\tif (has(notProp, \"enum\") && isArray(notProp.enum)) {\n\t\t\t\t\t\tif (has(subProp, \"const\")) {\n\t\t\t\t\t\t\tconst inNotEnum = some(notProp.enum, (v) =>\n\t\t\t\t\t\t\t\tisEqual(v, subProp.const),\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\tif (!inNotEnum) return true; // sub.const absent du not.enum\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (has(subProp, \"enum\") && isArray(subProp.enum)) {\n\t\t\t\t\t\t\tconst noneInNotEnum = every(\n\t\t\t\t\t\t\t\tsubProp.enum,\n\t\t\t\t\t\t\t\t(v) => !some(notProp.enum, (nv) => isEqual(v, nv)),\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\tif (noneInNotEnum) return true; // Aucune valeur de sub.enum dans not.enum\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\treturn false;\n\t\t\t\t});\n\n\t\t\t\tif (hasIncompatibleProp) return true;\n\n\t\t\t\t// Vérification inverse : si TOUTES les propriétés du not matchent sub\n\t\t\t\t// exactement (même const, sub a les required du not), alors sub VIOLE le not\n\t\t\t\tconst allPropsMatch = every(notPropKeys, (key) => {\n\t\t\t\t\tconst notPropDef = notProps[key];\n\t\t\t\t\tif (typeof notPropDef === \"boolean\") return true;\n\t\t\t\t\tconst notProp = notPropDef as JSONSchema7;\n\n\t\t\t\t\t// La propriété doit être dans sub.required si elle est dans not.required\n\t\t\t\t\tif (includes(notRequired, key) && !includes(subRequired, key))\n\t\t\t\t\t\treturn false;\n\t\t\t\t\tif (!has(subProps, key)) return false;\n\t\t\t\t\tconst subPropDef = subProps[key];\n\t\t\t\t\tif (typeof subPropDef === \"boolean\") return true;\n\t\t\t\t\tconst subProp = subPropDef as JSONSchema7;\n\n\t\t\t\t\t// Vérifier const match\n\t\t\t\t\tif (has(notProp, \"const\") && has(subProp, \"const\")) {\n\t\t\t\t\t\treturn isEqual(notProp.const, subProp.const);\n\t\t\t\t\t}\n\n\t\t\t\t\t// Vérifier enum inclusion\n\t\t\t\t\tif (has(notProp, \"enum\") && isArray(notProp.enum)) {\n\t\t\t\t\t\tif (has(subProp, \"const\")) {\n\t\t\t\t\t\t\treturn some(notProp.enum, (v) => isEqual(v, subProp.const));\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (has(subProp, \"enum\") && isArray(subProp.enum)) {\n\t\t\t\t\t\t\t// Toutes les valeurs de sub.enum sont dans not.enum\n\t\t\t\t\t\t\treturn every(subProp.enum, (v) =>\n\t\t\t\t\t\t\t\tsome(notProp.enum, (nv) => isEqual(v, nv)),\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\treturn false; // Indéterminé pour cette propriété\n\t\t\t\t});\n\n\t\t\t\tif (allPropsMatch) return false; // sub matche exactement le not → incompatible\n\t\t\t}\n\t\t}\n\n\t\t// ── Cas not.const ──\n\t\t// IMPORTANT : ce check est placé AVANT not.type car quand le not a\n\t\t// à la fois `type` et `const`, le check not.type seul produirait un\n\t\t// faux négatif (ex: sub type=string const=\"active\" et not type=string\n\t\t// const=\"deleted\" → le type check retournerait false car même type,\n\t\t// alors que les consts sont différents → compatible).\n\t\tif (has(notSchema, \"const\") && has(sub, \"const\")) {\n\t\t\tconst notConst = get(notSchema, \"const\");\n\t\t\tconst subConst = get(sub, \"const\");\n\t\t\tif (isEqual(subConst, notConst)) return false;\n\t\t\treturn true;\n\t\t}\n\n\t\t// ── Cas not.enum ──\n\t\t// Aussi placé AVANT not.type pour la même raison.\n\t\tif (\n\t\t\thas(notSchema, \"enum\") &&\n\t\t\tisArray(notSchema.enum) &&\n\t\t\thas(sub, \"enum\") &&\n\t\t\tisArray(sub.enum)\n\t\t) {\n\t\t\t// Toutes les valeurs de sub.enum doivent être absentes de not.enum\n\t\t\tconst allExcluded = every(\n\t\t\t\tsub.enum,\n\t\t\t\t(val) => !some(notSchema.enum, (notVal) => isEqual(val, notVal)),\n\t\t\t);\n\t\t\tif (allExcluded) return true;\n\t\t\t// Certaines valeurs de sub sont dans not.enum → pas automatiquement faux,\n\t\t\t// le merge engine peut encore gérer\n\t\t}\n\n\t\t// ── Cas not.type ──\n\t\t// Placé APRÈS not.const, not.enum et properties+required pour ne pas\n\t\t// court-circuiter les cas où le not a des contraintes plus spécifiques.\n\t\t// Le check type seul est un fallback pour les not schemas simples\n\t\t// (ex: { not: { type: \"string\" } }).\n\t\tif (has(notSchema, \"type\") && has(sub, \"type\")) {\n\t\t\tconst notType = get(notSchema, \"type\");\n\t\t\tconst subType = get(sub, \"type\");\n\n\t\t\t// Si les deux sont des strings simples\n\t\t\tif (typeof notType === \"string\" && typeof subType === \"string\") {\n\t\t\t\t// Ne retourner que si le not n'a PAS de contraintes plus spécifiques\n\t\t\t\t// (const, enum, properties) qui auraient dû être traitées plus haut\n\t\t\t\tif (\n\t\t\t\t\t!has(notSchema, \"const\") &&\n\t\t\t\t\t!has(notSchema, \"enum\") &&\n\t\t\t\t\t!isPlainObject(notSchema.properties)\n\t\t\t\t) {\n\t\t\t\t\tif (subType === notType) return false; // Incompatible : sub est exactement le type exclu\n\t\t\t\t\treturn true; // Compatible : sub est un type différent du type exclu\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Si notType est un tableau, sub.type doit ne pas être dedans\n\t\t\tif (isArray(notType) && typeof subType === \"string\") {\n\t\t\t\tif (includes(notType, subType)) return false;\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\t// ── 1.2 — Cas not avec anyOf / oneOf ──\n\t\t// not(anyOf([A, B])) ≡ allOf([not(A), not(B)])\n\t\t// Pour que sub ⊆ not(anyOf(...)), sub doit être incompatible avec CHAQUE branche.\n\t\tif (has(notSchema, \"anyOf\") && isArray(notSchema.anyOf)) {\n\t\t\tconst branches = notSchema.anyOf as JSONSchema7Definition[];\n\t\t\t// Pour chaque branche du not.anyOf, vérifier que sub est incompatible\n\t\t\tconst allIncompatible = every(branches, (branch) => {\n\t\t\t\tif (typeof branch === \"boolean\") return !branch; // not(true) = rien, not(false) = tout\n\t\t\t\t// Créer un sup virtuel { not: branch } et vérifier récursivement\n\t\t\t\tconst result = evaluateNot(sub, { not: branch });\n\t\t\t\t// result = true → sub est compatible avec not(branch) → sub ⊄ branch → OK\n\t\t\t\t// result = false → sub est incompatible avec not(branch) → sub ⊆ branch → pas OK\n\t\t\t\t// result = null → indéterminé\n\t\t\t\treturn result === true;\n\t\t\t});\n\t\t\tif (allIncompatible) return true;\n\n\t\t\t// Vérifier si au moins une branche accepte sub → incompatible avec not(anyOf)\n\t\t\tconst anyBranchMatches = some(branches, (branch) => {\n\t\t\t\tif (typeof branch === \"boolean\") return branch;\n\t\t\t\tconst result = evaluateNot(sub, { not: branch });\n\t\t\t\treturn result === false; // sub est incompatible avec not(branch) → sub ⊆ branch\n\t\t\t});\n\t\t\tif (anyBranchMatches) return false;\n\t\t}\n\n\t\t// Même logique pour oneOf (dans le contexte du not, traité comme anyOf)\n\t\tif (has(notSchema, \"oneOf\") && isArray(notSchema.oneOf)) {\n\t\t\tconst branches = notSchema.oneOf as JSONSchema7Definition[];\n\t\t\tconst allIncompatible = every(branches, (branch) => {\n\t\t\t\tif (typeof branch === \"boolean\") return !branch;\n\t\t\t\tconst result = evaluateNot(sub, { not: branch });\n\t\t\t\treturn result === true;\n\t\t\t});\n\t\t\tif (allIncompatible) return true;\n\n\t\t\tconst anyBranchMatches = some(branches, (branch) => {\n\t\t\t\tif (typeof branch === \"boolean\") return branch;\n\t\t\t\tconst result = evaluateNot(sub, { not: branch });\n\t\t\t\treturn result === false;\n\t\t\t});\n\t\t\tif (anyBranchMatches) return false;\n\t\t}\n\n\t\t// ── Cas not.format (format-vs-format uniquement) ──\n\t\t// Si not a un format et sub aussi, vérifier la compatibilité\n\t\tif (has(notSchema, \"format\") && has(sub, \"format\")) {\n\t\t\tconst subFormat = sub.format as string;\n\t\t\tconst notFormat = notSchema.format as string;\n\t\t\tif (subFormat === notFormat) return false; // Incompatible : sub a exactement le format exclu\n\t\t\t// Formats différents → compatible (approximation conservatrice)\n\t\t\treturn true;\n\t\t}\n\t}\n\n\t// Vérifier `not` dans sub ET dans sup (identité : { not: X } ⊆ { not: X })\n\tif (has(sub, \"not\") && has(sup, \"not\")) {\n\t\tif (isEqual(sub.not, sup.not)) return true;\n\t}\n\n\treturn null; // Pas d'avis → laisser le merge engine décider\n}\n\n// ─── Not stripping helper ────────────────────────────────────────────────────\n\n/**\n * Retire le mot-clé `not` d'un schema pour permettre un merge propre\n * quand `evaluateNot` a déjà confirmé la compatibilité.\n *\n * Gère aussi le `not` imbriqué dans les `properties` : si une propriété\n * de `sup` a un `not` qui est compatible avec la propriété correspondante\n * de `sub`, on le retire également.\n *\n * Retourne le schema nettoyé, ou `null` si le schema est vide après retrait.\n *\n * Utilise `_.omit`, `_.has`, `_.keys`, `_.isEmpty`, `_.isPlainObject`.\n */\nfunction stripNotFromSup(\n\tsub: JSONSchema7Definition,\n\tsup: JSONSchema7Definition,\n\tstripTopLevel: boolean = true,\n): JSONSchema7Definition {\n\tif (typeof sup === \"boolean\" || typeof sub === \"boolean\") return sup;\n\n\tlet result = sup as JSONSchema7;\n\n\t// ── Retirer le `not` de niveau supérieur (seulement si confirmé) ──\n\tif (stripTopLevel && has(result, \"not\")) {\n\t\tresult = omit(result, [\"not\"]) as JSONSchema7;\n\t}\n\n\t// ── Retirer les `not` dans les propriétés communes ──\n\t// Si sup.properties[key] a un `not` et que evaluateNot(sub.prop, sup.prop)\n\t// confirme la compatibilité, on retire le `not` de cette propriété aussi.\n\tif (\n\t\tisPlainObject(result.properties) &&\n\t\tisPlainObject((sub as JSONSchema7).properties)\n\t) {\n\t\tconst subProps = (sub as JSONSchema7).properties as Record<\n\t\t\tstring,\n\t\t\tJSONSchema7Definition\n\t\t>;\n\t\tconst supProps = result.properties as Record<string, JSONSchema7Definition>;\n\t\tlet propsModified = false;\n\t\tconst newProps: Record<string, JSONSchema7Definition> = { ...supProps };\n\n\t\tfor (const key of keys(supProps)) {\n\t\t\tconst supPropDef = supProps[key];\n\t\t\tconst subPropDef = subProps[key];\n\t\t\tif (\n\t\t\t\tsubPropDef !== undefined &&\n\t\t\t\ttypeof supPropDef !== \"boolean\" &&\n\t\t\t\ttypeof subPropDef !== \"boolean\" &&\n\t\t\t\thas(supPropDef, \"not\")\n\t\t\t) {\n\t\t\t\t// Vérifier la compatibilité du not au niveau de la propriété\n\t\t\t\tconst propNotResult = evaluateNot(subPropDef, supPropDef);\n\t\t\t\tif (propNotResult === true) {\n\t\t\t\t\tnewProps[key] = omit(supPropDef as JSONSchema7, [\n\t\t\t\t\t\t\"not\",\n\t\t\t\t\t]) as JSONSchema7Definition;\n\t\t\t\t\tpropsModified = true;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (propsModified) {\n\t\t\tresult = { ...result, properties: newProps };\n\t\t}\n\t}\n\n\treturn result;\n}\n\n// ─── Pattern stripping helper ────────────────────────────────────────────────\n\n/**\n * Retire le `pattern` de `sup` quand `isPatternSubset` a confirmé que\n * sub.pattern ⊆ sup.pattern par échantillonnage.\n *\n * Fonctionne comme `stripNotFromSup` : on retire la contrainte de sup\n * qui est déjà satisfaite par sub, pour éviter que le merge engine\n * produise un pattern combiné (lookahead conjunction) structurellement\n * différent du pattern de sub, ce qui causerait un faux négatif.\n *\n * Récurse dans les `properties` pour traiter les patterns imbriqués.\n *\n * @param sub  Le schema sub (utilisé pour extraire les patterns à comparer)\n * @param sup  Le schema sup dont on retire les patterns confirmés\n * @returns    Le schema sup nettoyé\n */\nfunction stripPatternFromSup(\n\tsub: JSONSchema7Definition,\n\tsup: JSONSchema7Definition,\n): JSONSchema7Definition {\n\tif (typeof sub === \"boolean\" || typeof sup === \"boolean\") return sup;\n\n\tlet result = { ...sup } as JSONSchema7;\n\n\t// ── Top-level pattern ──\n\tif (\n\t\thas(result, \"pattern\") &&\n\t\thas(sub, \"pattern\") &&\n\t\tresult.pattern !== sub.pattern\n\t) {\n\t\tconst patResult = isPatternSubset(\n\t\t\tsub.pattern as string,\n\t\t\tresult.pattern as string,\n\t\t);\n\t\tif (patResult === true) {\n\t\t\tresult = omit(result, [\"pattern\"]) as JSONSchema7;\n\t\t}\n\t}\n\n\t// ── Patterns dans les propriétés communes ──\n\tif (\n\t\tisPlainObject(result.properties) &&\n\t\tisPlainObject((sub as JSONSchema7).properties)\n\t) {\n\t\tconst subProps = (sub as JSONSchema7).properties as Record<\n\t\t\tstring,\n\t\t\tJSONSchema7Definition\n\t\t>;\n\t\tconst supProps = result.properties as Record<string, JSONSchema7Definition>;\n\t\tlet propsModified = false;\n\t\tconst newProps: Record<string, JSONSchema7Definition> = { ...supProps };\n\n\t\tfor (const key of keys(supProps)) {\n\t\t\tconst supPropDef = supProps[key];\n\t\t\tconst subPropDef = subProps[key];\n\t\t\tif (\n\t\t\t\tsubPropDef !== undefined &&\n\t\t\t\ttypeof supPropDef !== \"boolean\" &&\n\t\t\t\ttypeof subPropDef !== \"boolean\" &&\n\t\t\t\thas(supPropDef, \"pattern\") &&\n\t\t\t\thas(subPropDef, \"pattern\") &&\n\t\t\t\tsupPropDef.pattern !== subPropDef.pattern\n\t\t\t) {\n\t\t\t\tconst propPatResult = isPatternSubset(\n\t\t\t\t\t(subPropDef as JSONSchema7).pattern as string,\n\t\t\t\t\t(supPropDef as JSONSchema7).pattern as string,\n\t\t\t\t);\n\t\t\t\tif (propPatResult === true) {\n\t\t\t\t\tnewProps[key] = omit(supPropDef as JSONSchema7, [\n\t\t\t\t\t\t\"pattern\",\n\t\t\t\t\t]) as JSONSchema7Definition;\n\t\t\t\t\tpropsModified = true;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (propsModified) {\n\t\t\tresult = { ...result, properties: newProps };\n\t\t}\n\t}\n\n\t// ── Pattern dans items (single schema) ──\n\tif (\n\t\tisPlainObject(result.items) &&\n\t\ttypeof result.items !== \"boolean\" &&\n\t\tisPlainObject((sub as JSONSchema7).items) &&\n\t\ttypeof (sub as JSONSchema7).items !== \"boolean\"\n\t) {\n\t\tconst subItems = (sub as JSONSchema7).items as JSONSchema7;\n\t\tconst supItems = result.items as JSONSchema7;\n\t\tif (\n\t\t\thas(supItems, \"pattern\") &&\n\t\t\thas(subItems, \"pattern\") &&\n\t\t\tsupItems.pattern !== subItems.pattern\n\t\t) {\n\t\t\tconst itemsPatResult = isPatternSubset(\n\t\t\t\tsubItems.pattern as string,\n\t\t\t\tsupItems.pattern as string,\n\t\t\t);\n\t\t\tif (itemsPatResult === true) {\n\t\t\t\tresult = {\n\t\t\t\t\t...result,\n\t\t\t\t\titems: omit(supItems, [\"pattern\"]) as JSONSchema7Definition,\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\t}\n\n\treturn result;\n}\n\n// ─── Atomic subset check ─────────────────────────────────────────────────────\n\n/**\n * Vérifie si `sub ⊆ sup` pour deux schemas sans anyOf/oneOf (ou avec\n * anyOf/oneOf uniquement côté sup).\n *\n * Point 7 — Intègre un pré-check `not` étendu (`evaluateNot`) avant le merge.\n *\n * Quand `evaluateNot` confirme la compatibilité (`true`), on retire le `not`\n * de `sup` avant le merge pour éviter que le merge engine ajoute une contrainte\n * `not` que `sub` n'a pas (ce qui ferait échouer `isEqual(merged, sub)`).\n *\n * Pattern pre-check — Quand les deux schemas ont des patterns différents,\n * vérifie l'inclusion par échantillonnage via `isPatternSubset`. Si confirmé,\n * retire le pattern de sup avant le merge (même stratégie que pour `not`).\n *\n * Principe : merge(sub, sup) ≡ sub → sub est un sous-ensemble de sup.\n *\n * Utilise `_.some`, `_.has`, `_.omit`, `_.keys`, `_.isEmpty` pour la logique.\n */\nexport function isAtomicSubsetOf(\n\tsub: JSONSchema7Definition,\n\tsup: JSONSchema7Definition,\n\tengine: MergeEngine,\n): boolean {\n\tconst { branches: supBranches } = getBranchesTyped(sup);\n\n\t// Schema simple → merge direct\n\tif (supBranches.length === 1 && supBranches[0] === sup) {\n\t\t// Point 7 : pré-check `not` étendu\n\t\tconst notResult = evaluateNot(sub, sup);\n\t\tif (notResult === false) return false;\n\n\t\t// ── Format pre-check ──\n\t\t// Si les deux schemas ont un `format` différent, vérifier que\n\t\t// sub.format ⊆ sup.format. Sinon, sub ne peut pas être ⊆ sup.\n\t\t// Cela complète hasFormatConflict (qui gère le merge) en gérant\n\t\t// la direction du subset check que le merge ne peut pas résoudre.\n\t\tif (\n\t\t\ttypeof sub !== \"boolean\" &&\n\t\t\ttypeof sup !== \"boolean\" &&\n\t\t\thas(sub, \"format\") &&\n\t\t\thas(sup, \"format\") &&\n\t\t\tsub.format !== sup.format\n\t\t) {\n\t\t\tconst fmtResult = isFormatSubset(\n\t\t\t\tsub.format as string,\n\t\t\t\tsup.format as string,\n\t\t\t);\n\t\t\tif (fmtResult !== true) return false;\n\t\t}\n\n\t\t// ── Pattern pre-check ──\n\t\t// Si les deux schemas ont des patterns différents, vérifier l'inclusion\n\t\t// par échantillonnage. Si sub.pattern ⊄ sup.pattern (contre-exemple trouvé),\n\t\t// on retourne false immédiatement. Sinon, on pourra retirer le pattern\n\t\t// de sup pour éviter le faux négatif structurel du merge.\n\t\tif (\n\t\t\ttypeof sub !== \"boolean\" &&\n\t\t\ttypeof sup !== \"boolean\" &&\n\t\t\thas(sub, \"pattern\") &&\n\t\t\thas(sup, \"pattern\") &&\n\t\t\tsub.pattern !== sup.pattern\n\t\t) {\n\t\t\tconst patResult = isPatternSubset(\n\t\t\t\tsub.pattern as string,\n\t\t\t\tsup.pattern as string,\n\t\t\t);\n\t\t\tif (patResult === false) return false;\n\t\t}\n\n\t\t// Retirer `not` de sup (top-level et/ou dans les properties)\n\t\t// quand evaluateNot confirme la compatibilité au niveau correspondant.\n\t\t// Cela évite que le merge engine ajoute une contrainte `not` que sub n'a pas\n\t\t// (ce qui ferait merged ≠ sub et produirait un faux négatif).\n\t\tlet effectiveSup = sup;\n\t\tif (typeof sup !== \"boolean\") {\n\t\t\t// Si top-level not est confirmé compatible → retirer le not top-level\n\t\t\tif (notResult === true) {\n\t\t\t\teffectiveSup = stripNotFromSup(sub, sup, true);\n\t\t\t\t// Si sup n'avait QUE `not` → sub est compatible (le not est résolu)\n\t\t\t\tif (typeof effectiveSup !== \"boolean\" && isEmpty(keys(effectiveSup))) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\t// Même si le top-level not n'est pas confirmé (null), on tente\n\t\t\t\t// de retirer les `not` dans les properties individuelles\n\t\t\t\t// sans toucher au `not` top-level\n\t\t\t\teffectiveSup = stripNotFromSup(sub, sup, false);\n\t\t\t}\n\n\t\t\t// Retirer les patterns de sup confirmés par échantillonnage.\n\t\t\t// Même stratégie que pour `not` : on retire la contrainte déjà\n\t\t\t// satisfaite par sub pour éviter que le merge produise un pattern\n\t\t\t// combiné (lookahead conjunction) structurellement ≠ sub.\n\t\t\teffectiveSup = stripPatternFromSup(sub, effectiveSup);\n\t\t}\n\n\t\tconst merged = engine.merge(sub, effectiveSup);\n\t\t// Normalise le résultat du merge pour éliminer les artefacts\n\t\t// structurels (ex: enum redondant quand const est présent)\n\t\treturn merged !== null && engine.isEqual(normalize(merged), sub);\n\t}\n\n\t// anyOf/oneOf dans sup → au moins une branche doit accepter sub\n\treturn some(supBranches, (branch) => {\n\t\t// Point 7 : pré-check `not` étendu par branche\n\t\tconst notResult = evaluateNot(sub, branch);\n\t\tif (notResult === false) return false;\n\n\t\t// ── Pattern pre-check par branche ──\n\t\tif (\n\t\t\ttypeof sub !== \"boolean\" &&\n\t\t\ttypeof branch !== \"boolean\" &&\n\t\t\thas(sub, \"pattern\") &&\n\t\t\thas(branch, \"pattern\") &&\n\t\t\tsub.pattern !== branch.pattern\n\t\t) {\n\t\t\tconst patResult = isPatternSubset(\n\t\t\t\tsub.pattern as string,\n\t\t\t\tbranch.pattern as string,\n\t\t\t);\n\t\t\tif (patResult === false) return false;\n\t\t}\n\n\t\t// Même logique de strip pour les branches\n\t\tlet effectiveBranch = branch;\n\t\tif (typeof branch !== \"boolean\") {\n\t\t\tif (notResult === true) {\n\t\t\t\teffectiveBranch = stripNotFromSup(sub, branch, true);\n\t\t\t\tif (\n\t\t\t\t\ttypeof effectiveBranch !== \"boolean\" &&\n\t\t\t\t\tisEmpty(keys(effectiveBranch))\n\t\t\t\t) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\teffectiveBranch = stripNotFromSup(sub, branch, false);\n\t\t\t}\n\n\t\t\t// Strip patterns confirmés par échantillonnage\n\t\t\teffectiveBranch = stripPatternFromSup(sub, effectiveBranch);\n\t\t}\n\n\t\tconst merged = engine.merge(sub, effectiveBranch);\n\t\treturn merged !== null && engine.isEqual(normalize(merged), sub);\n\t});\n}\n\n// ─── Full subset check (with diffs) ─────────────────────────────────────────\n\n/**\n * Vérifie `sub ⊆ sup` pour un sub qui a des branches (anyOf/oneOf).\n * Chaque branche de sub doit être acceptée par sup.\n *\n * Point 6 — Utilise `getBranchesTyped` pour distinguer `anyOf[i]` de\n * `oneOf[i]` dans les paths de diff.\n *\n * Utilise `_.every` / `_.flatMap` / `_.map` pour une itération idiomatique.\n */\nexport function checkBranchedSub(\n\tsubBranches: JSONSchema7Definition[],\n\tsup: JSONSchema7Definition,\n\tengine: MergeEngine,\n\tbranchType: BranchType = \"anyOf\",\n): SubsetResult {\n\tconst allDiffs: SchemaDiff[] = [];\n\tlet allSubset = true;\n\n\t// Point 6 : utilise le type de branche réel pour le path\n\tconst branchLabel = branchType === \"none\" ? \"anyOf\" : branchType;\n\n\tfor (let i = 0; i < subBranches.length; i++) {\n\t\tconst branch = subBranches[i];\n\t\tif (branch === undefined) continue;\n\t\tif (!isAtomicSubsetOf(branch, sup, engine)) {\n\t\t\tallSubset = false;\n\t\t\tallDiffs.push({\n\t\t\t\tpath: `${branchLabel}[${i}]`,\n\t\t\t\ttype: \"changed\",\n\t\t\t\texpected: branch,\n\t\t\t\tactual: \"Branch not accepted by superset\",\n\t\t\t});\n\t\t}\n\t}\n\n\treturn {\n\t\tisSubset: allSubset,\n\t\tmerged: allSubset\n\t\t\t? branchType === \"oneOf\"\n\t\t\t\t? { oneOf: subBranches }\n\t\t\t\t: { anyOf: subBranches }\n\t\t\t: null,\n\t\tdiffs: allDiffs,\n\t};\n}\n\n/**\n * Vérifie `sub ⊆ sup` pour un sup qui a des branches (anyOf/oneOf).\n * Au moins une branche de sup doit accepter sub.\n *\n * Point 6 — Utilise le type de branche de sup pour des messages plus précis.\n *\n * Utilise `_.some` pour trouver la première branche compatible.\n */\nexport function checkBranchedSup(\n\tsub: JSONSchema7Definition,\n\tsupBranches: JSONSchema7Definition[],\n\tengine: MergeEngine,\n\tbranchType: BranchType = \"anyOf\",\n): SubsetResult {\n\tfor (const branch of supBranches) {\n\t\t// Strip patterns confirmés par échantillonnage avant le merge\n\t\tlet effectiveBranch = branch;\n\t\tif (typeof sub !== \"boolean\" && typeof branch !== \"boolean\") {\n\t\t\teffectiveBranch = stripPatternFromSup(sub, branch);\n\t\t}\n\t\tconst merged = engine.merge(sub, effectiveBranch);\n\t\tif (merged !== null && engine.isEqual(normalize(merged), sub)) {\n\t\t\treturn { isSubset: true, merged, diffs: [] };\n\t\t}\n\t}\n\n\t// Point 6 : message précis selon le type de branche\n\tconst branchLabel = branchType === \"none\" ? \"anyOf\" : branchType;\n\n\treturn {\n\t\tisSubset: false,\n\t\tmerged: null,\n\t\tdiffs: [\n\t\t\t{\n\t\t\t\tpath: \"$\",\n\t\t\t\ttype: \"changed\",\n\t\t\t\texpected: sub,\n\t\t\t\tactual: `No branch in superset's ${branchLabel} accepts this schema`,\n\t\t\t},\n\t\t],\n\t};\n}\n\n/**\n * Vérifie `sub ⊆ sup` pour deux schemas atomiques (sans anyOf/oneOf).\n * Utilise `mergeOrThrow` pour capturer les erreurs d'incompatibilité.\n *\n * Utilise `_.isEqual` via engine.isEqual pour la comparaison structurelle.\n */\nexport function checkAtomic(\n\tsub: JSONSchema7Definition,\n\tsup: JSONSchema7Definition,\n\tengine: MergeEngine,\n): SubsetResult {\n\t// Strip patterns confirmés par échantillonnage avant le merge,\n\t// même stratégie que dans isAtomicSubsetOf pour éviter les faux négatifs\n\t// structurels causés par la conjonction de patterns en lookahead.\n\tlet effectiveSup = sup;\n\tif (typeof sub !== \"boolean\" && typeof sup !== \"boolean\") {\n\t\teffectiveSup = stripPatternFromSup(sub, sup);\n\t}\n\n\ttry {\n\t\tconst merged = engine.mergeOrThrow(sub, effectiveSup);\n\t\tconst normalizedMerged = normalize(merged);\n\t\tconst cmp = engine.compare(normalizedMerged, sub);\n\n\t\tif (cmp === 0) {\n\t\t\treturn { isSubset: true, merged: normalizedMerged, diffs: [] };\n\t\t}\n\n\t\tconst diffs = computeDiffs(sub, normalizedMerged, \"\");\n\t\treturn { isSubset: false, merged: normalizedMerged, diffs };\n\t} catch (e) {\n\t\treturn {\n\t\t\tisSubset: false,\n\t\t\tmerged: null,\n\t\t\tdiffs: [\n\t\t\t\t{\n\t\t\t\t\tpath: \"$\",\n\t\t\t\t\ttype: \"changed\",\n\t\t\t\t\texpected: sub,\n\t\t\t\t\tactual: `Incompatible: ${e instanceof Error ? e.message : String(e)}`,\n\t\t\t\t},\n\t\t\t],\n\t\t};\n\t}\n}\n"
-  ],
-  "mappings": "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",
-  "debugId": "14C2312108595FF864756E2164756E21",
-  "names": []
-}

package/dist/chunk-g0pfcnm5.js

@@ -1,5 +0,0 @@
-import{isEmail as y,isFQDN as z,isIP as C,isISO8601 as H,isURL as w,isUUID as Y}from"class-validator";import Z from"lodash/includes";var $=/^\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})?$/,x=/^\d{4}-\d{2}-\d{2}$/,K=/^(\/([^~/]|~[01])*)*$/,W=/^\d+(#|(\/([^~/]|~[01])*)*)$/;var q=new Set(["date-time","date","time","email","idn-email","hostname","idn-hostname","ipv4","ipv6","uri","uri-reference","iri","iri-reference","uri-template","uuid","json-pointer","relative-json-pointer","regex"]),J={email:["idn-email"],hostname:["idn-hostname"],uri:["iri"],"uri-reference":["iri-reference"]},Q={"date-time":(g)=>{return H(g,{strict:!0})},date:(g)=>{if(!x.test(g))return!1;let j=new Date(`${g}T00:00:00Z`);return!Number.isNaN(j.getTime())&&g===j.toISOString().slice(0,10)},time:(g)=>{return $.test(g)},email:(g)=>{return y(g)},"idn-email":(g)=>{return y(g)},hostname:(g)=>{return z(g,{require_tld:!1})},"idn-hostname":(g)=>{return z(g,{require_tld:!1})},ipv4:(g)=>{return C(g,4)},ipv6:(g)=>{return C(g,6)},uri:(g)=>{return w(g,{require_protocol:!0})},"uri-reference":(g)=>{return w(g,{require_protocol:!1})},iri:(g)=>{return w(g,{require_protocol:!0})},"iri-reference":(g)=>{return w(g,{require_protocol:!1})},"uri-template":(g)=>{let j=!1;for(let k of g)if(k==="{"){if(j)return!1;j=!0}else if(k==="}"){if(!j)return!1;j=!1}return!j},uuid:(g)=>{return Y(g)},"json-pointer":(g)=>{if(g==="")return!0;return K.test(g)},"relative-json-pointer":(g)=>{return W.test(g)},regex:(g)=>{try{return new RegExp(g),!0}catch{return!1}}};function h(g){return q.has(g)}function G(g,j){if(typeof g!=="string")return!0;let k=Q[j];if(!k)return null;return k(g)}function M(g,j){if(g===j)return!0;let k=J[g];if(k&&Z(k,j))return!0;return null}
-export{q as n,J as o,h as p,G as q,M as r};
-
-//# debugId=DFC0070B9A7B6CD064756E2164756E21
-//# sourceMappingURL=chunk-g0pfcnm5.js.map

package/dist/chunk-g0pfcnm5.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/format-validator.ts"],
-  "sourcesContent": [
-    "import {\n\tisEmail,\n\tisFQDN,\n\tisIP,\n\tisISO8601,\n\tisURL,\n\tisUUID,\n} from \"class-validator\";\nimport includes from \"lodash/includes\";\n\n// ─── Format Validator ─────────────────────────────────────────────────────────\n//\n// Valide les valeurs contre les formats JSON Schema Draft-07 en utilisant\n// les fonctions utilitaires de `class-validator`.\n//\n// ⚠️  Ce module ne gère PAS la relation format ⊆ type.\n// Cette relation est déjà correctement gérée par l'approche merge :\n//   - { format: \"email\" } ⊆ { type: \"string\" } → true (merge ne change rien)\n//   - { type: \"string\" } ⊄ { format: \"email\" } → false (merge ajoute format)\n//\n// Ce module gère UNIQUEMENT :\n//   1. La validation d'une valeur runtime contre un format (evaluateCondition)\n//   2. La compatibilité entre deux formats différents (format-vs-format)\n//\n// Expose :\n//   - `validateFormat(value, format)` → validation runtime d'une valeur\n//   - `isFormatSubset(sub, sup)` → compatibilité statique format-vs-format\n//   - `isKnownFormat(format)` → vérifie si le format est supporté\n//   - `FORMAT_SUPERSETS` → hiérarchie d'inclusion entre formats\n\n// ─── Regex patterns ──────────────────────────────────────────────────────────\n\n/** Regex pour le format `time` (HH:MM:SS avec offset optionnel) */\nconst TIME_REGEX = /^\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(Z|[+-]\\d{2}:\\d{2})?$/;\n\n/** Regex pour le format `date` (YYYY-MM-DD strict) */\nconst DATE_REGEX = /^\\d{4}-\\d{2}-\\d{2}$/;\n\n/** Regex pour le format `json-pointer` (RFC 6901) */\nconst JSON_POINTER_REGEX = /^(\\/([^~/]|~[01])*)*$/;\n\n/** Regex pour le format `relative-json-pointer` (extension Draft-07) */\nconst RELATIVE_JSON_POINTER_REGEX = /^\\d+(#|(\\/([^~/]|~[01])*)*)$/;\n\n/** Regex pour le format `uri-template` (RFC 6570 — vérification basique) */\nconst _URI_TEMPLATE_REGEX = /\\{[^}]+\\}/;\n\n// ─── Known formats ──────────────────────────────────────────────────────────\n\n/** Formats reconnus par le validateur */\nexport const KNOWN_FORMATS: ReadonlySet<string> = new Set([\n\t\"date-time\",\n\t\"date\",\n\t\"time\",\n\t\"email\",\n\t\"idn-email\",\n\t\"hostname\",\n\t\"idn-hostname\",\n\t\"ipv4\",\n\t\"ipv6\",\n\t\"uri\",\n\t\"uri-reference\",\n\t\"iri\",\n\t\"iri-reference\",\n\t\"uri-template\",\n\t\"uuid\",\n\t\"json-pointer\",\n\t\"relative-json-pointer\",\n\t\"regex\",\n]);\n\n// ─── Format hierarchy ────────────────────────────────────────────────────────\n\n/**\n * Hiérarchie d'inclusion ENTRE FORMATS (pas format-vs-type).\n *\n * `FORMAT_SUPERSETS[format]` = liste des formats qui sont des sur-ensembles\n * de `format` (i.e., toute valeur valide pour `format` est aussi valide\n * pour chacun des sur-ensembles).\n *\n * Cette hiérarchie ne concerne QUE les comparaisons format-vs-format.\n * La relation format ⊆ type (ex: email ⊆ string) est gérée nativement\n * par le merge engine et n'a pas besoin d'être modélisée ici.\n *\n * En pratique, la plupart des formats sont **incomparables** (pas de relation d'inclusion).\n * Seule l'identité (même format) et les quelques relations ci-dessous sont garanties.\n */\nexport const FORMAT_SUPERSETS: Record<string, string[]> = {\n\temail: [\"idn-email\"], // email ⊆ idn-email (toute email ASCII est une idn-email)\n\thostname: [\"idn-hostname\"], // hostname ⊆ idn-hostname\n\turi: [\"iri\"], // uri ⊆ iri (toute URI est une IRI)\n\t\"uri-reference\": [\"iri-reference\"], // uri-reference ⊆ iri-reference\n};\n\n// ─── Format validators (internal) ───────────────────────────────────────────\n\n/**\n * Map interne des fonctions de validation par format.\n *\n * Chaque entrée associe un format Draft-07 à une fonction qui prend\n * une valeur `string` et retourne `boolean`.\n *\n * Utilise les fonctions standalone de `class-validator` quand disponibles,\n * sinon des regex ou des heuristiques.\n */\nconst FORMAT_VALIDATORS: Record<string, (value: string) => boolean> = {\n\t/** ISO 8601 date-time (ex: \"2023-01-15T10:30:00Z\") */\n\t\"date-time\": (value: string): boolean => {\n\t\treturn isISO8601(value, { strict: true });\n\t},\n\n\t/** Date complète (ex: \"2023-01-15\") */\n\tdate: (value: string): boolean => {\n\t\tif (!DATE_REGEX.test(value)) return false;\n\t\t// Vérifier que la date est valide (pas de 2023-02-30)\n\t\tconst d = new Date(`${value}T00:00:00Z`);\n\t\treturn !Number.isNaN(d.getTime()) && value === d.toISOString().slice(0, 10);\n\t},\n\n\t/** Heure complète (ex: \"10:30:00\") */\n\ttime: (value: string): boolean => {\n\t\treturn TIME_REGEX.test(value);\n\t},\n\n\t/** Adresse email (RFC 5321) */\n\temail: (value: string): boolean => {\n\t\treturn isEmail(value);\n\t},\n\n\t/** Adresse email internationalisée (approximation via isEmail) */\n\t\"idn-email\": (value: string): boolean => {\n\t\treturn isEmail(value);\n\t},\n\n\t/** Nom d'hôte (RFC 1123) */\n\thostname: (value: string): boolean => {\n\t\treturn isFQDN(value, { require_tld: false });\n\t},\n\n\t/** Nom d'hôte internationalisé (approximation via isFQDN) */\n\t\"idn-hostname\": (value: string): boolean => {\n\t\treturn isFQDN(value, { require_tld: false });\n\t},\n\n\t/** Adresse IPv4 (ex: \"192.168.1.1\") */\n\tipv4: (value: string): boolean => {\n\t\treturn isIP(value, 4);\n\t},\n\n\t/** Adresse IPv6 (ex: \"::1\") */\n\tipv6: (value: string): boolean => {\n\t\treturn isIP(value, 6);\n\t},\n\n\t/** URI absolue (RFC 3986) */\n\turi: (value: string): boolean => {\n\t\treturn isURL(value, { require_protocol: true });\n\t},\n\n\t/** Référence URI (absolue ou relative — approximation via isURL) */\n\t\"uri-reference\": (value: string): boolean => {\n\t\t// Une uri-reference peut être relative, isURL est une approximation\n\t\treturn isURL(value, { require_protocol: false });\n\t},\n\n\t/** IRI (RFC 3987 — approximation via isURL) */\n\tiri: (value: string): boolean => {\n\t\treturn isURL(value, { require_protocol: true });\n\t},\n\n\t/** Référence IRI (approximation via isURL) */\n\t\"iri-reference\": (value: string): boolean => {\n\t\treturn isURL(value, { require_protocol: false });\n\t},\n\n\t/** Template URI (RFC 6570 — vérification basique) */\n\t\"uri-template\": (value: string): boolean => {\n\t\t// Un uri-template valide peut contenir des expressions entre accolades\n\t\t// ou être une URI simple sans template expressions.\n\t\t// On vérifie juste que les accolades sont bien formées.\n\t\tlet inBrace = false;\n\t\tfor (const ch of value) {\n\t\t\tif (ch === \"{\") {\n\t\t\t\tif (inBrace) return false; // Accolades imbriquées\n\t\t\t\tinBrace = true;\n\t\t\t} else if (ch === \"}\") {\n\t\t\t\tif (!inBrace) return false; // Accolade fermante sans ouvrante\n\t\t\t\tinBrace = false;\n\t\t\t}\n\t\t}\n\t\treturn !inBrace; // Pas d'accolade non fermée\n\t},\n\n\t/** UUID (RFC 4122) */\n\tuuid: (value: string): boolean => {\n\t\treturn isUUID(value);\n\t},\n\n\t/** JSON Pointer (RFC 6901) */\n\t\"json-pointer\": (value: string): boolean => {\n\t\t// Chaîne vide est un json-pointer valide (pointe vers la racine)\n\t\tif (value === \"\") return true;\n\t\treturn JSON_POINTER_REGEX.test(value);\n\t},\n\n\t/** Relative JSON Pointer (extension Draft-07) */\n\t\"relative-json-pointer\": (value: string): boolean => {\n\t\treturn RELATIVE_JSON_POINTER_REGEX.test(value);\n\t},\n\n\t/** Expression régulière ECMA-262 */\n\tregex: (value: string): boolean => {\n\t\ttry {\n\t\t\tnew RegExp(value);\n\t\t\treturn true;\n\t\t} catch {\n\t\t\treturn false;\n\t\t}\n\t},\n};\n\n// ─── Public API ──────────────────────────────────────────────────────────────\n\n/**\n * Vérifie si le format est connu/supporté.\n *\n * @param format  Le nom du format à vérifier\n * @returns       `true` si le format est dans la liste des formats reconnus\n */\nexport function isKnownFormat(format: string): boolean {\n\treturn KNOWN_FORMATS.has(format);\n}\n\n/**\n * Valide une valeur contre un format JSON Schema Draft-07.\n *\n * Retourne `true` si la valeur est valide pour le format,\n * `false` si elle ne l'est pas, `null` si le format est inconnu.\n *\n * Ne valide que les strings — pour les non-strings, retourne `true`\n * (le format ne s'applique qu'aux strings en Draft-07).\n *\n * @param value   La valeur à valider\n * @param format  Le format JSON Schema Draft-07 à vérifier\n * @returns       `true` si valide, `false` si invalide, `null` si format inconnu\n *\n * @example\n * ```ts\n * validateFormat(\"test@example.com\", \"email\");  // true\n * validateFormat(\"not-an-email\", \"email\");       // false\n * validateFormat(42, \"email\");                   // true (non-string → skip)\n * validateFormat(\"foo\", \"unknown-format\");       // null (format inconnu)\n * ```\n */\nexport function validateFormat(value: unknown, format: string): boolean | null {\n\t// Le format ne s'applique qu'aux strings en Draft-07\n\tif (typeof value !== \"string\") return true;\n\n\tconst validator = FORMAT_VALIDATORS[format];\n\tif (!validator) return null; // Format inconnu → indéterminé\n\n\treturn validator(value);\n}\n\n/**\n * Vérifie si le format `sub` est un sous-ensemble du format `sup`.\n *\n * ⚠️  Cette fonction compare UNIQUEMENT deux formats entre eux.\n * Elle ne gère PAS la relation format ⊆ type (ex: email ⊆ string),\n * qui est déjà correctement gérée par le merge engine.\n *\n * `sub ⊆ sup` signifie : toute valeur valide pour `sub` est aussi valide pour `sup`.\n *\n * Retourne `true` si `sub ⊆ sup`, `false` si incompatible, `null` si indéterminé.\n *\n * Cas gérés :\n *   - Identité : `sub === sup` → `true`\n *   - Hiérarchie : `sup` est dans `FORMAT_SUPERSETS[sub]` → `true`\n *   - Hiérarchie inverse : `sub` est dans `FORMAT_SUPERSETS[sup]` → `null`\n *     (le subset est un sur-ensemble du superset → indéterminé, pas un conflit\n *     car certaines valeurs valides pour sub pourraient aussi être valides pour sup)\n *   - Formats différents sans relation connue → `null` (indéterminé)\n *\n * @param subFormat  Le format du schema sub\n * @param supFormat  Le format du schema sup\n * @returns          `true` si sub ⊆ sup, `null` si indéterminé\n *\n * @example\n * ```ts\n * isFormatSubset(\"email\", \"email\");       // true (identité)\n * isFormatSubset(\"email\", \"idn-email\");   // true (email ⊆ idn-email)\n * isFormatSubset(\"email\", \"ipv4\");        // null (incomparable)\n * isFormatSubset(\"idn-email\", \"email\");   // null (sur-ensemble, pas sous-ensemble)\n * ```\n */\nexport function isFormatSubset(\n\tsubFormat: string,\n\tsupFormat: string,\n): boolean | null {\n\t// Identité : même format → toujours un sous-ensemble\n\tif (subFormat === supFormat) return true;\n\n\t// Hiérarchie : vérifier si sup est un sur-ensemble connu de sub\n\tconst supersets = FORMAT_SUPERSETS[subFormat];\n\tif (supersets && includes(supersets, supFormat)) {\n\t\treturn true;\n\t}\n\n\t// Formats différents sans relation connue → indéterminé\n\t// On ne retourne PAS false ici car on ne peut pas affirmer l'incompatibilité\n\t// entre deux formats quelconques sans les connaître parfaitement.\n\t// Le merge engine (via hasFormatConflict) se charge de détecter les conflits\n\t// quand les deux schemas ont un format et qu'aucune relation n'est connue.\n\treturn null;\n}\n"
-  ],
-  "mappings": "AAAA,kBACC,YACA,UACA,eACA,WACA,YACA,wBAED,+BAyBA,IAAM,EAAa,kDAGb,EAAa,sBAGb,EAAqB,wBAGrB,EAA8B,+BAQ7B,IAAM,EAAqC,IAAI,IAAI,CACzD,YACA,OACA,OACA,QACA,YACA,WACA,eACA,OACA,OACA,MACA,gBACA,MACA,gBACA,eACA,OACA,eACA,wBACA,OACD,CAAC,EAkBY,EAA6C,CACzD,MAAO,CAAC,WAAW,EACnB,SAAU,CAAC,cAAc,EACzB,IAAK,CAAC,KAAK,EACX,gBAAiB,CAAC,eAAe,CAClC,EAaM,EAAgE,CAErE,YAAa,CAAC,IAA2B,CACxC,OAAO,EAAU,EAAO,CAAE,OAAQ,EAAK,CAAC,GAIzC,KAAM,CAAC,IAA2B,CACjC,GAAI,CAAC,EAAW,KAAK,CAAK,EAAG,MAAO,GAEpC,IAAM,EAAI,IAAI,KAAK,GAAG,aAAiB,EACvC,MAAO,CAAC,OAAO,MAAM,EAAE,QAAQ,CAAC,GAAK,IAAU,EAAE,YAAY,EAAE,MAAM,EAAG,EAAE,GAI3E,KAAM,CAAC,IAA2B,CACjC,OAAO,EAAW,KAAK,CAAK,GAI7B,MAAO,CAAC,IAA2B,CAClC,OAAO,EAAQ,CAAK,GAIrB,YAAa,CAAC,IAA2B,CACxC,OAAO,EAAQ,CAAK,GAIrB,SAAU,CAAC,IAA2B,CACrC,OAAO,EAAO,EAAO,CAAE,YAAa,EAAM,CAAC,GAI5C,eAAgB,CAAC,IAA2B,CAC3C,OAAO,EAAO,EAAO,CAAE,YAAa,EAAM,CAAC,GAI5C,KAAM,CAAC,IAA2B,CACjC,OAAO,EAAK,EAAO,CAAC,GAIrB,KAAM,CAAC,IAA2B,CACjC,OAAO,EAAK,EAAO,CAAC,GAIrB,IAAK,CAAC,IAA2B,CAChC,OAAO,EAAM,EAAO,CAAE,iBAAkB,EAAK,CAAC,GAI/C,gBAAiB,CAAC,IAA2B,CAE5C,OAAO,EAAM,EAAO,CAAE,iBAAkB,EAAM,CAAC,GAIhD,IAAK,CAAC,IAA2B,CAChC,OAAO,EAAM,EAAO,CAAE,iBAAkB,EAAK,CAAC,GAI/C,gBAAiB,CAAC,IAA2B,CAC5C,OAAO,EAAM,EAAO,CAAE,iBAAkB,EAAM,CAAC,GAIhD,eAAgB,CAAC,IAA2B,CAI3C,IAAI,EAAU,GACd,QAAW,KAAM,EAChB,GAAI,IAAO,IAAK,CACf,GAAI,EAAS,MAAO,GACpB,EAAU,GACJ,QAAI,IAAO,IAAK,CACtB,GAAI,CAAC,EAAS,MAAO,GACrB,EAAU,GAGZ,MAAO,CAAC,GAIT,KAAM,CAAC,IAA2B,CACjC,OAAO,EAAO,CAAK,GAIpB,eAAgB,CAAC,IAA2B,CAE3C,GAAI,IAAU,GAAI,MAAO,GACzB,OAAO,EAAmB,KAAK,CAAK,GAIrC,wBAAyB,CAAC,IAA2B,CACpD,OAAO,EAA4B,KAAK,CAAK,GAI9C,MAAO,CAAC,IAA2B,CAClC,GAAI,CAEH,OADA,IAAI,OAAO,CAAK,EACT,GACN,KAAM,CACP,MAAO,IAGV,EAUO,SAAS,CAAa,CAAC,EAAyB,CACtD,OAAO,EAAc,IAAI,CAAM,EAwBzB,SAAS,CAAc,CAAC,EAAgB,EAAgC,CAE9E,GAAI,OAAO,IAAU,SAAU,MAAO,GAEtC,IAAM,EAAY,EAAkB,GACpC,GAAI,CAAC,EAAW,OAAO,KAEvB,OAAO,EAAU,CAAK,EAkChB,SAAS,CAAc,CAC7B,EACA,EACiB,CAEjB,GAAI,IAAc,EAAW,MAAO,GAGpC,IAAM,EAAY,EAAiB,GACnC,GAAI,GAAa,EAAS,EAAW,CAAS,EAC7C,MAAO,GAQR,OAAO",
-  "debugId": "DFC0070B9A7B6CD064756E2164756E21",
-  "names": []
-}

package/dist/chunk-h080ggvf.js

@@ -1,5 +0,0 @@
-import{b as Q,c as U,d as X,e as Y,f as Z}from"./chunk-e4501gq7.js";import{j as N}from"./chunk-w7qcey06.js";import{l as V}from"./chunk-cspd2zw4.js";import{m as W}from"./chunk-2vpph7cy.js";import{t as G}from"./chunk-pw49kj6f.js";class ${engine;constructor(){this.engine=new W}isSubset(j,w){let x=G(j),J=G(w),{branches:H}=Q(x);if(H.length>1||H[0]!==x)return H.every((K)=>U(K,J,this.engine));return U(x,J,this.engine)}check(j,w){let x=G(j),J=G(w),{branches:H,type:K}=Q(x),{branches:L,type:_}=Q(J);if(H.length>1||H[0]!==x)return X(H,J,this.engine,K);if(L.length>1||L[0]!==J)return Y(x,L,this.engine,_);return Z(x,J,this.engine)}canConnect(j,w){return{...this.check(j,w),direction:"sourceOutput ⊆ targetInput"}}isEqual(j,w){return this.engine.isEqual(G(j),G(w))}intersect(j,w){let x=this.engine.merge(G(j),G(w));return x!==null?G(x):null}resolveConditions(j,w){return N(j,w,this.engine)}checkResolved(j,w,x,J){let H=N(j,x,this.engine),K=N(w,J??x,this.engine);return{...this.check(H.resolved,K.resolved),resolvedSub:H,resolvedSup:K}}normalize(j){return G(j)}formatResult(j,w){return V(j,w)}}
-export{$ as a};
-
-//# debugId=4FAC5F36C398ED8864756E2164756E21
-//# sourceMappingURL=chunk-h080ggvf.js.map

package/dist/chunk-h080ggvf.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/json-schema-compatibility-checker.ts"],
-  "sourcesContent": [
-    "import type { JSONSchema7, JSONSchema7Definition } from \"json-schema\";\nimport { resolveConditions } from \"./condition-resolver\";\nimport { formatResult } from \"./formatter\";\nimport { MergeEngine } from \"./merge-engine\";\nimport { normalize } from \"./normalizer\";\nimport {\n\tarePatternsEquivalent,\n\tisPatternSubset,\n\tisTrivialPattern,\n} from \"./pattern-subset\";\nimport type { BranchResult, BranchType } from \"./subset-checker\";\nimport {\n\tcheckAtomic,\n\tcheckBranchedSub,\n\tcheckBranchedSup,\n\tgetBranchesTyped,\n\tisAtomicSubsetOf,\n} from \"./subset-checker\";\nimport type {\n\tConnectionResult,\n\tResolvedConditionResult,\n\tSchemaDiff,\n\tSubsetResult,\n} from \"./types\";\n\n// ─── Re-exports ──────────────────────────────────────────────────────────────\n\nexport type {\n\tSchemaDiff,\n\tSubsetResult,\n\tConnectionResult,\n\tResolvedConditionResult,\n\tBranchType,\n\tBranchResult,\n};\n\nexport {\n\tnormalize,\n\tresolveConditions,\n\tformatResult,\n\tMergeEngine,\n\tisPatternSubset,\n\tarePatternsEquivalent,\n\tisTrivialPattern,\n};\n\n// ─── Main Class ──────────────────────────────────────────────────────────────\n//\n// Façade légère qui orchestre les sous-modules pour vérifier la compatibilité\n// entre JSON Schemas (Draft-07).\n//\n// Principe mathématique :\n//   A ⊆ B  ⟺  A ∩ B ≡ A\n//\n// En JSON Schema :\n//   - A ∩ B  =  allOf([A, B])  résolu via merge\n//   - ≡      =  comparaison structurelle\n//\n// @example\n// ```ts\n// const checker = new JsonSchemaCompatibilityChecker();\n//\n// checker.isSubset(strict, loose);             // true\n// checker.check(loose, strict);                // { isSubset: false, diffs: [...] }\n// checker.canConnect(nodeA.output, nodeB.input); // ConnectionResult\n// ```\n\nexport class JsonSchemaCompatibilityChecker {\n\tprivate readonly engine: MergeEngine;\n\n\tconstructor() {\n\t\tthis.engine = new MergeEngine();\n\t}\n\n\t// ── Subset check (boolean) ─────────────────────────────────────────────\n\n\t/**\n\t * Vérifie si `sub ⊆ sup`.\n\t * Toute valeur valide pour sub est-elle aussi valide pour sup ?\n\t *\n\t * Point 6 — Utilise `getBranchesTyped` pour distinguer `anyOf` de `oneOf`\n\t * en interne, bien que le résultat boolean ne reflète pas la distinction.\n\t */\n\tisSubset(sub: JSONSchema7Definition, sup: JSONSchema7Definition): boolean {\n\t\tconst nSub = normalize(sub);\n\t\tconst nSup = normalize(sup);\n\t\tconst { branches: subBranches } = getBranchesTyped(nSub);\n\n\t\tif (subBranches.length > 1 || subBranches[0] !== nSub) {\n\t\t\treturn subBranches.every((branch) =>\n\t\t\t\tisAtomicSubsetOf(branch, nSup, this.engine),\n\t\t\t);\n\t\t}\n\n\t\treturn isAtomicSubsetOf(nSub, nSup, this.engine);\n\t}\n\n\t// ── Subset check (detailed) ────────────────────────────────────────────\n\n\t/**\n\t * Vérifie `sub ⊆ sup` et retourne un diagnostic complet\n\t * avec les diffs structurels.\n\t *\n\t * Point 6 — Utilise `getBranchesTyped` pour distinguer `anyOf` de `oneOf`\n\t * dans les paths de diff (ex: `anyOf[0]` vs `oneOf[0]`).\n\t */\n\tcheck(sub: JSONSchema7Definition, sup: JSONSchema7Definition): SubsetResult {\n\t\tconst nSub = normalize(sub);\n\t\tconst nSup = normalize(sup);\n\t\tconst { branches: subBranches, type: subBranchType } =\n\t\t\tgetBranchesTyped(nSub);\n\t\tconst { branches: supBranches, type: supBranchType } =\n\t\t\tgetBranchesTyped(nSup);\n\n\t\t// anyOf/oneOf dans sub\n\t\tif (subBranches.length > 1 || subBranches[0] !== nSub) {\n\t\t\treturn checkBranchedSub(subBranches, nSup, this.engine, subBranchType);\n\t\t}\n\n\t\t// anyOf/oneOf dans sup uniquement\n\t\tif (supBranches.length > 1 || supBranches[0] !== nSup) {\n\t\t\treturn checkBranchedSup(nSub, supBranches, this.engine, supBranchType);\n\t\t}\n\n\t\t// Cas standard\n\t\treturn checkAtomic(nSub, nSup, this.engine);\n\t}\n\n\t// ── Connection check ───────────────────────────────────────────────────\n\n\t/**\n\t * Vérifie si la sortie d'un nœud source peut alimenter l'entrée d'un nœud cible.\n\t *\n\t * Sémantique : `sourceOutput ⊆ targetInput`\n\t * → Toute donnée produite par source sera acceptée par target.\n\t */\n\tcanConnect(\n\t\tsourceOutput: JSONSchema7Definition,\n\t\ttargetInput: JSONSchema7Definition,\n\t): ConnectionResult {\n\t\tconst result = this.check(sourceOutput, targetInput);\n\t\treturn { ...result, direction: \"sourceOutput ⊆ targetInput\" };\n\t}\n\n\t// ── Equality ───────────────────────────────────────────────────────────\n\n\t/**\n\t * Vérifie l'égalité structurelle entre deux schemas.\n\t */\n\tisEqual(a: JSONSchema7Definition, b: JSONSchema7Definition): boolean {\n\t\treturn this.engine.isEqual(normalize(a), normalize(b));\n\t}\n\n\t// ── Intersection ───────────────────────────────────────────────────────\n\n\t/**\n\t * Calcule l'intersection de deux schemas (allOf merge).\n\t * Retourne null si les schemas sont incompatibles.\n\t *\n\t * Le résultat est normalisé pour éliminer les artefacts structurels\n\t * du merge (ex: `enum` redondant quand `const` est présent).\n\t */\n\tintersect(\n\t\ta: JSONSchema7Definition,\n\t\tb: JSONSchema7Definition,\n\t): JSONSchema7Definition | null {\n\t\tconst merged = this.engine.merge(normalize(a), normalize(b));\n\t\treturn merged !== null ? normalize(merged) : null;\n\t}\n\n\t// ── Condition resolution ───────────────────────────────────────────────\n\n\t/**\n\t * Résout les `if/then/else` d'un schema en évaluant le `if` contre\n\t * des données partielles (discriminants).\n\t */\n\tresolveConditions(\n\t\tschema: JSONSchema7,\n\t\tdata: Record<string, unknown>,\n\t): ResolvedConditionResult {\n\t\treturn resolveConditions(schema, data, this.engine);\n\t}\n\n\t// ── Resolved check ────────────────────────────────────────────────────\n\n\t/**\n\t * Raccourci : résout les conditions des deux schemas puis vérifie sub ⊆ sup.\n\t *\n\t * Utile quand le superset contient des if/then/else et que tu connais\n\t * les valeurs discriminantes que le subset va produire.\n\t */\n\tcheckResolved(\n\t\tsub: JSONSchema7,\n\t\tsup: JSONSchema7,\n\t\tsubData: Record<string, unknown>,\n\t\tsupData?: Record<string, unknown>,\n\t): SubsetResult & {\n\t\tresolvedSub: ResolvedConditionResult;\n\t\tresolvedSup: ResolvedConditionResult;\n\t} {\n\t\tconst resolvedSub = resolveConditions(sub, subData, this.engine);\n\t\tconst resolvedSup = resolveConditions(sup, supData ?? subData, this.engine);\n\t\tconst result = this.check(resolvedSub.resolved, resolvedSup.resolved);\n\n\t\treturn { ...result, resolvedSub, resolvedSup };\n\t}\n\n\t// ── Normalization ──────────────────────────────────────────────────────\n\n\t/**\n\t * Normalise un schema : infère `type` depuis `const`/`enum`,\n\t * et normalise récursivement tous les sous-schemas.\n\t */\n\tnormalize(def: JSONSchema7Definition): JSONSchema7Definition {\n\t\treturn normalize(def);\n\t}\n\n\t// ── Formatting ─────────────────────────────────────────────────────────\n\n\t/**\n\t * Formate un SubsetResult en chaîne lisible (utile pour logs/debug).\n\t */\n\tformatResult(label: string, result: SubsetResult): string {\n\t\treturn formatResult(label, result);\n\t}\n}\n"
-  ],
-  "mappings": "4PAmEO,AAAM,LAA+B,LAC1B,CAEjB,WAAW,EAAG,CACb,KAAK,OAAS,IAAI,EAYnB,QAAQ,CAAC,EAA4B,EAAqC,CACzE,IAAM,EAAO,EAAU,CAAG,EACpB,EAAO,EAAU,CAAG,GAClB,SAAU,GAAgB,EAAiB,CAAI,EAEvD,GAAI,EAAY,OAAS,GAAK,EAAY,KAAO,EAChD,OAAO,EAAY,MAAM,CAAC,IACzB,EAAiB,EAAQ,EAAM,KAAK,MAAM,CAC3C,EAGD,OAAO,EAAiB,EAAM,EAAM,KAAK,MAAM,EAYhD,KAAK,CAAC,EAA4B,EAA0C,CAC3E,IAAM,EAAO,EAAU,CAAG,EACpB,EAAO,EAAU,CAAG,GAClB,SAAU,EAAa,KAAM,GACpC,EAAiB,CAAI,GACd,SAAU,EAAa,KAAM,GACpC,EAAiB,CAAI,EAGtB,GAAI,EAAY,OAAS,GAAK,EAAY,KAAO,EAChD,OAAO,EAAiB,EAAa,EAAM,KAAK,OAAQ,CAAa,EAItE,GAAI,EAAY,OAAS,GAAK,EAAY,KAAO,EAChD,OAAO,EAAiB,EAAM,EAAa,KAAK,OAAQ,CAAa,EAItE,OAAO,EAAY,EAAM,EAAM,KAAK,MAAM,EAW3C,UAAU,CACT,EACA,EACmB,CAEnB,MAAO,IADQ,KAAK,MAAM,EAAc,CAAW,EAC/B,UAAW,4BAA4B,EAQ5D,OAAO,CAAC,EAA0B,EAAmC,CACpE,OAAO,KAAK,OAAO,QAAQ,EAAU,CAAC,EAAG,EAAU,CAAC,CAAC,EAYtD,SAAS,CACR,EACA,EAC+B,CAC/B,IAAM,EAAS,KAAK,OAAO,MAAM,EAAU,CAAC,EAAG,EAAU,CAAC,CAAC,EAC3D,OAAO,IAAW,KAAO,EAAU,CAAM,EAAI,KAS9C,iBAAiB,CAChB,EACA,EAC0B,CAC1B,OAAO,EAAkB,EAAQ,EAAM,KAAK,MAAM,EAWnD,aAAa,CACZ,EACA,EACA,EACA,EAIC,CACD,IAAM,EAAc,EAAkB,EAAK,EAAS,KAAK,MAAM,EACzD,EAAc,EAAkB,EAAK,GAAW,EAAS,KAAK,MAAM,EAG1E,MAAO,IAFQ,KAAK,MAAM,EAAY,SAAU,EAAY,QAAQ,EAEhD,cAAa,aAAY,EAS9C,SAAS,CAAC,EAAmD,CAC5D,OAAO,EAAU,CAAG,EAQrB,YAAY,CAAC,EAAe,EAA8B,CACzD,OAAO,EAAa,EAAO,CAAM,EAEnC",
-  "debugId": "4FAC5F36C398ED8864756E2164756E21",
-  "names": []
-}

package/dist/chunk-pw49kj6f.js

@@ -1,5 +0,0 @@
-import C from"lodash/compact";import D from"lodash/first";import U from"lodash/has";import Z from"lodash/isArray";import K from"lodash/isEmpty";import Y from"lodash/isEqual";import $ from"lodash/isPlainObject";import w from"lodash/keys";import I from"lodash/map";import M from"lodash/mapValues";import L from"lodash/omit";import V from"lodash/reduce";import N from"lodash/size";import F from"lodash/some";import j from"lodash/uniq";function W(B){if(B===null)return"null";switch(typeof B){case"string":return"string";case"number":return Number.isInteger(B)?"integer":"number";case"boolean":return"boolean";case"object":return Z(B)?"array":"object";default:return}}var T=["additionalProperties","additionalItems","contains","propertyNames","not","if","then","else"],b=new Set(["$id","$schema","$comment","title","description","default","examples","definitions","$defs"]);function R(B){return w(B).every((X)=>X==="not"||b.has(X))}var _=["anyOf","oneOf","allOf"],z=["properties","patternProperties"];function P(B){return M(B,(g)=>G(g))}function O(B){if(!U(B,"const")||B.type!==void 0)return;let g=W(B.const);return g?g:void 0}function f(B){if(!Z(B.enum)||B.type!==void 0)return;let g=j(C(I(B.enum,(H)=>W(H)))),X=N(g);if(X===1)return D(g);if(X>1)return g;return}function G(B){if(typeof B==="boolean")return B;let g={...B},X=O(g);if(X)g.type=X;let H=f(g);if(H)g.type=H;if(Z(g.enum)&&N(g.enum)===1&&!U(g,"const"))g={...L(g,["enum"]),const:g.enum[0]};if(U(g,"const")&&Z(g.enum)){if(F(g.enum,(x)=>Y(x,g.const)))g=L(g,["enum"])}for(let x of z){let J=g[x];if($(J))g={...g,[x]:P(J)}}if($(g.dependencies))g={...g,dependencies:M(g.dependencies,(x)=>{if(Z(x))return x;if($(x))return G(x);return x})};if(g.items){if(Z(g.items))g={...g,items:I(g.items,(x)=>G(x))};else if($(g.items))g={...g,items:G(g.items)}}if(g=V(T,(x,J)=>{let Q=x[J];if(Q!==void 0&&typeof Q!=="boolean")return{...x,[J]:G(Q)};return x},g),U(g,"not")&&$(g.not)&&typeof g.not!=="boolean"){let x=g.not;if(U(x,"not")&&R(x)&&$(x.not)&&typeof x.not!=="boolean"){let J=x.not,Q=L(g,["not"]);if(K(w(Q)))g={...J};else g={...Q,...J}}}return g=V(_,(x,J)=>{let Q=x[J];if(Z(Q))return{...x,[J]:I(Q,(q)=>G(q))};return x},g),g}
-export{W as s,G as t};
-
-//# debugId=089A2A71B5D4754C64756E2164756E21
-//# sourceMappingURL=chunk-pw49kj6f.js.map

package/dist/chunk-pw49kj6f.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/normalizer.ts"],
-  "sourcesContent": [
-    "import type { JSONSchema7, JSONSchema7Definition } from \"json-schema\";\nimport compact from \"lodash/compact\";\nimport first from \"lodash/first\";\nimport has from \"lodash/has\";\nimport isArray from \"lodash/isArray\";\nimport isEmpty from \"lodash/isEmpty\";\nimport isEqual from \"lodash/isEqual\";\nimport isPlainObject from \"lodash/isPlainObject\";\nimport keys from \"lodash/keys\";\nimport map from \"lodash/map\";\nimport mapValues from \"lodash/mapValues\";\nimport omit from \"lodash/omit\";\nimport reduce from \"lodash/reduce\";\nimport size from \"lodash/size\";\nimport some from \"lodash/some\";\nimport uniq from \"lodash/uniq\";\n\n// ─── Schema Normalizer ───────────────────────────────────────────────────────\n//\n// Fonctions pures pour normaliser un JSON Schema :\n//   - Inférer `type` depuis `const` ou `enum`\n//   - Récurser dans toutes les sous-structures (properties, items, anyOf, etc.)\n//   - Résoudre la double négation `not.not` → aplatir en contenu direct\n//   - Récurser dans `patternProperties` (Point 2)\n//   - Récurser dans `dependencies` forme schema (Point 3)\n//\n// Utilise lodash massivement pour réduire la complexité et améliorer\n// la lisibilité des transformations sur les objets et tableaux.\n\n// ─── Type inference ──────────────────────────────────────────────────────────\n\n/**\n * Infère le type JSON Schema d'une valeur JavaScript.\n */\nexport function inferType(value: unknown): string | undefined {\n\tif (value === null) return \"null\";\n\tswitch (typeof value) {\n\t\tcase \"string\":\n\t\t\treturn \"string\";\n\t\tcase \"number\":\n\t\t\treturn Number.isInteger(value) ? \"integer\" : \"number\";\n\t\tcase \"boolean\":\n\t\t\treturn \"boolean\";\n\t\tcase \"object\":\n\t\t\treturn isArray(value) ? \"array\" : \"object\";\n\t\tdefault:\n\t\t\treturn undefined;\n\t}\n}\n\n// ─── Sub-schema keywords ─────────────────────────────────────────────────────\n\n/** Mots-clés contenant un unique sous-schema */\nconst SINGLE_SCHEMA_KEYWORDS = [\n\t\"additionalProperties\",\n\t\"additionalItems\",\n\t\"contains\",\n\t\"propertyNames\",\n\t\"not\",\n\t\"if\",\n\t\"then\",\n\t\"else\",\n] as const;\n\n/**\n * Vérifie si un schema ne contient qu'un seul mot-clé `not` (et aucun\n * autre mot-clé significatif). Utilisé pour la résolution de double négation.\n *\n * Un schema « pur not » est de la forme `{ not: X }` sans aucune autre\n * contrainte. Dans ce cas, `{ not: { not: Y } }` ≡ `Y`.\n *\n * Les mots-clés de métadonnée (`$id`, `$schema`, `$comment`, `title`,\n * `description`, `default`, `examples`, `definitions`, `$defs`) ne sont\n * PAS considérés comme significatifs pour cette détection.\n */\nconst METADATA_KEYWORDS = new Set([\n\t\"$id\",\n\t\"$schema\",\n\t\"$comment\",\n\t\"title\",\n\t\"description\",\n\t\"default\",\n\t\"examples\",\n\t\"definitions\",\n\t\"$defs\",\n]);\n\n/**\n * Vérifie si un objet schema ne contient que le mot-clé `not`\n * (plus éventuellement des métadonnées non significatives).\n */\nfunction isPureNotSchema(schema: JSONSchema7): boolean {\n\tconst schemaKeys = keys(schema);\n\treturn schemaKeys.every((k) => k === \"not\" || METADATA_KEYWORDS.has(k));\n}\n\n/** Mots-clés contenant un tableau de sous-schemas */\nconst ARRAY_SCHEMA_KEYWORDS = [\"anyOf\", \"oneOf\", \"allOf\"] as const;\n\n/**\n * Mots-clés contenant un Record<string, JSONSchema7Definition>\n * (chaque valeur est un sous-schema à normaliser récursivement).\n */\nconst PROPERTIES_LIKE_KEYWORDS = [\"properties\", \"patternProperties\"] as const;\n\n// ─── Internal helpers ────────────────────────────────────────────────────────\n\n/**\n * Normalise un `Record<string, JSONSchema7Definition>` en appliquant\n * `normalize` à chaque valeur via `lodash/mapValues`.\n */\nfunction normalizePropertiesMap(\n\tprops: Record<string, JSONSchema7Definition>,\n): Record<string, JSONSchema7Definition> {\n\treturn mapValues(props, (v) => normalize(v as JSONSchema7Definition));\n}\n\n/**\n * Infère le `type` depuis `const` si absent.\n * Retourne le type inféré ou undefined si non applicable.\n */\nfunction inferTypeFromConst(\n\tschema: JSONSchema7,\n): JSONSchema7[\"type\"] | undefined {\n\tif (!has(schema, \"const\") || schema.type !== undefined) return undefined;\n\tconst t = inferType(schema.const);\n\treturn t ? (t as JSONSchema7[\"type\"]) : undefined;\n}\n\n/**\n * Infère le `type` depuis `enum` si absent.\n * Retourne le type inféré (single ou array) ou undefined si non applicable.\n */\nfunction inferTypeFromEnum(\n\tschema: JSONSchema7,\n): JSONSchema7[\"type\"] | undefined {\n\tif (!isArray(schema.enum) || schema.type !== undefined) return undefined;\n\n\tconst types = uniq(compact(map(schema.enum, (v) => inferType(v))));\n\tconst count = size(types);\n\n\tif (count === 1) return first(types) as JSONSchema7[\"type\"];\n\tif (count > 1) return types as JSONSchema7[\"type\"];\n\treturn undefined;\n}\n\n// ─── Normalization ───────────────────────────────────────────────────────────\n\n/**\n * Normalise un schema : infère `type` depuis `const`/`enum`,\n * et normalise récursivement tous les sous-schemas.\n *\n * Récurse dans :\n *   - `properties` et `patternProperties` (Point 2) via `_.mapValues`\n *   - `dependencies` forme schema (Point 3) — les valeurs tableau (forme 1)\n *     sont laissées intactes\n *   - `items` (single ou tuple)\n *   - Mots-clés single-schema (`additionalProperties`, `not`, `if`, etc.)\n *   - Mots-clés array-of-schema (`anyOf`, `oneOf`, `allOf`)\n */\nexport function normalize(def: JSONSchema7Definition): JSONSchema7Definition {\n\tif (typeof def === \"boolean\") return def;\n\n\tlet schema = { ...def };\n\n\t// ── Inférer type depuis const ──\n\tconst typeFromConst = inferTypeFromConst(schema);\n\tif (typeFromConst) {\n\t\tschema.type = typeFromConst;\n\t}\n\n\t// ── Inférer type depuis enum ──\n\tconst typeFromEnum = inferTypeFromEnum(schema);\n\tif (typeFromEnum) {\n\t\tschema.type = typeFromEnum;\n\t}\n\n\t// ── Convertir enum à un seul élément en const ──\n\t// Sémantiquement, { enum: [X] } ≡ { const: X }.\n\t// Cette normalisation garantit que la comparaison structurelle\n\t// (isEqual) ne produit pas de faux négatifs quand un schema utilise\n\t// enum et l'autre utilise const pour la même valeur.\n\tif (\n\t\tisArray(schema.enum) &&\n\t\tsize(schema.enum) === 1 &&\n\t\t!has(schema, \"const\")\n\t) {\n\t\tschema = {\n\t\t\t...(omit(schema, [\"enum\"]) as JSONSchema7),\n\t\t\tconst: schema.enum[0],\n\t\t};\n\t}\n\n\t// ── Strip redundant enum when const is present ──\n\t// Si `const: X` et `enum: [... X ...]` coexistent, `const` est plus\n\t// restrictif → `enum` est redondant. Le merge engine peut produire\n\t// cette combinaison lors de l'intersection const ∩ enum.\n\tif (has(schema, \"const\") && isArray(schema.enum)) {\n\t\tif (some(schema.enum, (v) => isEqual(v, schema.const))) {\n\t\t\tschema = omit(schema, [\"enum\"]) as JSONSchema7;\n\t\t}\n\t}\n\n\t// ── Récurser dans properties & patternProperties (Point 2) ──\n\t// Utilise `_.mapValues` pour transformer chaque sous-schema en une seule passe\n\tfor (const keyword of PROPERTIES_LIKE_KEYWORDS) {\n\t\tconst val = schema[keyword];\n\t\tif (isPlainObject(val)) {\n\t\t\tschema = {\n\t\t\t\t...schema,\n\t\t\t\t[keyword]: normalizePropertiesMap(\n\t\t\t\t\tval as Record<string, JSONSchema7Definition>,\n\t\t\t\t),\n\t\t\t};\n\t\t}\n\t}\n\n\t// ── Récurser dans dependencies (Point 3) ──\n\t// `dependencies` peut contenir :\n\t//   - Forme 1 (property deps) : { foo: [\"bar\", \"baz\"] } → tableau de strings, on skip\n\t//   - Forme 2 (schema deps) : { foo: { required: [...] } } → objet schema, on normalise\n\tif (isPlainObject(schema.dependencies)) {\n\t\tschema = {\n\t\t\t...schema,\n\t\t\tdependencies: mapValues(\n\t\t\t\tschema.dependencies as Record<string, JSONSchema7Definition | string[]>,\n\t\t\t\t(val) => {\n\t\t\t\t\t// Forme 1 : tableau de strings → laisser tel quel\n\t\t\t\t\tif (isArray(val)) return val;\n\t\t\t\t\t// Forme 2 : sous-schema → normaliser récursivement\n\t\t\t\t\tif (isPlainObject(val))\n\t\t\t\t\t\treturn normalize(val as JSONSchema7Definition);\n\t\t\t\t\treturn val;\n\t\t\t\t},\n\t\t\t),\n\t\t};\n\t}\n\n\t// ── Récurser dans items (tuple ou single) ──\n\tif (schema.items) {\n\t\tif (isArray(schema.items)) {\n\t\t\t// Tuple : normaliser chaque élément via `_.map`\n\t\t\tschema = {\n\t\t\t\t...schema,\n\t\t\t\titems: map(schema.items as JSONSchema7Definition[], (it) =>\n\t\t\t\t\tnormalize(it),\n\t\t\t\t),\n\t\t\t};\n\t\t} else if (isPlainObject(schema.items)) {\n\t\t\t// Single items schema\n\t\t\tschema = {\n\t\t\t\t...schema,\n\t\t\t\titems: normalize(schema.items as JSONSchema7Definition),\n\t\t\t};\n\t\t}\n\t}\n\n\t// ── Récurser dans les mots-clés single-schema ──\n\t// Utilise `_.reduce` pour accumuler les transformations en une seule passe\n\tschema = reduce(\n\t\tSINGLE_SCHEMA_KEYWORDS,\n\t\t(acc, key) => {\n\t\t\tconst val = acc[key];\n\t\t\tif (val !== undefined && typeof val !== \"boolean\") {\n\t\t\t\treturn {\n\t\t\t\t\t...acc,\n\t\t\t\t\t[key]: normalize(val as JSONSchema7Definition),\n\t\t\t\t};\n\t\t\t}\n\t\t\treturn acc;\n\t\t},\n\t\tschema,\n\t);\n\n\t// ── Résoudre la double négation not(not(X)) → X ──\n\t// Après la récursion dans les sous-schemas, `schema.not` est normalisé.\n\t// Si `schema.not` est un objet qui ne contient QUE `not` (un « pur not »),\n\t// alors `{ ...rest, not: { not: X } }` ≡ `{ ...rest, ...X }`.\n\t//\n\t// Logique propositionnelle : ¬¬P ≡ P\n\t//\n\t// On ne résout que le cas « pur » (schema.not n'a que `not` comme clé\n\t// significative) pour éviter les faux-positifs dans les cas complexes.\n\tif (\n\t\thas(schema, \"not\") &&\n\t\tisPlainObject(schema.not) &&\n\t\ttypeof schema.not !== \"boolean\"\n\t) {\n\t\tconst notSchema = schema.not as JSONSchema7;\n\t\tif (\n\t\t\thas(notSchema, \"not\") &&\n\t\t\tisPureNotSchema(notSchema) &&\n\t\t\tisPlainObject(notSchema.not) &&\n\t\t\ttypeof notSchema.not !== \"boolean\"\n\t\t) {\n\t\t\t// Extraire le contenu de not.not et le fusionner avec le reste du schema\n\t\t\tconst innerSchema = notSchema.not as JSONSchema7;\n\t\t\t// Retirer `not` du schema courant et spreader le contenu interne\n\t\t\tconst withoutNot = omit(schema, [\"not\"]) as JSONSchema7;\n\t\t\t// Si le schema courant n'avait QUE `not` → remplacer entièrement par le contenu interne\n\t\t\tif (isEmpty(keys(withoutNot))) {\n\t\t\t\tschema = { ...innerSchema };\n\t\t\t} else {\n\t\t\t\t// Le schema a d'autres contraintes → fusionner (allOf implicite)\n\t\t\t\tschema = { ...withoutNot, ...innerSchema };\n\t\t\t}\n\t\t}\n\t}\n\n\t// ── Récurser dans les mots-clés array-of-schema ──\n\t// Utilise `_.reduce` + `_.map` pour transformer chaque branche\n\tschema = reduce(\n\t\tARRAY_SCHEMA_KEYWORDS,\n\t\t(acc, key) => {\n\t\t\tconst val = acc[key];\n\t\t\tif (isArray(val)) {\n\t\t\t\treturn {\n\t\t\t\t\t...acc,\n\t\t\t\t\t[key]: map(val as JSONSchema7Definition[], (s) => normalize(s)),\n\t\t\t\t};\n\t\t\t}\n\t\t\treturn acc;\n\t\t},\n\t\tschema,\n\t);\n\n\treturn schema;\n}\n"
-  ],
-  "mappings": "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",
-  "debugId": "089A2A71B5D4754C64756E2164756E21",
-  "names": []
-}

package/dist/chunk-v5tqyc67.js

@@ -1,5 +0,0 @@
-import X from"lodash/flatMap";import W from"lodash/isArray";import Z from"lodash/isEqual";import J from"lodash/isPlainObject";import N from"lodash/keys";import $ from"lodash/union";var T=new Set(["items","additionalProperties","additionalItems","contains","propertyNames","not","if","then","else"]),U=new Set(["properties","patternProperties","dependencies"]);function L(x,z,B){return T.has(x)&&J(z)&&J(B)}function Y(x,z,B){return U.has(x)&&J(z)&&J(B)}function C(x,z,B){if(typeof x==="boolean"||typeof z==="boolean"){if(x!==z)return[{path:B||"$",type:"changed",expected:x,actual:z}];return[]}let Q=$(N(x),N(z));return X(Q,(F)=>{let G=B?`${B}.${F}`:F,w=x[F],v=z[F];if(w===void 0&&v!==void 0)return[{path:G,type:"added",expected:void 0,actual:v}];if(w!==void 0&&v===void 0)return[{path:G,type:"removed",expected:w,actual:void 0}];if(w!==void 0&&v!==void 0&&!Z(w,v)){if(L(F,w,v))return C(w,v,G);if(Y(F,w,v))return q(w,v,G,F);return[{path:G,type:"changed",expected:w,actual:v}]}return[]})}function q(x,z,B,Q){let F=$(N(x),N(z));return X(F,(G)=>{let w=`${B}.${G}`,v=x[G],H=z[G];if(v===void 0&&H!==void 0)return[{path:w,type:"added",expected:void 0,actual:H}];if(v!==void 0&&H===void 0)return[{path:w,type:"removed",expected:v,actual:void 0}];if(v!==void 0&&H!==void 0){if(Q==="dependencies"&&(W(v)||W(H))){if(!Z(v,H))return[{path:w,type:"changed",expected:v,actual:H}];return[]}return C(v,H,w)}return[]})}
-export{C as k};
-
-//# debugId=02D80E1C0883272664756E2164756E21
-//# sourceMappingURL=chunk-v5tqyc67.js.map

package/dist/chunk-v5tqyc67.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/differ.ts"],
-  "sourcesContent": [
-    "import type { JSONSchema7, JSONSchema7Definition } from \"json-schema\";\nimport flatMap from \"lodash/flatMap\";\nimport isArray from \"lodash/isArray\";\nimport isEqual from \"lodash/isEqual\";\nimport isPlainObject from \"lodash/isPlainObject\";\nimport keys from \"lodash/keys\";\nimport union from \"lodash/union\";\nimport type { SchemaDiff } from \"./types\";\n\n// ─── Schema Differ ───────────────────────────────────────────────────────────\n//\n// Calcul des différences structurelles entre un schema original et son\n// intersection (merged). Utilisé pour produire des diagnostics lisibles\n// quand sub ⊄ sup.\n//\n// Utilise lodash massivement :\n//   - `_.isEqual`       pour la comparaison profonde (remplace JSON.stringify — Point 9)\n//   - `_.union`         pour fusionner les ensembles de clés\n//   - `_.keys`          pour extraire les clés d'un objet\n//   - `_.isPlainObject` pour détecter les sous-schemas récursables\n//   - `_.isArray`       pour distinguer tableaux de strings vs schemas dans `dependencies`\n//   - `_.has`           pour vérifier l'existence d'une clé\n//   - `_.flatMap`       pour aplatir les diffs récursifs\n//   - `_.forEach`       pour itérer sur les clés\n\n// ─── Recursive diff keys ─────────────────────────────────────────────────────\n\n/** Mots-clés dont la valeur est un sous-schema unique (récursion possible) */\nconst RECURSIVE_KEYS: ReadonlySet<string> = new Set([\n\t\"items\",\n\t\"additionalProperties\",\n\t\"additionalItems\",\n\t\"contains\",\n\t\"propertyNames\",\n\t\"not\",\n\t\"if\",\n\t\"then\",\n\t\"else\",\n]);\n\n/**\n * Mots-clés dont la valeur est un `Record<string, JSONSchema7Definition>`\n * — chaque entrée est un sous-schema dans lequel on doit récurser\n * individuellement (properties, patternProperties, dependencies).\n *\n * Point 2 — patternProperties ajouté ici.\n * Point 3 — dependencies ajouté ici (avec gestion spéciale forme tableau).\n */\nconst PROPERTIES_LIKE_KEYS: ReadonlySet<string> = new Set([\n\t\"properties\",\n\t\"patternProperties\",\n\t\"dependencies\",\n]);\n\n// ─── Internal helpers ────────────────────────────────────────────────────────\n\n/**\n * Vérifie si un mot-clé pointe vers un sous-schema unique récursable.\n * Utilise `_.isPlainObject` pour s'assurer que les deux valeurs sont\n * des objets (pas des tableaux, pas null).\n */\nfunction canRecurseInto(\n\tkey: string,\n\torigVal: unknown,\n\tmergedVal: unknown,\n): boolean {\n\treturn (\n\t\tRECURSIVE_KEYS.has(key) &&\n\t\tisPlainObject(origVal) &&\n\t\tisPlainObject(mergedVal)\n\t);\n}\n\n/**\n * Vérifie si un mot-clé pointe vers un objet de propriétés\n * (`properties`, `patternProperties`, `dependencies`).\n *\n * Utilise `_.includes` sur le Set pour une vérification concise.\n */\nfunction isPropertiesLikeObject(\n\tkey: string,\n\torigVal: unknown,\n\tmergedVal: unknown,\n): boolean {\n\treturn (\n\t\tPROPERTIES_LIKE_KEYS.has(key) &&\n\t\tisPlainObject(origVal) &&\n\t\tisPlainObject(mergedVal)\n\t);\n}\n\n// ─── Public API ──────────────────────────────────────────────────────────────\n\n/**\n * Calcule les différences structurelles entre le schema original et le schema\n * mergé (intersection). Récurse dans properties, patternProperties,\n * dependencies et les sous-schemas.\n *\n * @param original  Le schema original (sub)\n * @param merged    Le schema résultant de l'intersection allOf(sub, sup)\n * @param path      Chemin JSON-path courant (vide à la racine)\n *\n * Point 9 — Utilise `_.isEqual` au lieu de `JSON.stringify` pour comparer\n * les valeurs, ce qui élimine la dépendance à l'ordre des clés.\n */\nexport function computeDiffs(\n\toriginal: JSONSchema7Definition,\n\tmerged: JSONSchema7Definition,\n\tpath: string,\n): SchemaDiff[] {\n\t// Cas boolean schemas\n\tif (typeof original === \"boolean\" || typeof merged === \"boolean\") {\n\t\tif (original !== merged) {\n\t\t\treturn [\n\t\t\t\t{\n\t\t\t\t\tpath: path || \"$\",\n\t\t\t\t\ttype: \"changed\",\n\t\t\t\t\texpected: original,\n\t\t\t\t\tactual: merged,\n\t\t\t\t},\n\t\t\t];\n\t\t}\n\t\treturn [];\n\t}\n\n\t// Collecter toutes les clés des deux schemas via `_.union` + `_.keys`\n\tconst allKeys = union(keys(original), keys(merged)) as (keyof JSONSchema7)[];\n\n\treturn flatMap(allKeys, (key): SchemaDiff[] => {\n\t\tconst currentPath = path ? `${path}.${key}` : key;\n\t\tconst origVal = original[key];\n\t\tconst mergedVal = merged[key];\n\n\t\t// Clé ajoutée par le merge\n\t\tif (origVal === undefined && mergedVal !== undefined) {\n\t\t\treturn [\n\t\t\t\t{\n\t\t\t\t\tpath: currentPath,\n\t\t\t\t\ttype: \"added\",\n\t\t\t\t\texpected: undefined,\n\t\t\t\t\tactual: mergedVal,\n\t\t\t\t},\n\t\t\t];\n\t\t}\n\n\t\t// Clé supprimée par le merge\n\t\tif (origVal !== undefined && mergedVal === undefined) {\n\t\t\treturn [\n\t\t\t\t{\n\t\t\t\t\tpath: currentPath,\n\t\t\t\t\ttype: \"removed\",\n\t\t\t\t\texpected: origVal,\n\t\t\t\t\tactual: undefined,\n\t\t\t\t},\n\t\t\t];\n\t\t}\n\n\t\t// Les deux sont définies — vérifier si elles diffèrent\n\t\t// Point 9 : `_.isEqual` remplace `JSON.stringify` pour une comparaison\n\t\t// profonde indépendante de l'ordre des clés\n\t\tif (\n\t\t\torigVal !== undefined &&\n\t\t\tmergedVal !== undefined &&\n\t\t\t!isEqual(origVal, mergedVal)\n\t\t) {\n\t\t\t// Récurser dans les sous-schemas uniques\n\t\t\tif (canRecurseInto(key, origVal, mergedVal)) {\n\t\t\t\treturn computeDiffs(\n\t\t\t\t\torigVal as JSONSchema7Definition,\n\t\t\t\t\tmergedVal as JSONSchema7Definition,\n\t\t\t\t\tcurrentPath,\n\t\t\t\t);\n\t\t\t}\n\n\t\t\t// Récurser dans les objets de propriétés (properties, patternProperties, dependencies)\n\t\t\tif (isPropertiesLikeObject(key, origVal, mergedVal)) {\n\t\t\t\treturn computePropertyDiffs(\n\t\t\t\t\torigVal as Record<string, JSONSchema7Definition>,\n\t\t\t\t\tmergedVal as Record<string, JSONSchema7Definition>,\n\t\t\t\t\tcurrentPath,\n\t\t\t\t\tkey,\n\t\t\t\t);\n\t\t\t}\n\n\t\t\t// Valeur scalaire ou structure non-récursable\n\t\t\treturn [\n\t\t\t\t{\n\t\t\t\t\tpath: currentPath,\n\t\t\t\t\ttype: \"changed\",\n\t\t\t\t\texpected: origVal,\n\t\t\t\t\tactual: mergedVal,\n\t\t\t\t},\n\t\t\t];\n\t\t}\n\n\t\t// Pas de diff pour cette clé\n\t\treturn [];\n\t});\n}\n\n// ─── Property-level diffs ────────────────────────────────────────────────────\n\n/**\n * Calcule les diffs pour un objet de type `properties` / `patternProperties` /\n * `dependencies`, en récursant dans chaque entrée via `computeDiffs`.\n *\n * Point 3 — Pour `dependencies`, gère les deux formes :\n *   - Forme 1 (tableau de strings) : comparaison directe via `_.isEqual`\n *   - Forme 2 (sous-schema) : récursion via `computeDiffs`\n *\n * Utilise `_.union` + `_.keys` pour fusionner les clés des deux côtés,\n * et `_.flatMap` pour produire un tableau aplati de diffs.\n */\nfunction computePropertyDiffs(\n\toriginal: Record<string, JSONSchema7Definition | string[]>,\n\tmerged: Record<string, JSONSchema7Definition | string[]>,\n\tbasePath: string,\n\tparentKey: string,\n): SchemaDiff[] {\n\tconst allPropKeys = union(keys(original), keys(merged));\n\n\treturn flatMap(allPropKeys, (key): SchemaDiff[] => {\n\t\tconst currentPath = `${basePath}.${key}`;\n\t\tconst origVal = original[key];\n\t\tconst mergedVal = merged[key];\n\n\t\tif (origVal === undefined && mergedVal !== undefined) {\n\t\t\treturn [\n\t\t\t\t{\n\t\t\t\t\tpath: currentPath,\n\t\t\t\t\ttype: \"added\",\n\t\t\t\t\texpected: undefined,\n\t\t\t\t\tactual: mergedVal,\n\t\t\t\t},\n\t\t\t];\n\t\t}\n\n\t\tif (origVal !== undefined && mergedVal === undefined) {\n\t\t\treturn [\n\t\t\t\t{\n\t\t\t\t\tpath: currentPath,\n\t\t\t\t\ttype: \"removed\",\n\t\t\t\t\texpected: origVal,\n\t\t\t\t\tactual: undefined,\n\t\t\t\t},\n\t\t\t];\n\t\t}\n\n\t\tif (origVal !== undefined && mergedVal !== undefined) {\n\t\t\t// Pour `dependencies`, les valeurs peuvent être des tableaux de strings (forme 1)\n\t\t\t// On ne récurse que si les deux valeurs sont des objets (sous-schemas)\n\t\t\tif (\n\t\t\t\tparentKey === \"dependencies\" &&\n\t\t\t\t(isArray(origVal) || isArray(mergedVal))\n\t\t\t) {\n\t\t\t\t// Comparaison directe pour les tableaux de strings\n\t\t\t\tif (!isEqual(origVal, mergedVal)) {\n\t\t\t\t\treturn [\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tpath: currentPath,\n\t\t\t\t\t\t\ttype: \"changed\",\n\t\t\t\t\t\t\texpected: origVal,\n\t\t\t\t\t\t\tactual: mergedVal,\n\t\t\t\t\t\t},\n\t\t\t\t\t];\n\t\t\t\t}\n\t\t\t\treturn [];\n\t\t\t}\n\n\t\t\t// Récursion standard pour les sous-schemas\n\t\t\treturn computeDiffs(\n\t\t\t\torigVal as JSONSchema7Definition,\n\t\t\t\tmergedVal as JSONSchema7Definition,\n\t\t\t\tcurrentPath,\n\t\t\t);\n\t\t}\n\n\t\treturn [];\n\t});\n}\n"
-  ],
-  "mappings": "AACA,8BACA,8BACA,8BACA,oCACA,2BACA,4BAsBA,IAAM,EAAsC,IAAI,IAAI,CACnD,QACA,uBACA,kBACA,WACA,gBACA,MACA,KACA,OACA,MACD,CAAC,EAUK,EAA4C,IAAI,IAAI,CACzD,aACA,oBACA,cACD,CAAC,EASD,SAAS,CAAc,CACtB,EACA,EACA,EACU,CACV,OACC,EAAe,IAAI,CAAG,GACtB,EAAc,CAAO,GACrB,EAAc,CAAS,EAUzB,SAAS,CAAsB,CAC9B,EACA,EACA,EACU,CACV,OACC,EAAqB,IAAI,CAAG,GAC5B,EAAc,CAAO,GACrB,EAAc,CAAS,EAkBlB,SAAS,CAAY,CAC3B,EACA,EACA,EACe,CAEf,GAAI,OAAO,IAAa,WAAa,OAAO,IAAW,UAAW,CACjE,GAAI,IAAa,EAChB,MAAO,CACN,CACC,KAAM,GAAQ,IACd,KAAM,UACN,SAAU,EACV,OAAQ,CACT,CACD,EAED,MAAO,CAAC,EAIT,IAAM,EAAU,EAAM,EAAK,CAAQ,EAAG,EAAK,CAAM,CAAC,EAElD,OAAO,EAAQ,EAAS,CAAC,IAAsB,CAC9C,IAAM,EAAc,EAAO,GAAG,KAAQ,IAAQ,EACxC,EAAU,EAAS,GACnB,EAAY,EAAO,GAGzB,GAAI,IAAY,QAAa,IAAc,OAC1C,MAAO,CACN,CACC,KAAM,EACN,KAAM,QACN,SAAU,OACV,OAAQ,CACT,CACD,EAID,GAAI,IAAY,QAAa,IAAc,OAC1C,MAAO,CACN,CACC,KAAM,EACN,KAAM,UACN,SAAU,EACV,OAAQ,MACT,CACD,EAMD,GACC,IAAY,QACZ,IAAc,QACd,CAAC,EAAQ,EAAS,CAAS,EAC1B,CAED,GAAI,EAAe,EAAK,EAAS,CAAS,EACzC,OAAO,EACN,EACA,EACA,CACD,EAID,GAAI,EAAuB,EAAK,EAAS,CAAS,EACjD,OAAO,EACN,EACA,EACA,EACA,CACD,EAID,MAAO,CACN,CACC,KAAM,EACN,KAAM,UACN,SAAU,EACV,OAAQ,CACT,CACD,EAID,MAAO,CAAC,EACR,EAgBF,SAAS,CAAoB,CAC5B,EACA,EACA,EACA,EACe,CACf,IAAM,EAAc,EAAM,EAAK,CAAQ,EAAG,EAAK,CAAM,CAAC,EAEtD,OAAO,EAAQ,EAAa,CAAC,IAAsB,CAClD,IAAM,EAAc,GAAG,KAAY,IAC7B,EAAU,EAAS,GACnB,EAAY,EAAO,GAEzB,GAAI,IAAY,QAAa,IAAc,OAC1C,MAAO,CACN,CACC,KAAM,EACN,KAAM,QACN,SAAU,OACV,OAAQ,CACT,CACD,EAGD,GAAI,IAAY,QAAa,IAAc,OAC1C,MAAO,CACN,CACC,KAAM,EACN,KAAM,UACN,SAAU,EACV,OAAQ,MACT,CACD,EAGD,GAAI,IAAY,QAAa,IAAc,OAAW,CAGrD,GACC,IAAc,iBACb,EAAQ,CAAO,GAAK,EAAQ,CAAS,GACrC,CAED,GAAI,CAAC,EAAQ,EAAS,CAAS,EAC9B,MAAO,CACN,CACC,KAAM,EACN,KAAM,UACN,SAAU,EACV,OAAQ,CACT,CACD,EAED,MAAO,CAAC,EAIT,OAAO,EACN,EACA,EACA,CACD,EAGD,MAAO,CAAC,EACR",
-  "debugId": "02D80E1C0883272664756E2164756E21",
-  "names": []
-}

package/dist/chunk-vcwsxmk4.js

@@ -1,5 +0,0 @@
-import Q from"randexp";var J=200,V=100,W=20;function Y(j){try{let f=new Q(j);return f.max=W,f}catch{return null}}function Z(j){try{return new RegExp(j)}catch{return null}}function $(j,f){let k=new Set,q=0,w=f*3;while(k.size<f&&q<w){let y=j.gen();if(typeof y==="string"&&y.length<=V)k.add(y);q++}return k}function z(j,f,k=J){if(j===f)return!0;let q=Z(f);if(q===null)return null;let w=Y(j);if(w===null)return null;let y=$(w,k);if(y.size===0)return null;for(let K of y)if(!q.test(K))return!1;return!0}function H(j,f,k=J){if(j===f)return!0;let q=z(j,f,k);if(q===null)return null;if(q===!1)return!1;let w=z(f,j,k);if(w===null)return null;return w}function F(j){let f=j.trim();if(f==="")return!0;return new Set([".*",".+","^.*$","^.+$","^.*",".*$","^.+",".+$","(?:.*)","(?:.+)"]).has(f)}
-export{z as g,H as h,F as i};
-
-//# debugId=48D958DFBEBC91AF64756E2164756E21
-//# sourceMappingURL=chunk-vcwsxmk4.js.map

package/dist/chunk-vcwsxmk4.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/pattern-subset.ts"],
-  "sourcesContent": [
-    "import RandExp from \"randexp\";\n\n// ─── Pattern Subset Checker ──────────────────────────────────────────────────\n//\n// Vérifie si un pattern regex est un sous-ensemble d'un autre pattern regex\n// via une approche par échantillonnage (sampling).\n//\n// Principe :\n//   L(A) ⊆ L(B)  ⟺  ∀s ∈ L(A), s ∈ L(B)\n//\n// On ne peut pas prouver ça formellement pour des regex ECMA-262 arbitraires\n// (le problème est PSPACE-complet pour les regex pures, et indécidable avec\n// les extensions comme les backreferences).\n//\n// Approche pragmatique :\n//   1. Générer N strings aléatoires matchant le pattern sub (via `randexp`)\n//   2. Vérifier que CHAQUE string matche aussi le pattern sup\n//   3. Si toutes matchent → retourner `true` (confiance haute)\n//   4. Si au moins une ne matche pas → retourner `false` (certain)\n//   5. Si la génération échoue → retourner `null` (indéterminé)\n//\n// Limites :\n//   - Faux positifs possibles (mais très improbables avec N suffisant)\n//   - Ne gère pas les regex avec backreferences complexes\n//   - `randexp` peut générer des strings biaisées (pas uniformément distribuées)\n//\n// Pour mitiger les faux positifs, on utilise :\n//   - Un nombre d'échantillons élevé (200 par défaut)\n//   - Plusieurs seeds pour diversifier la génération\n//   - Un fallback `null` en cas de doute\n\n// ─── Configuration ───────────────────────────────────────────────────────────\n\n/** Nombre d'échantillons générés par défaut */\nconst DEFAULT_SAMPLE_COUNT = 200;\n\n/** Longueur maximale des strings générées par randexp */\nconst MAX_GENERATED_LENGTH = 100;\n\n/** Nombre maximal de répétitions pour les quantificateurs unbounded (*, +, {n,}) */\nconst MAX_REPETITION = 20;\n\n// ─── Internal helpers ────────────────────────────────────────────────────────\n\n/**\n * Crée un générateur RandExp configuré pour un pattern donné.\n *\n * @param pattern  Le pattern regex source\n * @returns        L'instance RandExp configurée, ou null si le pattern est invalide\n */\nfunction createGenerator(pattern: string): RandExp | null {\n\ttry {\n\t\tconst randexp = new RandExp(pattern);\n\t\trandexp.max = MAX_REPETITION;\n\t\treturn randexp;\n\t} catch {\n\t\treturn null;\n\t}\n}\n\n/**\n * Compile un pattern en RegExp avec gestion d'erreur.\n *\n * @param pattern  Le pattern regex à compiler\n * @returns        L'objet RegExp compilé, ou null si invalide\n */\nfunction compileRegex(pattern: string): RegExp | null {\n\ttry {\n\t\treturn new RegExp(pattern);\n\t} catch {\n\t\treturn null;\n\t}\n}\n\n/**\n * Génère un ensemble diversifié de strings matchant un pattern.\n *\n * Utilise plusieurs passes avec des seeds différentes pour maximiser\n * la diversité des échantillons et réduire le risque de faux positifs.\n *\n * @param generator   Le générateur RandExp\n * @param count       Le nombre total d'échantillons à produire\n * @returns           Un Set de strings uniques générées\n */\nfunction generateDiverseSamples(\n\tgenerator: RandExp,\n\tcount: number,\n): Set<string> {\n\tconst samples = new Set<string>();\n\tlet attempts = 0;\n\tconst maxAttempts = count * 3; // Éviter les boucles infinies\n\n\twhile (samples.size < count && attempts < maxAttempts) {\n\t\tconst sample = generator.gen();\n\t\tif (typeof sample === \"string\" && sample.length <= MAX_GENERATED_LENGTH) {\n\t\t\tsamples.add(sample);\n\t\t}\n\t\tattempts++;\n\t}\n\n\treturn samples;\n}\n\n// ─── Public API ──────────────────────────────────────────────────────────────\n\n/**\n * Vérifie si le langage du pattern `sub` est un sous-ensemble du langage\n * du pattern `sup` via échantillonnage.\n *\n * `sub ⊆ sup` signifie : toute string matchant `sub` matche aussi `sup`.\n *\n * Contrat ternaire :\n *   - `true`  → toutes les strings échantillonnées de sub matchent sup\n *               (confiance haute, pas une preuve formelle)\n *   - `false` → au moins une string de sub ne matche PAS sup\n *               (certain — c'est un contre-exemple concret)\n *   - `null`  → impossible de déterminer (pattern invalide, génération échouée)\n *\n * @param subPattern    Le pattern regex du schema sub\n * @param supPattern    Le pattern regex du schema sup\n * @param sampleCount   Nombre d'échantillons (défaut: 200)\n * @returns             `true`, `false`, ou `null`\n *\n * @example\n * ```ts\n * isPatternSubset(\"^[a-z]{3}$\", \"^[a-z]+$\");      // true  — 3 lettres ⊆ 1+ lettres\n * isPatternSubset(\"^[a-z]+$\", \"^[0-9]+$\");         // false — lettres ⊄ chiffres\n * isPatternSubset(\"^[a-z]+$\", \"^[a-z]{3}$\");       // false — \"ab\" matche sub mais pas sup\n * isPatternSubset(\"invalid[\", \"^[a-z]+$\");          // null  — pattern invalide\n * ```\n */\nexport function isPatternSubset(\n\tsubPattern: string,\n\tsupPattern: string,\n\tsampleCount: number = DEFAULT_SAMPLE_COUNT,\n): boolean | null {\n\t// ── Identité : même pattern → toujours subset ──\n\tif (subPattern === supPattern) return true;\n\n\t// ── Compiler le pattern sup ──\n\tconst supRegex = compileRegex(supPattern);\n\tif (supRegex === null) return null;\n\n\t// ── Créer le générateur pour sub ──\n\tconst generator = createGenerator(subPattern);\n\tif (generator === null) return null;\n\n\t// ── Générer les échantillons ──\n\tconst samples = generateDiverseSamples(generator, sampleCount);\n\n\t// Si aucun échantillon n'a pu être généré → indéterminé\n\tif (samples.size === 0) return null;\n\n\t// ── Vérifier chaque échantillon contre sup ──\n\tfor (const sample of samples) {\n\t\tif (!supRegex.test(sample)) {\n\t\t\t// Contre-exemple trouvé → sub ⊄ sup (certain)\n\t\t\treturn false;\n\t\t}\n\t}\n\n\t// Tous les échantillons matchent → sub ⊆ sup (confiance haute)\n\treturn true;\n}\n\n/**\n * Vérifie si deux patterns sont équivalents (acceptent le même langage)\n * via échantillonnage bidirectionnel.\n *\n * `A ≡ B` signifie : `A ⊆ B` ET `B ⊆ A`.\n *\n * @param patternA     Premier pattern regex\n * @param patternB     Second pattern regex\n * @param sampleCount  Nombre d'échantillons par direction (défaut: 200)\n * @returns            `true`, `false`, ou `null`\n */\nexport function arePatternsEquivalent(\n\tpatternA: string,\n\tpatternB: string,\n\tsampleCount: number = DEFAULT_SAMPLE_COUNT,\n): boolean | null {\n\tif (patternA === patternB) return true;\n\n\tconst aSubB = isPatternSubset(patternA, patternB, sampleCount);\n\tif (aSubB === null) return null;\n\tif (aSubB === false) return false;\n\n\tconst bSubA = isPatternSubset(patternB, patternA, sampleCount);\n\tif (bSubA === null) return null;\n\n\treturn bSubA;\n}\n\n/**\n * Vérifie si un pattern est \"trivially universal\" — i.e., il matche\n * toute string (ou presque). Utile pour détecter les patterns qui\n * n'ajoutent aucune contrainte réelle.\n *\n * Patterns détectés comme universels :\n *   - `.*`\n *   - `.+` (matche tout sauf la string vide)\n *   - `^.*$`\n *   - `^.+$`\n *   - Patterns vides ou whitespace\n *\n * @param pattern  Le pattern à vérifier\n * @returns        `true` si le pattern est trivial/universel\n */\nexport function isTrivialPattern(pattern: string): boolean {\n\tconst trimmed = pattern.trim();\n\tif (trimmed === \"\") return true;\n\n\t// Patterns universels courants (avec ou sans anchors)\n\tconst universalPatterns = new Set([\n\t\t\".*\",\n\t\t\".+\",\n\t\t\"^.*$\",\n\t\t\"^.+$\",\n\t\t\"^.*\",\n\t\t\".*$\",\n\t\t\"^.+\",\n\t\t\".+$\",\n\t\t\"(?:.*)\",\n\t\t\"(?:.+)\",\n\t]);\n\n\treturn universalPatterns.has(trimmed);\n}\n"
-  ],
-  "mappings": "AAAA,uBAkCA,IAAM,EAAuB,IAGvB,EAAuB,IAGvB,EAAiB,GAUvB,SAAS,CAAe,CAAC,EAAiC,CACzD,GAAI,CACH,IAAM,EAAU,IAAI,EAAQ,CAAO,EAEnC,OADA,EAAQ,IAAM,EACP,EACN,KAAM,CACP,OAAO,MAUT,SAAS,CAAY,CAAC,EAAgC,CACrD,GAAI,CACH,OAAO,IAAI,OAAO,CAAO,EACxB,KAAM,CACP,OAAO,MAcT,SAAS,CAAsB,CAC9B,EACA,EACc,CACd,IAAM,EAAU,IAAI,IAChB,EAAW,EACT,EAAc,EAAQ,EAE5B,MAAO,EAAQ,KAAO,GAAS,EAAW,EAAa,CACtD,IAAM,EAAS,EAAU,IAAI,EAC7B,GAAI,OAAO,IAAW,UAAY,EAAO,QAAU,EAClD,EAAQ,IAAI,CAAM,EAEnB,IAGD,OAAO,EA+BD,SAAS,CAAe,CAC9B,EACA,EACA,EAAsB,EACL,CAEjB,GAAI,IAAe,EAAY,MAAO,GAGtC,IAAM,EAAW,EAAa,CAAU,EACxC,GAAI,IAAa,KAAM,OAAO,KAG9B,IAAM,EAAY,EAAgB,CAAU,EAC5C,GAAI,IAAc,KAAM,OAAO,KAG/B,IAAM,EAAU,EAAuB,EAAW,CAAW,EAG7D,GAAI,EAAQ,OAAS,EAAG,OAAO,KAG/B,QAAW,KAAU,EACpB,GAAI,CAAC,EAAS,KAAK,CAAM,EAExB,MAAO,GAKT,MAAO,GAcD,SAAS,CAAqB,CACpC,EACA,EACA,EAAsB,EACL,CACjB,GAAI,IAAa,EAAU,MAAO,GAElC,IAAM,EAAQ,EAAgB,EAAU,EAAU,CAAW,EAC7D,GAAI,IAAU,KAAM,OAAO,KAC3B,GAAI,IAAU,GAAO,MAAO,GAE5B,IAAM,EAAQ,EAAgB,EAAU,EAAU,CAAW,EAC7D,GAAI,IAAU,KAAM,OAAO,KAE3B,OAAO,EAkBD,SAAS,CAAgB,CAAC,EAA0B,CAC1D,IAAM,EAAU,EAAQ,KAAK,EAC7B,GAAI,IAAY,GAAI,MAAO,GAgB3B,OAb0B,IAAI,IAAI,CACjC,KACA,KACA,OACA,OACA,MACA,MACA,MACA,MACA,SACA,QACD,CAAC,EAEwB,IAAI,CAAO",
-  "debugId": "48D958DFBEBC91AF64756E2164756E21",
-  "names": []
-}

package/dist/chunk-w7qcey06.js

@@ -1,5 +0,0 @@
-import{q as x}from"./chunk-g0pfcnm5.js";import{s as C}from"./chunk-pw49kj6f.js";import M from"lodash/every";import D from"lodash/filter";import _ from"lodash/forEach";import K from"lodash/get";import R from"lodash/has";import U from"lodash/isArray";import I from"lodash/isEmpty";import T from"lodash/isEqual";import X from"lodash/isPlainObject";import B from"lodash/keys";import O from"lodash/mapValues";import V from"lodash/omit";import g from"lodash/reduce";import S from"lodash/size";import q from"lodash/some";import j from"lodash/union";var b=new Set(["required","properties","dependencies"]),f=new Set(["additionalProperties","items","contains","propertyNames","not"]),k=new Set(["minimum","exclusiveMinimum","minLength","minItems","minProperties"]),u=new Set(["maximum","exclusiveMaximum","maxLength","maxItems","maxProperties"]);function m(w,W){if(W===void 0)return!0;let G=U(W)?W:[W],Z=C(w);return q(G,(J)=>J===Z||J==="number"&&Z==="integer")}function y(w,W){if(W.minimum!==void 0&&!(w>=W.minimum))return!1;if(W.maximum!==void 0&&!(w<=W.maximum))return!1;if(W.exclusiveMinimum!==void 0&&!(w>W.exclusiveMinimum))return!1;if(W.exclusiveMaximum!==void 0&&!(w<W.exclusiveMaximum))return!1;if(W.multipleOf!==void 0&&w%W.multipleOf!==0)return!1;return!0}function h(w,W){if(W.minLength!==void 0&&!(w.length>=W.minLength))return!1;if(W.maxLength!==void 0&&!(w.length<=W.maxLength))return!1;if(W.pattern!==void 0&&!new RegExp(W.pattern).test(w))return!1;return!0}function v(w,W){if(W.minItems!==void 0&&!(w.length>=W.minItems))return!1;if(W.maxItems!==void 0&&!(w.length<=W.maxItems))return!1;if(W.uniqueItems===!0){if(!M(w,(Z,J)=>M(w.slice(J+1),(Q)=>!T(Z,Q))))return!1}return!0}function Y(w,W){if(X(w.properties)){if(!M(B(w.properties),(Z)=>{let J=w.properties?.[Z];if(typeof J==="boolean")return!0;let Q=J,$=K(W,Z);if($===void 0)return!0;if(R(Q,"const")){if(!T($,Q.const))return!1}if(R(Q,"enum")){if(!q(Q.enum,(F)=>T(F,$)))return!1}if(R(Q,"type")&&$!==void 0){if(!m($,Q.type))return!1}if(typeof $==="number"){if(!y($,Q))return!1}if(typeof $==="string"){if(!h($,Q))return!1}if(U($)){if(!v($,Q))return!1}if(Q.format!==void 0&&typeof $==="string"){if(x($,Q.format)===!1)return!1}if(X(Q.properties)||U(Q.required)){if(X($)){if(!Y(Q,$))return!1}}return!0}))return!1}if(U(w.required)){if(!M(w.required,(Z)=>R(W,Z)))return!1}if(U(w.allOf)){if(!M(w.allOf,(Z)=>{if(typeof Z==="boolean")return Z;return Y(Z,W)}))return!1}if(U(w.anyOf)){if(!q(w.anyOf,(Z)=>{if(typeof Z==="boolean")return Z;return Y(Z,W)}))return!1}if(U(w.oneOf)){let G=D(w.oneOf,(Z)=>{if(typeof Z==="boolean")return Z;return Y(Z,W)});if(S(G)!==1)return!1}if(R(w,"not")&&X(w.not)&&typeof w.not!=="boolean"){if(Y(w.not,W))return!1}return!0}var t=["const","enum","minimum","maximum","exclusiveMinimum","exclusiveMaximum","pattern","minLength","maxLength","multipleOf","minItems","maxItems","format"];function E(w,W,G){if(!X(w.properties))return;_(w.properties,(Z,J)=>{if(typeof Z==="boolean")return;let Q=Z;if(q(t,(F)=>R(Q,F))&&R(W,J))G[J]=W[J]})}function P(w,W,G){if(typeof W==="boolean")return;let Z=W;if(U(Z.required))w.required=j(w.required??[],Z.required);if(X(Z.properties))w.properties={...w.properties??{},...O(Z.properties??{},(J,Q)=>{let $=K(w.properties,Q);if($!==void 0&&typeof $!=="boolean"&&typeof J!=="boolean")return G.merge($,J)??J;return J})};if(X(Z.dependencies)){let J=w.dependencies??{},Q=Z.dependencies;w.dependencies=g(B(Q),($,F)=>{let H=Q[F];if(H===void 0)return $;let L=$[F];if(L===void 0)$[F]=H;else if(U(L)&&U(H))$[F]=j(L,H);else if(X(L)&&X(H)){let z=G.merge(L,H);$[F]=z??H}else $[F]=H;return $},{...J})}_(B(Z),(J)=>{if(b.has(J))return;let Q=Z[J],$=w[J];if($===void 0){w[J]=Q;return}if(T($,Q))return;if(f.has(J)){let z=G.merge($,Q);if(z!==null)w[J]=z;else w[J]=Q;return}if(k.has(J)){if(typeof $==="number"&&typeof Q==="number")w[J]=Math.max($,Q);else w[J]=Q;return}if(u.has(J)){if(typeof $==="number"&&typeof Q==="number")w[J]=Math.min($,Q);else w[J]=Q;return}if(J==="uniqueItems"){w[J]=$===!0||Q===!0;return}if(J==="pattern"||J==="format"){w[J]=Q;return}let F={[J]:$},H={[J]:Q},L=G.merge(F,H);if(L&&typeof L!=="boolean"&&R(L,J))w[J]=L[J];else w[J]=Q})}function c(w,W,G){let Z={...w},J=null,Q={};if(Z=d(Z,W,G,Q),Z.if!==void 0){let $=Z.if,F=Y($,W);E($,W,Q);let H=F?Z.then:Z.else;if(J=F?"then":"else",H)P(Z,H,G);delete Z.if,delete Z.then,delete Z.else}return Z=p(Z,W,G,Q),{resolved:Z,branch:J,discriminant:Q}}function d(w,W,G,Z){if(!U(w.allOf))return w;let J=[];if(_(w.allOf,(Q)=>{if(typeof Q==="boolean"){J.push(Q);return}let $=Q;if($.if===void 0){J.push(Q);return}let F=$.if,H=Y(F,W);E(F,W,Z);let L=H?$.then:$.else;if(L)P(w,L,G);let z=V($,["if","then","else"]);if(!I(z))J.push(z)}),w={...w},I(J))delete w.allOf;else w.allOf=J;return w}function p(w,W,G,Z){if(!X(w.properties))return w;let J=O(w.properties??{},(Q,$)=>{if(typeof Q==="boolean")return Q;let F=Q;if(!(F.if!==void 0||U(F.allOf)&&q(F.allOf,(N)=>typeof N!=="boolean"&&R(N,"if"))))return Q;let L=X(W[$])?W[$]:{},z=c(F,L,G);return _(z.discriminant,(N,A)=>{Z[`${$}.${A}`]=N}),z.resolved});return{...w,properties:J}}
-export{c as j};
-
-//# debugId=F16CECF34B4F471564756E2164756E21
-//# sourceMappingURL=chunk-w7qcey06.js.map

package/dist/chunk-w7qcey06.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/condition-resolver.ts"],
-  "sourcesContent": [
-    "import type { JSONSchema7, JSONSchema7Definition } from \"json-schema\";\nimport every from \"lodash/every\";\nimport filter from \"lodash/filter\";\nimport forEach from \"lodash/forEach\";\nimport get from \"lodash/get\";\n\nimport has from \"lodash/has\";\nimport isArray from \"lodash/isArray\";\nimport isEmpty from \"lodash/isEmpty\";\nimport isEqual from \"lodash/isEqual\";\nimport isPlainObject from \"lodash/isPlainObject\";\nimport keys from \"lodash/keys\";\nimport mapValues from \"lodash/mapValues\";\nimport omit from \"lodash/omit\";\nimport reduce from \"lodash/reduce\";\nimport size from \"lodash/size\";\nimport some from \"lodash/some\";\nimport union from \"lodash/union\";\nimport { validateFormat } from \"./format-validator\";\nimport type { MergeEngine } from \"./merge-engine\";\nimport { inferType } from \"./normalizer\";\nimport type { ResolvedConditionResult } from \"./types\";\n\n// ─── Condition Resolver ──────────────────────────────────────────────────────\n//\n// Résout les `if/then/else` d'un schema en évaluant le `if` contre\n// des données partielles (discriminants).\n//\n// Stratégie :\n//  1. Évaluer si les données partielles satisfont le `if`\n//  2. Merger la branche applicable (`then` ou `else`) dans le schema de base\n//  3. Supprimer les mots-clés `if/then/else` du résultat\n//  4. Récurser dans les `properties` pour résoudre les conditions imbriquées\n//\n// L'évaluation du `if` (via `evaluateCondition`) gère :\n//   - `properties` avec `const`, `enum`, `type`, contraintes numériques/string/array\n//   - `required` (vérification de présence des clés)\n//   - `allOf` (toutes les entrées doivent matcher — récursion) [2.1]\n//   - `anyOf` (au moins une entrée doit matcher — récursion) [2.2]\n//   - `oneOf` (exactement une entrée doit matcher — récursion) [2.3]\n//   - `not` (inversion du résultat — récursion) [2.4]\n//   - Propriétés imbriquées (nested objects — récursion) [2.5]\n//   - `format` via `validateFormat` de `format-validator.ts` [2.6]\n//\n// Utilise lodash massivement :\n//   - `_.has` / `_.get`         pour l'accès sûr aux propriétés\n//   - `_.every` / `_.some`      pour les prédicats sur les collections\n//   - `_.union` / `_.uniq`      pour la fusion de tableaux (required, deps)\n//   - `_.isArray` / `_.isPlainObject` pour le typage des valeurs\n//   - `_.mapValues`             pour transformer les propriétés\n//   - `_.omit` / `_.pick`       pour sélectionner/exclure des clés\n//   - `_.keys` / `_.forEach`    pour l'itération\n//   - `_.reduce`                pour accumuler les résultats\n//   - `_.isEqual`               pour la comparaison profonde\n//   - `_.size` / `_.filter`     pour le comptage (oneOf)\n\n// ─── Keywords classification ─────────────────────────────────────────────────\n\n/** Mots-clés qui ne doivent pas être traités par la boucle générique de mergeBranchInto */\nconst SPECIAL_MERGE_KEYS = new Set([\"required\", \"properties\", \"dependencies\"]);\n\n/** Mots-clés contenant un sous-schema unique (mergeable via engine.merge) */\nconst SUB_SCHEMA_KEYS = new Set([\n\t\"additionalProperties\",\n\t\"items\",\n\t\"contains\",\n\t\"propertyNames\",\n\t\"not\",\n]);\n\n/** Mots-clés numériques de type \"minimum\" (prendre le max pour être plus restrictif) */\nconst MIN_KEYS = new Set([\n\t\"minimum\",\n\t\"exclusiveMinimum\",\n\t\"minLength\",\n\t\"minItems\",\n\t\"minProperties\",\n]);\n\n/** Mots-clés numériques de type \"maximum\" (prendre le min pour être plus restrictif) */\nconst MAX_KEYS = new Set([\n\t\"maximum\",\n\t\"exclusiveMaximum\",\n\t\"maxLength\",\n\t\"maxItems\",\n\t\"maxProperties\",\n]);\n\n// ─── Condition evaluation (internal) ─────────────────────────────────────────\n\n/**\n * Vérifie si `value` correspond à un type JSON Schema.\n */\nfunction matchesType(value: unknown, type: JSONSchema7[\"type\"]): boolean {\n\tif (type === undefined) return true;\n\n\tconst types = isArray(type) ? type : [type];\n\tconst actualType = inferType(value);\n\n\treturn some(\n\t\ttypes,\n\t\t(t) => t === actualType || (t === \"number\" && actualType === \"integer\"),\n\t);\n}\n\n/**\n * Évalue une contrainte numérique sur une valeur.\n * Point 5 — Enrichissement de evaluateCondition.\n */\nfunction evaluateNumericConstraints(value: number, prop: JSONSchema7): boolean {\n\tif (prop.minimum !== undefined && !(value >= prop.minimum)) return false;\n\tif (prop.maximum !== undefined && !(value <= prop.maximum)) return false;\n\tif (\n\t\tprop.exclusiveMinimum !== undefined &&\n\t\t!(value > (prop.exclusiveMinimum as number))\n\t)\n\t\treturn false;\n\tif (\n\t\tprop.exclusiveMaximum !== undefined &&\n\t\t!(value < (prop.exclusiveMaximum as number))\n\t)\n\t\treturn false;\n\tif (prop.multipleOf !== undefined && value % prop.multipleOf !== 0)\n\t\treturn false;\n\treturn true;\n}\n\n/**\n * Évalue une contrainte string sur une valeur.\n * Point 5 — Enrichissement de evaluateCondition.\n */\nfunction evaluateStringConstraints(value: string, prop: JSONSchema7): boolean {\n\tif (prop.minLength !== undefined && !(value.length >= prop.minLength))\n\t\treturn false;\n\tif (prop.maxLength !== undefined && !(value.length <= prop.maxLength))\n\t\treturn false;\n\tif (prop.pattern !== undefined && !new RegExp(prop.pattern).test(value))\n\t\treturn false;\n\treturn true;\n}\n\n/**\n * Évalue une contrainte array sur une valeur.\n * Point 5 — Enrichissement de evaluateCondition.\n */\nfunction evaluateArrayConstraints(\n\tvalue: unknown[],\n\tprop: JSONSchema7,\n): boolean {\n\tif (prop.minItems !== undefined && !(value.length >= prop.minItems))\n\t\treturn false;\n\tif (prop.maxItems !== undefined && !(value.length <= prop.maxItems))\n\t\treturn false;\n\tif (prop.uniqueItems === true) {\n\t\t// Vérifier l'unicité via lodash isEqual pour les éléments non-primitifs\n\t\tconst isUnique = every(value, (item, idx) =>\n\t\t\tevery(value.slice(idx + 1), (other) => !isEqual(item, other)),\n\t\t);\n\t\tif (!isUnique) return false;\n\t}\n\treturn true;\n}\n\n/**\n * Évalue si des données partielles satisfont un `if` schema.\n *\n * Stratégie pragmatique (pas un validateur complet) :\n *  - Vérifie les `properties` avec `const`, `enum`, `type`\n *  - Point 5 : Vérifie aussi minimum/maximum, minLength/maxLength,\n *    pattern, multipleOf, minItems/maxItems, uniqueItems\n *  - Vérifie les `required`\n *  - 2.1 : `allOf` → toutes les entrées doivent matcher (récursion)\n *  - 2.2 : `anyOf` → au moins une entrée doit matcher (récursion)\n *  - 2.3 : `oneOf` → exactement une entrée doit matcher (récursion)\n *  - 2.4 : `not` → inversion du résultat (récursion)\n *  - 2.5 : Propriétés imbriquées → récursion sur les sous-objets\n *  - 2.6 : `format` → validation via `validateFormat`\n *\n * Utilise `_.forEach` / `_.every` / `_.has` pour une itération idiomatique.\n */\nfunction evaluateCondition(\n\tifSchema: JSONSchema7,\n\tdata: Record<string, unknown>,\n): boolean {\n\tif (isPlainObject(ifSchema.properties)) {\n\t\tconst propsOk = every(keys(ifSchema.properties), (key) => {\n\t\t\tconst propDef = ifSchema.properties?.[key];\n\t\t\tif (typeof propDef === \"boolean\") return true;\n\t\t\tconst prop = propDef as JSONSchema7;\n\t\t\tconst value = get(data, key);\n\n\t\t\t// ── Propriété absente → skip ──\n\t\t\t// Selon la spec JSON Schema Draft-07, le keyword `properties` ne valide\n\t\t\t// une propriété que si elle est **présente** dans l'instance.\n\t\t\t// C'est le keyword `required` qui gère la présence obligatoire.\n\t\t\tif (value === undefined) return true;\n\n\t\t\t// ── const ──\n\t\t\tif (has(prop, \"const\")) {\n\t\t\t\tif (!isEqual(value, prop.const)) return false;\n\t\t\t}\n\n\t\t\t// ── enum ──\n\t\t\tif (has(prop, \"enum\")) {\n\t\t\t\tif (!some(prop.enum, (v) => isEqual(v, value))) return false;\n\t\t\t}\n\n\t\t\t// ── type ──\n\t\t\tif (has(prop, \"type\") && value !== undefined) {\n\t\t\t\tif (!matchesType(value, prop.type)) return false;\n\t\t\t}\n\n\t\t\t// ── Point 5 : Contraintes numériques/string/array ──\n\t\t\t// Quand `value` est `undefined`, aucun de ces blocs ne s'exécute\n\t\t\t// (`typeof undefined` vaut `\"undefined\"`, pas `\"number\"` ni `\"string\"`,\n\t\t\t// et `isArray(undefined)` retourne `false`).\n\t\t\t// C'est le comportement voulu : on ne peut pas évaluer une contrainte\n\t\t\t// sur une donnée absente → on skip, cohérent avec la logique pragmatique.\n\t\t\tif (typeof value === \"number\") {\n\t\t\t\tif (!evaluateNumericConstraints(value, prop)) return false;\n\t\t\t}\n\n\t\t\tif (typeof value === \"string\") {\n\t\t\t\tif (!evaluateStringConstraints(value, prop)) return false;\n\t\t\t}\n\n\t\t\tif (isArray(value)) {\n\t\t\t\tif (!evaluateArrayConstraints(value as unknown[], prop)) return false;\n\t\t\t}\n\n\t\t\t// ── 2.6 — format ──\n\t\t\t// Valide la valeur contre le format via class-validator.\n\t\t\t// Le format ne s'applique qu'aux strings en Draft-07.\n\t\t\t// Si le format est inconnu → skip (retourne null → on continue).\n\t\t\tif (prop.format !== undefined && typeof value === \"string\") {\n\t\t\t\tconst formatResult = validateFormat(value, prop.format);\n\t\t\t\tif (formatResult === false) return false;\n\t\t\t\t// null (format inconnu) → skip, cohérent avec l'approche pragmatique\n\t\t\t}\n\n\t\t\t// ── 2.5 — Propriétés imbriquées (nested objects) ──\n\t\t\t// Si la propriété elle-même a des `properties` ou un `required`,\n\t\t\t// et que la valeur dans data est un objet, récurser dans evaluateCondition\n\t\t\t// en passant la sous-donnée comme nouveau `data`.\n\t\t\t// Si data[key] n'est pas un objet, on skip (retourne true pour cette prop,\n\t\t\t// cohérent avec \"absence = pas de contrainte\").\n\t\t\tif (isPlainObject(prop.properties) || isArray(prop.required)) {\n\t\t\t\tif (isPlainObject(value)) {\n\t\t\t\t\tif (!evaluateCondition(prop, value as Record<string, unknown>)) {\n\t\t\t\t\t\treturn false;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t// value n'est pas un objet → skip, on ne peut pas évaluer les sous-props\n\t\t\t}\n\n\t\t\treturn true;\n\t\t});\n\t\tif (!propsOk) return false;\n\t}\n\n\t// ── required ──\n\tif (isArray(ifSchema.required)) {\n\t\tconst allRequired = every(ifSchema.required, (key) => has(data, key));\n\t\tif (!allRequired) return false;\n\t}\n\n\t// ── 2.1 — allOf ──\n\t// Toutes les entrées du allOf doivent matcher (évaluation récursive).\n\tif (isArray(ifSchema.allOf)) {\n\t\tconst allMatch = every(ifSchema.allOf, (entry) => {\n\t\t\tif (typeof entry === \"boolean\") return entry;\n\t\t\treturn evaluateCondition(entry as JSONSchema7, data);\n\t\t});\n\t\tif (!allMatch) return false;\n\t}\n\n\t// ── 2.2 — anyOf ──\n\t// Au moins une entrée du anyOf doit matcher (évaluation récursive).\n\tif (isArray(ifSchema.anyOf)) {\n\t\tconst anyMatch = some(ifSchema.anyOf, (entry) => {\n\t\t\tif (typeof entry === \"boolean\") return entry;\n\t\t\treturn evaluateCondition(entry as JSONSchema7, data);\n\t\t});\n\t\tif (!anyMatch) return false;\n\t}\n\n\t// ── 2.3 — oneOf ──\n\t// Exactement une entrée du oneOf doit matcher (évaluation récursive).\n\tif (isArray(ifSchema.oneOf)) {\n\t\tconst matchingBranches = filter(ifSchema.oneOf, (entry) => {\n\t\t\tif (typeof entry === \"boolean\") return entry;\n\t\t\treturn evaluateCondition(entry as JSONSchema7, data);\n\t\t});\n\t\tif (size(matchingBranches) !== 1) return false;\n\t}\n\n\t// ── 2.4 — not ──\n\t// Inverser le résultat de l'évaluation du contenu du `not`.\n\tif (\n\t\thas(ifSchema, \"not\") &&\n\t\tisPlainObject(ifSchema.not) &&\n\t\ttypeof ifSchema.not !== \"boolean\"\n\t) {\n\t\tconst notResult = evaluateCondition(ifSchema.not as JSONSchema7, data);\n\t\tif (notResult) return false; // Le not matche → la condition not ne matche pas\n\t}\n\n\treturn true;\n}\n\n// ─── Discriminant extraction ─────────────────────────────────────────────────\n\n/**\n * Mots-clés qui indiquent qu'une propriété est un discriminant\n * (sa valeur dans les données est utilisée pour la résolution).\n *\n * Point 5 — Étendu avec les contraintes numériques/string/pattern.\n */\nconst DISCRIMINANT_INDICATORS = [\n\t\"const\",\n\t\"enum\",\n\t\"minimum\",\n\t\"maximum\",\n\t\"exclusiveMinimum\",\n\t\"exclusiveMaximum\",\n\t\"pattern\",\n\t\"minLength\",\n\t\"maxLength\",\n\t\"multipleOf\",\n\t\"minItems\",\n\t\"maxItems\",\n\t\"format\",\n] as const;\n\n/**\n * Extrait les valeurs discriminantes utilisées dans un `if` schema\n * depuis les données partielles.\n *\n * Point 5 — Collecte aussi les discriminants pour les nouvelles contraintes\n * (minimum, maximum, pattern, etc.).\n *\n * Utilise `_.some` pour vérifier qu'au moins un indicateur est présent,\n * et `_.has` pour un accès sûr.\n */\nfunction extractDiscriminants(\n\tifSchema: JSONSchema7,\n\tdata: Record<string, unknown>,\n\tout: Record<string, unknown>,\n): void {\n\tif (!isPlainObject(ifSchema.properties)) return;\n\n\tforEach(ifSchema.properties, (propDef, key) => {\n\t\tif (typeof propDef === \"boolean\") return;\n\t\tconst prop = propDef as JSONSchema7;\n\n\t\t// Collecter si au moins un indicateur de discriminant est présent\n\t\tconst hasIndicator = some(DISCRIMINANT_INDICATORS, (indicator) =>\n\t\t\thas(prop, indicator),\n\t\t);\n\n\t\tif (hasIndicator && has(data, key)) {\n\t\t\tout[key] = data[key];\n\t\t}\n\t});\n}\n\n// ─── Branch merging (deduplicated) ───────────────────────────────────────────\n\n/**\n * Merge une branche conditionnelle (`then` ou `else`) dans le schema résolu.\n *\n * Point 4 — Fix first-writer-wins :\n *   Au lieu d'ignorer les keywords déjà présents dans `resolved`,\n *   on tente un merge intelligent selon le type de keyword :\n *\n *   - `required` → union dédupliquée via `_.union`\n *   - `properties` → merge individuel via engine.merge\n *   - `dependencies` → Point 3 : union des tableaux (forme 1),\n *      merge des schemas (forme 2) via `_.mapValues`\n *   - Sub-schema keys → merge via engine.merge\n *   - Min keys → `Math.max` (plus restrictif)\n *   - Max keys → `Math.min` (plus restrictif)\n *   - `uniqueItems` → `true` gagne sur `false`\n *   - `pattern` / `format` → la branche gagne (plus spécifique)\n *   - Autres → tentative de merge via engine, sinon la branche gagne\n *\n * Utilise lodash massivement pour chaque opération de merge.\n */\nfunction mergeBranchInto(\n\tresolved: JSONSchema7,\n\tbranchDef: JSONSchema7Definition,\n\tengine: MergeEngine,\n): void {\n\tif (typeof branchDef === \"boolean\") return;\n\n\tconst branchSchema = branchDef as JSONSchema7;\n\n\t// ── Merger required via _.union (dédupliquée automatiquement) ──\n\tif (isArray(branchSchema.required)) {\n\t\tresolved.required = union(resolved.required ?? [], branchSchema.required);\n\t}\n\n\t// ── Merger properties ──\n\tif (isPlainObject(branchSchema.properties)) {\n\t\tresolved.properties = {\n\t\t\t...(resolved.properties ?? {}),\n\t\t\t...mapValues(branchSchema.properties ?? {}, (branchProp, key) => {\n\t\t\t\tconst existing = get(resolved.properties, key);\n\t\t\t\tif (\n\t\t\t\t\texisting !== undefined &&\n\t\t\t\t\ttypeof existing !== \"boolean\" &&\n\t\t\t\t\ttypeof branchProp !== \"boolean\"\n\t\t\t\t) {\n\t\t\t\t\tconst merged = engine.merge(\n\t\t\t\t\t\texisting as JSONSchema7Definition,\n\t\t\t\t\t\tbranchProp as JSONSchema7Definition,\n\t\t\t\t\t);\n\t\t\t\t\treturn merged ?? branchProp;\n\t\t\t\t}\n\t\t\t\treturn branchProp;\n\t\t\t}),\n\t\t};\n\t}\n\n\t// ── Merger dependencies (Point 3) ──\n\tif (isPlainObject(branchSchema.dependencies)) {\n\t\tconst resolvedDeps = (resolved.dependencies ?? {}) as Record<\n\t\t\tstring,\n\t\t\tJSONSchema7Definition | string[]\n\t\t>;\n\t\tconst branchDeps = branchSchema.dependencies as Record<\n\t\t\tstring,\n\t\t\tJSONSchema7Definition | string[]\n\t\t>;\n\n\t\tresolved.dependencies = reduce(\n\t\t\tkeys(branchDeps),\n\t\t\t(acc, depKey) => {\n\t\t\t\tconst branchVal = branchDeps[depKey] as\n\t\t\t\t\t| JSONSchema7Definition\n\t\t\t\t\t| string[]\n\t\t\t\t\t| undefined;\n\t\t\t\tif (branchVal === undefined) return acc;\n\t\t\t\tconst existingVal = acc[depKey] as\n\t\t\t\t\t| JSONSchema7Definition\n\t\t\t\t\t| string[]\n\t\t\t\t\t| undefined;\n\n\t\t\t\tif (existingVal === undefined) {\n\t\t\t\t\t// Pas de valeur existante → copier directement\n\t\t\t\t\tacc[depKey] = branchVal;\n\t\t\t\t} else if (isArray(existingVal) && isArray(branchVal)) {\n\t\t\t\t\t// Forme 1 : union dédupliquée des tableaux de strings\n\t\t\t\t\tacc[depKey] = union(existingVal as string[], branchVal as string[]);\n\t\t\t\t} else if (isPlainObject(existingVal) && isPlainObject(branchVal)) {\n\t\t\t\t\t// Forme 2 : merge des sous-schemas\n\t\t\t\t\tconst merged = engine.merge(\n\t\t\t\t\t\texistingVal as JSONSchema7Definition,\n\t\t\t\t\t\tbranchVal as JSONSchema7Definition,\n\t\t\t\t\t);\n\t\t\t\t\tacc[depKey] = (merged ?? branchVal) as JSONSchema7Definition;\n\t\t\t\t} else {\n\t\t\t\t\t// Types incompatibles (tableau vs schema) → la branche gagne\n\t\t\t\t\tacc[depKey] = branchVal;\n\t\t\t\t}\n\n\t\t\t\treturn acc;\n\t\t\t},\n\t\t\t{ ...resolvedDeps },\n\t\t) as Record<string, JSONSchema7Definition | string[]>;\n\t}\n\n\t// ── Merger les autres mots-clés (Point 4 — fix first-writer-wins) ──\n\tforEach(keys(branchSchema) as (keyof JSONSchema7)[], (key) => {\n\t\t// Skip les clés déjà traitées ci-dessus\n\t\tif (SPECIAL_MERGE_KEYS.has(key)) return;\n\n\t\tconst branchVal = branchSchema[key];\n\t\tconst resolvedVal = resolved[key];\n\n\t\t// Si le resolved n'a pas cette clé → copier directement\n\t\tif (resolvedVal === undefined) {\n\t\t\t(resolved as Record<string, unknown>)[key] = branchVal;\n\t\t\treturn;\n\t\t}\n\n\t\t// Si les deux ont la même valeur → rien à faire\n\t\tif (isEqual(resolvedVal, branchVal)) return;\n\n\t\t// ── Sub-schema keys → merge via engine ──\n\t\tif (SUB_SCHEMA_KEYS.has(key)) {\n\t\t\tconst merged = engine.merge(\n\t\t\t\tresolvedVal as JSONSchema7Definition,\n\t\t\t\tbranchVal as JSONSchema7Definition,\n\t\t\t);\n\t\t\tif (merged !== null) {\n\t\t\t\t(resolved as Record<string, unknown>)[key] = merged;\n\t\t\t} else {\n\t\t\t\t// Merge impossible → la branche gagne (contexte conditionnel)\n\t\t\t\t(resolved as Record<string, unknown>)[key] = branchVal;\n\t\t\t}\n\t\t\treturn;\n\t\t}\n\n\t\t// ── Min keys → Math.max (plus restrictif) ──\n\t\tif (MIN_KEYS.has(key)) {\n\t\t\tif (typeof resolvedVal === \"number\" && typeof branchVal === \"number\") {\n\t\t\t\t(resolved as Record<string, unknown>)[key] = Math.max(\n\t\t\t\t\tresolvedVal,\n\t\t\t\t\tbranchVal,\n\t\t\t\t);\n\t\t\t} else {\n\t\t\t\t(resolved as Record<string, unknown>)[key] = branchVal;\n\t\t\t}\n\t\t\treturn;\n\t\t}\n\n\t\t// ── Max keys → Math.min (plus restrictif) ──\n\t\tif (MAX_KEYS.has(key)) {\n\t\t\tif (typeof resolvedVal === \"number\" && typeof branchVal === \"number\") {\n\t\t\t\t(resolved as Record<string, unknown>)[key] = Math.min(\n\t\t\t\t\tresolvedVal,\n\t\t\t\t\tbranchVal,\n\t\t\t\t);\n\t\t\t} else {\n\t\t\t\t(resolved as Record<string, unknown>)[key] = branchVal;\n\t\t\t}\n\t\t\treturn;\n\t\t}\n\n\t\t// ── uniqueItems → true gagne sur false ──\n\t\tif (key === \"uniqueItems\") {\n\t\t\t(resolved as Record<string, unknown>)[key] =\n\t\t\t\tresolvedVal === true || branchVal === true;\n\t\t\treturn;\n\t\t}\n\n\t\t// ── pattern / format → la branche gagne (plus spécifique au contexte) ──\n\t\tif (key === \"pattern\" || key === \"format\") {\n\t\t\t(resolved as Record<string, unknown>)[key] = branchVal;\n\t\t\treturn;\n\t\t}\n\n\t\t// ── Fallback : tentative de merge via engine pour les cas restants ──\n\t\tconst base = { [key]: resolvedVal } as JSONSchema7Definition;\n\t\tconst branch = { [key]: branchVal } as JSONSchema7Definition;\n\t\tconst merged = engine.merge(base, branch);\n\t\tif (merged && typeof merged !== \"boolean\" && has(merged, key)) {\n\t\t\t(resolved as Record<string, unknown>)[key] = (\n\t\t\t\tmerged as unknown as Record<string, unknown>\n\t\t\t)[key];\n\t\t} else {\n\t\t\t// Merge échoué → la branche gagne (contexte conditionnel applicable)\n\t\t\t(resolved as Record<string, unknown>)[key] = branchVal;\n\t\t}\n\t});\n}\n\n// ─── Public API ──────────────────────────────────────────────────────────────\n\n/**\n * Résout les `if/then/else` d'un schema en évaluant le `if` contre\n * des données partielles (discriminants).\n *\n * @param schema  Le schema contenant potentiellement des if/then/else\n * @param data    Données partielles utilisées pour évaluer les conditions\n * @param engine  Le MergeEngine pour merger les branches\n *\n * @example\n * ```ts\n * const form = {\n *   type: \"object\",\n *   properties: { accountType: { type: \"string\" }, ... },\n *   if:   { properties: { accountType: { const: \"business\" } } },\n *   then: { required: [\"companyName\"] },\n *   else: { required: [\"firstName\"] },\n * };\n *\n * const { resolved } = resolveConditions(form, { accountType: \"business\" }, engine);\n * // → resolved n'a plus de if/then/else, mais a required: [\"companyName\"]\n * ```\n */\nexport function resolveConditions(\n\tschema: JSONSchema7,\n\tdata: Record<string, unknown>,\n\tengine: MergeEngine,\n): ResolvedConditionResult {\n\tlet resolved = { ...schema };\n\tlet branch: \"then\" | \"else\" | null = null;\n\tconst discriminant: Record<string, unknown> = {};\n\n\t// ── Phase 1 : Résoudre les if/then/else dans allOf ──\n\tresolved = resolveAllOfConditions(resolved, data, engine, discriminant);\n\n\t// ── Phase 2 : Résoudre le if/then/else de ce niveau ──\n\tif (resolved.if !== undefined) {\n\t\tconst ifSchema = resolved.if as JSONSchema7;\n\t\tconst matches = evaluateCondition(ifSchema, data);\n\n\t\textractDiscriminants(ifSchema, data, discriminant);\n\n\t\tconst applicableBranch = matches ? resolved.then : resolved.else;\n\t\tbranch = matches ? \"then\" : \"else\";\n\n\t\tif (applicableBranch) {\n\t\t\tmergeBranchInto(\n\t\t\t\tresolved,\n\t\t\t\tapplicableBranch as JSONSchema7Definition,\n\t\t\t\tengine,\n\t\t\t);\n\t\t}\n\n\t\tdelete resolved.if;\n\t\tdelete resolved.then;\n\t\tdelete resolved.else;\n\t}\n\n\t// ── Phase 3 : Récurser dans les properties ──\n\tresolved = resolveNestedProperties(resolved, data, engine, discriminant);\n\n\treturn { resolved, branch, discriminant };\n}\n\n// ─── Internal phases ─────────────────────────────────────────────────────────\n\n/**\n * Phase 1 : Parcourt les entrées `allOf` et résout celles qui contiennent\n * un `if/then/else`. Les entrées non-conditionnelles sont préservées.\n *\n * Utilise `_.reduce` pour accumuler les entrées restantes et `_.filter`\n * pour séparer les clés conditionnelles des non-conditionnelles.\n */\nfunction resolveAllOfConditions(\n\tresolved: JSONSchema7,\n\tdata: Record<string, unknown>,\n\tengine: MergeEngine,\n\tdiscriminant: Record<string, unknown>,\n): JSONSchema7 {\n\tif (!isArray(resolved.allOf)) return resolved;\n\n\tconst remainingAllOf: JSONSchema7Definition[] = [];\n\n\tforEach(resolved.allOf, (entry) => {\n\t\tif (typeof entry === \"boolean\") {\n\t\t\tremainingAllOf.push(entry);\n\t\t\treturn;\n\t\t}\n\n\t\tconst subSchema = entry as JSONSchema7;\n\n\t\tif (subSchema.if === undefined) {\n\t\t\tremainingAllOf.push(entry);\n\t\t\treturn;\n\t\t}\n\n\t\t// Résoudre la condition de cette entrée allOf\n\t\tconst ifSchema = subSchema.if as JSONSchema7;\n\t\tconst matches = evaluateCondition(ifSchema, data);\n\n\t\textractDiscriminants(ifSchema, data, discriminant);\n\n\t\tconst applicableBranch = matches ? subSchema.then : subSchema.else;\n\n\t\tif (applicableBranch) {\n\t\t\tmergeBranchInto(\n\t\t\t\tresolved,\n\t\t\t\tapplicableBranch as JSONSchema7Definition,\n\t\t\t\tengine,\n\t\t\t);\n\t\t}\n\n\t\t// Garder les parties non-conditionnelles de l'entrée allOf\n\t\t// Utilise `_.omit` pour supprimer proprement if/then/else\n\t\tconst remaining = omit(subSchema, [\"if\", \"then\", \"else\"]);\n\t\tif (!isEmpty(remaining)) {\n\t\t\tremainingAllOf.push(remaining as JSONSchema7);\n\t\t}\n\t});\n\n\tresolved = { ...resolved };\n\tif (isEmpty(remainingAllOf)) {\n\t\tdelete resolved.allOf;\n\t} else {\n\t\tresolved.allOf = remainingAllOf;\n\t}\n\n\treturn resolved;\n}\n\n/**\n * Phase 3 : Récurse dans les `properties` du schema résolu pour résoudre\n * les conditions imbriquées (ex: un objet dont une propriété a un if/then/else).\n *\n * Utilise `_.mapValues` pour transformer chaque propriété en une seule passe,\n * et `_.forEach` pour remonter les discriminants imbriqués.\n */\nfunction resolveNestedProperties(\n\tresolved: JSONSchema7,\n\tdata: Record<string, unknown>,\n\tengine: MergeEngine,\n\tdiscriminant: Record<string, unknown>,\n): JSONSchema7 {\n\tif (!isPlainObject(resolved.properties)) return resolved;\n\n\tconst resolvedProps = mapValues(resolved.properties ?? {}, (propDef, key) => {\n\t\tif (typeof propDef === \"boolean\") return propDef;\n\n\t\tconst propSchema = propDef as JSONSchema7;\n\t\tconst hasConditions =\n\t\t\tpropSchema.if !== undefined ||\n\t\t\t(isArray(propSchema.allOf) &&\n\t\t\t\tsome(propSchema.allOf, (e) => typeof e !== \"boolean\" && has(e, \"if\")));\n\n\t\tif (!hasConditions) return propDef;\n\n\t\t// Données imbriquées disponibles → résoudre récursivement\n\t\tconst nestedData = isPlainObject(data[key])\n\t\t\t? (data[key] as Record<string, unknown>)\n\t\t\t: {};\n\n\t\tconst nested = resolveConditions(propSchema, nestedData, engine);\n\n\t\t// Remonter les discriminants imbriqués avec prefix\n\t\tforEach(nested.discriminant, (dv, dk) => {\n\t\t\tdiscriminant[`${key}.${dk}`] = dv;\n\t\t});\n\n\t\treturn nested.resolved;\n\t});\n\n\treturn { ...resolved, properties: resolvedProps };\n}\n"
-  ],
-  "mappings": "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",
-  "debugId": "F16CECF34B4F471564756E2164756E21",
-  "names": []
-}