@inf-monkeys-tech/monkeys 1.1.30 → 1.1.31

package/lib/esm/{chunk-DHPZLF57.mjs → chunk-N3RVZAFT.mjs}

@@ -5651,6 +5651,15 @@ var schemasCannotOverlap = (left, right) => {
   const values = (schema) => Object.prototype.hasOwnProperty.call(schema, "const") ? [schema.const] : Array.isArray(schema.enum) ? schema.enum : void 0;
   const av = values(a), bv = values(b);
   if (av && bv && av.every((value) => !bv.some((other) => canonicalContentHash(value) === canonicalContentHash(other)))) return true;
+  const declaredTypes = (schema) => {
+    const types = typeof schema.type === "string" ? [schema.type] : schema.type;
+    if (!Array.isArray(types) || !types.length || types.some((type) => !["null", "boolean", "object", "array", "number", "integer", "string"].includes(type))) return void 0;
+    return types.map((type) => type === "integer" ? "number" : type);
+  };
+  const valueTypes = (entries) => entries?.map((value) => value === null ? "null" : Array.isArray(value) ? "array" : typeof value);
+  const disjoint = (leftTypes, rightTypes) => !!leftTypes && !!rightTypes && leftTypes.every((type) => !rightTypes.includes(type));
+  const at = declaredTypes(a), bt = declaredTypes(b);
+  if (disjoint(at, bt) || disjoint(valueTypes(av), bt) || disjoint(at, valueTypes(bv))) return true;
   if (a.type !== "object" || b.type !== "object") return false;
   const property = (schema, key) => schema.properties?.[key] ?? (schema.patternProperties ? true : schema.additionalProperties ?? true);
   return [...a.required ?? [], ...b.required ?? []].some((key) => schemasCannotOverlap(property(a, key), property(b, key)));
@@ -5688,6 +5697,31 @@ var boundAcceptsPrevious = (previous, next, direction) => {
   return previous.value !== next.value || !previous.inclusive || next.inclusive;
 };
 var numericRangesAcceptPrevious = (previous, next) => boundAcceptsPrevious(numericBound(previous, "lower"), numericBound(next, "lower"), "lower") && boundAcceptsPrevious(numericBound(previous, "upper"), numericBound(next, "upper"), "upper");
+var containsSchemaReference = (value) => !!value && typeof value === "object" && Object.entries(value).some(([key, child]) => ["$ref", "$dynamicRef", "$recursiveRef"].includes(key) || containsSchemaReference(child));
+var hasPositiveLocalReferences = (schema, names, root = true) => {
+  if (typeof schema === "boolean") return true;
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) return false;
+  return Object.entries(schema).every(([key, value]) => {
+    if (key === "$ref") return typeof value === "string" && [...names].some((name) => value === `#/$defs/${name.replace(/~/g, "~0").replace(/\//g, "~1")}`);
+    if (["$dynamicRef", "$recursiveRef", "$dynamicAnchor", "$recursiveAnchor", "$anchor"].includes(key)) return false;
+    if (key === "$id") return root;
+    if (key === "$defs" || key === "properties") {
+      if (key === "$defs" && !root) return false;
+      return !!value && typeof value === "object" && !Array.isArray(value) && Object.values(value).every((child) => hasPositiveLocalReferences(child, names, false));
+    }
+    if (["items", "additionalProperties"].includes(key)) return hasPositiveLocalReferences(value, names, false);
+    if (["anyOf", "allOf"].includes(key)) return Array.isArray(value) && value.every((child) => hasPositiveLocalReferences(child, names, false));
+    return !containsSchemaReference(value);
+  });
+};
+var isUnreachableConditional = (previous, branch) => {
+  if (previous.type !== "object" || !branch || typeof branch !== "object" || Array.isArray(branch)) return false;
+  const rule = branch;
+  if (!rule.if || Object.keys(rule).some((key) => !["if", "then"].includes(key))) return false;
+  const condition = rule.if;
+  if (typeof condition !== "object" || Array.isArray(condition) || Object.keys(condition).some((key) => !["type", "properties", "required"].includes(key)) || condition.type !== void 0 && condition.type !== "object" || !Array.isArray(condition.required)) return false;
+  return condition.required.some((key) => typeof key === "string" && schemasCannotOverlap(previous.properties?.[key] ?? (previous.patternProperties ? true : previous.additionalProperties ?? true), condition.properties?.[key] ?? true));
+};
 var acceptsPreviousSchema = (previous, next) => {
   if (canonicalContentHash(previous) === canonicalContentHash(next) || next === true) return true;
   if (previous === false) return true;
@@ -5700,6 +5734,21 @@ var acceptsPreviousSchema = (previous, next) => {
   if (oldBranches) return oldBranches.every((branch) => acceptsPreviousSchema(branch, next));
   const newBranches = branches(after);
   if (newBranches) return newBranches.some((branch, index) => acceptsPreviousSchema(previous, branch) && (!after.oneOf || newBranches.every((other, otherIndex) => index === otherIndex || schemasCannotOverlap(previous, other))));
+  if (canonicalContentHash(before.$defs ?? null) !== canonicalContentHash(after.$defs ?? null)) {
+    const oldDefinitions = before.$defs, newDefinitions = after.$defs;
+    if (!oldDefinitions || !newDefinitions || typeof oldDefinitions !== "object" || typeof newDefinitions !== "object" || Array.isArray(oldDefinitions) || Array.isArray(newDefinitions)) return false;
+    const names = new Set(Object.keys(oldDefinitions));
+    if (names.size !== Object.keys(newDefinitions).length || [...names].some((name) => !Object.prototype.hasOwnProperty.call(newDefinitions, name)) || !hasPositiveLocalReferences(before, names) || !hasPositiveLocalReferences(after, names) || [...names].some((name) => !acceptsPreviousSchema(oldDefinitions[name], newDefinitions[name]))) return false;
+    delete before.$defs;
+    delete after.$defs;
+  }
+  if (canonicalContentHash(before.allOf ?? null) !== canonicalContentHash(after.allOf ?? null)) {
+    if (before.allOf !== void 0 && !Array.isArray(before.allOf) || !Array.isArray(after.allOf)) return false;
+    const previousBranches = before.allOf ?? [];
+    if (previousBranches.some((branch) => !after.allOf.some((candidate) => canonicalContentHash(branch) === canonicalContentHash(candidate))) || after.allOf.some((branch) => !previousBranches.some((candidate) => canonicalContentHash(branch) === canonicalContentHash(candidate)) && !isUnreachableConditional(before, branch))) return false;
+    if (before.allOf === void 0) delete after.allOf;
+    else after.allOf = before.allOf;
+  }
   const {
     properties: oldProperties,
     required: oldRequired,
@@ -7186,4 +7235,4 @@ export {
   PageCompositionSchema,
   compilePageComposition
 };
-//# sourceMappingURL=chunk-DHPZLF57.mjs.map
+//# sourceMappingURL=chunk-N3RVZAFT.mjs.map