oas 32.1.9 → 32.1.11

package/dist/{chunk-7BR3G6FM.js → chunk-QINBUHP2.js}

@@ -6,7 +6,7 @@ import {
   isOpenAPI30,
   isRef,
   isSchema
-} from "./chunk-MNOEMVCF.js";
+} from "./chunk-PSNTODZL.js";
 
 // src/lib/matches-mimetype.ts
 function matchesMediaType(types2, mediaType) {
@@ -141,6 +141,24 @@ function dereferenceRef(value, definition, seenRefs = /* @__PURE__ */ new Set())
   }
   return value;
 }
+function dereferenceRefDeep(value, definition, seenRefs = /* @__PURE__ */ new Set()) {
+  if (value === null || value === void 0) return value;
+  if (typeof value !== "object") return value;
+  if (isRef(value)) {
+    if (!definition) return value;
+    const resolved = dereferenceRef(value, definition, seenRefs);
+    if (isRef(resolved)) return resolved;
+    return dereferenceRefDeep(resolved, definition, seenRefs);
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => dereferenceRefDeep(entry, definition, seenRefs));
+  }
+  const out = {};
+  for (const key of Object.keys(value)) {
+    out[key] = dereferenceRefDeep(value[key], definition, seenRefs);
+  }
+  return out;
+}
 function getDereferencingOptions(circularRefs) {
   return {
     resolve: {
@@ -209,6 +227,15 @@ function getRefPathSegments(ref) {
   }
   return path;
 }
+function isArrayIndexSegment(seg) {
+  return /^\d+$/.test(seg);
+}
+function childShouldBeSchemaArray(parentKey, childSeg) {
+  if (!childSeg || !isArrayIndexSegment(childSeg)) {
+    return false;
+  }
+  return parentKey === "allOf" || parentKey === "anyOf" || parentKey === "oneOf";
+}
 function mergeReferencedSchemasIntoRoot(root, refToSchema) {
   for (const [ref, schema] of refToSchema) {
     const segments = getRefPathSegments(ref);
@@ -216,16 +243,57 @@ function mergeReferencedSchemasIntoRoot(root, refToSchema) {
       continue;
     }
     let current = root;
+    let pathInvalid = false;
     for (let i = 0; i < segments.length - 1; i++) {
       const seg = segments[i];
-      let next = current[seg];
-      if (!next || typeof next !== "object" || Array.isArray(next)) {
+      const nextSeg = segments[i + 1];
+      if (Array.isArray(current)) {
+        const idx = Number(seg);
+        if (!Number.isInteger(idx) || idx < 0) {
+          pathInvalid = true;
+          break;
+        }
+        const slot = current[idx];
+        if (slot === void 0 || slot === null || typeof slot !== "object" || Array.isArray(slot)) {
+          const nextObj = {};
+          current[idx] = nextObj;
+          current = nextObj;
+        } else {
+          current = slot;
+        }
+        continue;
+      }
+      const cur = current;
+      const existing = cur[seg];
+      if (childShouldBeSchemaArray(seg, nextSeg)) {
+        if (!Array.isArray(existing)) {
+          cur[seg] = [];
+        }
+        current = cur[seg];
+        continue;
+      }
+      let next;
+      if (existing !== void 0 && existing !== null && typeof existing === "object" && !Array.isArray(existing)) {
+        next = existing;
+      } else {
         next = {};
-        current[seg] = next;
+        cur[seg] = next;
       }
       current = next;
     }
-    current[segments[segments.length - 1]] = schema;
+    if (pathInvalid) {
+      continue;
+    }
+    const lastSeg = segments[segments.length - 1];
+    if (Array.isArray(current)) {
+      const idx = Number(lastSeg);
+      if (!Number.isInteger(idx) || idx < 0) {
+        continue;
+      }
+      current[idx] = schema;
+    } else {
+      current[lastSeg] = schema;
+    }
   }
 }
 
@@ -350,6 +418,35 @@ var UNSUPPORTED_SCHEMA_PROPS = [
   "externalDocs",
   "xml"
 ];
+var mergeAllOfSchemasOptions = {
+  ignoreAdditionalProperties: true,
+  resolvers: {
+    // `merge-json-schema-allof` by default takes the first `description` when you're merging an
+    // `allOf` but because generally when you're merging two schemas together with an `allOf` you
+    // want data in the subsequent schemas to be applied to the first and `description` should be a
+    // part of that.
+    description: (obj) => {
+      return obj.slice(-1)[0];
+    },
+    // `merge-json-schema-allof` doesn't support merging enum arrays but since that's a safe and
+    // simple operation as enums always contain primitives we can handle it ourselves with a custom
+    // resolver. We intersect the arrays so that child schemas can narrow a parent's broad enum
+    // (e.g. [1,2,20,50] ∩ [1] = [1]).
+    //
+    // We unfortunately need to cast our return value as `any[]` because the internal types of
+    // `merge-json-schema-allof`'s `enum` resolver are not portable.
+    enum: (obj) => {
+      const arrays = obj;
+      const intersection = arrays.reduce((acc, e) => acc.filter((v) => e.includes(v)));
+      return intersection.length > 0 ? intersection : arrays.reduce((acc, e) => acc.concat(e), []);
+    },
+    // For any unknown keywords (e.g., `example`, `format`, `x-readme-ref-name`), we fallback to
+    // using the `title` resolver (which uses the first value found).
+    // https://github.com/mokkabonna/json-schema-merge-allof/blob/ea2e48ee34415022de5a50c236eb4793a943ad11/src/index.js#L292
+    // https://github.com/mokkabonna/json-schema-merge-allof/blob/ea2e48ee34415022de5a50c236eb4793a943ad11/README.md?plain=1#L147
+    defaultResolver: mergeJSONSchemaAllOf.options.resolvers.title
+  }
+};
 var PENDING_SCHEMA = { __pending: true };
 function isPendingSchema(s) {
   return isObject(s) && "__pending" in s && s.__pending === true;
@@ -369,6 +466,14 @@ function getSchemaVersionString(schema, api) {
 function isPolymorphicSchema(schema) {
   return "allOf" in schema || "anyOf" in schema || "oneOf" in schema;
 }
+function shouldFoldParentItemsIntoPolymorphBranch(item) {
+  if (!isObject(item)) return false;
+  if (isRef(item)) return true;
+  const branch = item;
+  if (!("type" in branch) || branch.type === void 0) return true;
+  if (!hasSchemaType(branch, "array")) return false;
+  return !("items" in branch) || branch.items === void 0;
+}
 function isEmptyPolymorphicSchema(list) {
   if (!Array.isArray(list)) return false;
   if (!list.length) return true;
@@ -378,7 +483,7 @@ function isEmptyPolymorphicSchema(list) {
     return Array.isArray(branch) ? !branch.length : !Object.keys(branch).length;
   });
 }
-function inlinePropertyRefsForMerge(schema, usedSchemas) {
+function inlinePropertyRefsForMerge(schema, usedSchemas, refLogger) {
   const out = structuredClone(schema);
   if (!("properties" in out) || typeof out.properties !== "object" || out.properties === null) {
     return out;
@@ -386,6 +491,10 @@ function inlinePropertyRefsForMerge(schema, usedSchemas) {
   for (const key of Object.keys(out.properties)) {
     const val = out.properties[key];
     if (isRef(val)) {
+      if (val.$ref.startsWith("#/paths/")) {
+        refLogger(val.$ref, "ref");
+        continue;
+      }
       const resolved = usedSchemas.get(val.$ref);
       if (resolved !== void 0 && !isPendingSchema(resolved)) {
         out.properties[key] = {
@@ -590,7 +699,7 @@ function toJSONSchema(data, opts) {
         returnMode: "ref",
         refLogger
       });
-      const { $ref: _$ref, ...siblings } = schema;
+      const { $ref: _$ref, properties: _propertiesWithRef, ...siblings } = schema;
       if (Object.keys(siblings).length > 0) {
         return { ...resolved, ...siblings };
       }
@@ -601,14 +710,43 @@ function toJSONSchema(data, opts) {
   }
   if (isSchema(schema, isPolymorphicAllOfChild)) {
     if ("allOf" in schema && Array.isArray(schema.allOf)) {
+      if ("properties" in schema && schema.properties !== void 0 && typeof schema.properties === "object" && schema.properties !== null && !Array.isArray(schema.properties)) {
+        const preprocessed = {};
+        for (const prop of Object.keys(schema.properties)) {
+          const val = schema.properties[prop];
+          if (Array.isArray(val) || typeof val === "object" && val !== null) {
+            preprocessed[prop] = toJSONSchema(val, {
+              ...polyOptions,
+              currentLocation: `${currentLocation}/${encodePointer(prop)}`,
+              prevDefaultSchemas,
+              prevExampleSchemas
+            });
+          } else {
+            preprocessed[prop] = val;
+          }
+        }
+        schema = { ...schema, properties: preprocessed };
+      }
       let allOfSchemas = schema.allOf;
       if (definition && usedSchemas) {
-        const allOfOptions = schema.allOf.length > 1 ? { ...polyOptions, refLogger: () => {
+        const allOfOptions = allOfSchemas.length > 1 ? { ...polyOptions, refLogger: () => {
         } } : polyOptions;
-        allOfSchemas = schema.allOf.map((item) => {
+        allOfSchemas = allOfSchemas.map((item) => {
           if (isRef(item)) {
-            return resolveAndCacheRefSchema({
-              schema: item,
+            if (Object.keys(item).length === 1) {
+              return resolveAndCacheRefSchema({
+                schema: item,
+                definition,
+                usedSchemas,
+                seenRefs,
+                conversionOptions: allOfOptions,
+                returnMode: "converted",
+                refLogger
+              });
+            }
+            const { $ref, ...siblings } = item;
+            const resolved = resolveAndCacheRefSchema({
+              schema: { $ref },
               definition,
               usedSchemas,
               seenRefs,
@@ -616,44 +754,28 @@ function toJSONSchema(data, opts) {
               returnMode: "converted",
               refLogger
             });
+            if (!Object.keys(siblings).length) {
+              return resolved;
+            }
+            const siblingSchema = toJSONSchema(siblings, allOfOptions);
+            try {
+              return mergeJSONSchemaAllOf(
+                { allOf: [resolved, siblingSchema] },
+                mergeAllOfSchemasOptions
+              );
+            } catch {
+              return resolved;
+            }
           }
           return toJSONSchema(item, allOfOptions);
         });
         schema = {
           ...schema,
-          allOf: allOfSchemas.map((s) => inlinePropertyRefsForMerge(s, usedSchemas))
+          allOf: allOfSchemas.map((s) => inlinePropertyRefsForMerge(s, usedSchemas, refLogger))
         };
       }
       try {
-        schema = mergeJSONSchemaAllOf(schema, {
-          ignoreAdditionalProperties: true,
-          resolvers: {
-            // `merge-json-schema-allof` by default takes the first `description` when you're
-            // merging an `allOf` but because generally when you're merging two schemas together
-            // with an `allOf` you want data in the subsequent schemas to be applied to the first
-            // and `description` should be a part of that.
-            description: (obj) => {
-              return obj.slice(-1)[0];
-            },
-            // `merge-json-schema-allof` doesn't support merging enum arrays but since that's a
-            // safe and simple operation as enums always contain primitives we can handle it
-            // ourselves with a custom resolver. We intersect the arrays so that child schemas
-            // can narrow a parent's broad enum (e.g. [1,2,20,50] ∩ [1] = [1]).
-            //
-            // We unfortunately need to cast our return value as `any[]` because the internal types
-            // of `merge-json-schema-allof`'s `enum` resolver are not portable.
-            enum: (obj) => {
-              const arrays = obj;
-              const intersection = arrays.reduce((acc, e) => acc.filter((v) => e.includes(v)));
-              return intersection.length > 0 ? intersection : arrays.reduce((acc, e) => acc.concat(e), []);
-            },
-            // for any unknown keywords (e.g., `example`, `format`, `x-readme-ref-name`),
-            // we fallback to using the title resolver (which uses the first value found).
-            // https://github.com/mokkabonna/json-schema-merge-allof/blob/ea2e48ee34415022de5a50c236eb4793a943ad11/src/index.js#L292
-            // https://github.com/mokkabonna/json-schema-merge-allof/blob/ea2e48ee34415022de5a50c236eb4793a943ad11/README.md?plain=1#L147
-            defaultResolver: mergeJSONSchemaAllOf.options.resolvers.title
-          }
-        });
+        schema = mergeJSONSchemaAllOf(schema, mergeAllOfSchemasOptions);
       } catch {
         const { ...schemaWithoutAllOf } = schema;
         schema = schemaWithoutAllOf;
@@ -687,12 +809,16 @@ function toJSONSchema(data, opts) {
               itemOptions
             );
           } else if ("items" in schema) {
-            schema[polyType][idx] = toJSONSchema(
-              {
-                allOf: [item, { items: schema.items }]
-              },
-              itemOptions
-            );
+            if (shouldFoldParentItemsIntoPolymorphBranch(item)) {
+              schema[polyType][idx] = toJSONSchema(
+                {
+                  allOf: [item, { items: schema.items }]
+                },
+                itemOptions
+              );
+            } else {
+              schema[polyType][idx] = toJSONSchema(item, itemOptions);
+            }
           } else {
             schema[polyType][idx] = toJSONSchema(item, itemOptions);
           }
@@ -1037,6 +1163,9 @@ ${enums}`;
       }
       if ("items" in schema) {
         delete schema.items;
+        if ("type" in schema && schema.type === "array") {
+          delete schema.type;
+        }
       }
     }
   }
@@ -1268,7 +1397,9 @@ export {
   decorateComponentSchemasWithRefName,
   decodePointer,
   dereferenceRef,
+  dereferenceRefDeep,
   getDereferencingOptions,
+  collectRefsInSchema,
   filterRequiredRefsToReferenced,
   mergeReferencedSchemasIntoRoot,
   matches_mimetype_default,
@@ -1282,4 +1413,4 @@ export {
   supportedMethods,
   SERVER_VARIABLE_REGEX
 };
-//# sourceMappingURL=chunk-7BR3G6FM.js.map
+//# sourceMappingURL=chunk-QINBUHP2.js.map