@sanity/schema 5.0.1-next.38 → 5.0.1-next.40

package/lib/_internal.js

@@ -2305,7 +2305,7 @@ const documentDefaultFields = (typeName) => ({
   ["email", { type: "string" }]
 ]);
 function extractSchema(schemaDef, extractOptions = {}) {
-  const inlineFields = /* @__PURE__ */ new Set(), documentTypes = /* @__PURE__ */ new Map(), schema = [], generatedTypes = /* @__PURE__ */ new Map(), { sortedSchemaTypeNames, repeated } = sortByDependencies(schemaDef);
+  const inlineFields = /* @__PURE__ */ new Set(), documentTypes = /* @__PURE__ */ new Map(), schema = [], hoistedRefMap = /* @__PURE__ */ new Map(), { sortedSchemaTypeNames, repeated } = sortByDependencies(schemaDef);
   repeated.forEach((key, objectField) => {
     const base = convertSchemaType(objectField.type);
     if (base !== null) {
@@ -2319,7 +2319,7 @@ function extractSchema(schemaDef, extractOptions = {}) {
       }
       schema.push({
         type: "type",
-        name: getGeneratedTypeName(key),
+        name: key,
         value: base
       });
     }
@@ -2330,15 +2330,15 @@ function extractSchema(schemaDef, extractOptions = {}) {
     const base = convertBaseType(schemaType);
     base !== null && (base.type === "type" && inlineFields.add(schemaType), base.type === "document" && documentTypes.set(typeName, base), schema.push(base));
   });
-  function getGeneratedTypeName(typeName, suffix = "") {
-    const name = generatedTypes.get(typeName);
+  function reserveRefName(refName) {
+    const name = hoistedRefMap.get(refName);
     if (name) return name;
     for (let i = 0; i < 5; i++) {
-      const uniqueName = `${typeName}${suffix}${i || ""}`;
-      if (!sortedSchemaTypeNames.includes(uniqueName))
-        return generatedTypes.set(typeName, uniqueName), uniqueName;
+      const uniqueName = `${refName}${i || ""}`;
+      if (!schemaDef.has(uniqueName))
+        return hoistedRefMap.set(refName, uniqueName), uniqueName;
     }
-    throw new Error(`Unable to generate unique type name for ${typeName}.`);
+    return null;
   }
   function convertBaseType(schemaType) {
     let typeName;
@@ -2409,7 +2409,7 @@ function extractSchema(schemaDef, extractOptions = {}) {
       if (hoisted && !isTopLevelSchemaType)
         value = {
           type: "inline",
-          name: getGeneratedTypeName(hoisted)
+          name: hoisted
         };
       else {
         if (value = convertSchemaType(field.type), value === null)
@@ -2461,22 +2461,34 @@ function extractSchema(schemaDef, extractOptions = {}) {
   }
   function createReferenceTypeNodeDefintion(reference2) {
     const references = gatherReferenceNames(reference2);
-    for (const name of references)
-      generatedTypes.has(name) || schema.push({
-        type: "type",
-        name: getGeneratedTypeName(name, ".reference"),
-        value: createReferenceTypeNode(name)
-      });
-    return references.length === 1 ? { type: "inline", name: getGeneratedTypeName(references[0], ".reference") } : {
+    for (const name of references) {
+      const refName = getInlineRefName(name);
+      if (!hoistedRefMap.has(refName)) {
+        const inlined = reserveRefName(refName);
+        inlined && schema.push({
+          type: "type",
+          name: inlined,
+          value: createReferenceTypeNode(name)
+        });
+      }
+    }
+    if (references.length === 1) {
+      const inlined = hoistedRefMap.get(getInlineRefName(references[0]));
+      return inlined ? { type: "inline", name: inlined } : createReferenceTypeNode(references[0]);
+    }
+    return {
       type: "union",
-      of: references.map((name) => ({
-        type: "inline",
-        name: getGeneratedTypeName(name, ".reference")
-      }))
+      of: references.map((name) => {
+        const inlined = hoistedRefMap.get(getInlineRefName(name));
+        return inlined ? { type: "inline", name: inlined } : createReferenceTypeNode(name);
+      })
     };
   }
   return schema;
 }
+function getInlineRefName(typeName) {
+  return `${typeName}.reference`;
+}
 function createKeyField() {
   return {
     type: "objectAttribute",
@@ -2595,12 +2607,18 @@ function lastType(typeDef) {
 function sortByDependencies(compiledSchema) {
   const seen = /* @__PURE__ */ new Set(), objectMap = /* @__PURE__ */ new Set(), repeated = /* @__PURE__ */ new Map(), repeatedNames = /* @__PURE__ */ new Set();
   function pickRepeatedName(path) {
-    for (let idx = path.length - 1; idx >= 0; idx--) {
+    for (let idx = path.length - 1; idx >= 1; idx--) {
       const name = path.slice(idx).join(".");
-      if (!repeatedNames.has(name))
+      if (!repeatedNames.has(name) && !compiledSchema.get(name))
         return repeatedNames.add(name), name;
     }
-    throw new Error(`Unable to pick repeated name: ${path.join(".")}`);
+    for (let i = 1; i < 10; i++)
+      for (let idx = path.length - 1; idx >= 1; idx--) {
+        const name = `${path.slice(idx).join(".")}${i}`;
+        if (!repeatedNames.has(name) && !compiledSchema.get(name))
+          return repeatedNames.add(name), name;
+      }
+    return null;
   }
   function walkDependencies(schemaType, dependencies, path, hoistRepetitions = !0) {
     if (!seen.has(schemaType)) {
@@ -2617,7 +2635,11 @@ function sortByDependencies(compiledSchema) {
               field.type.to.forEach((ref) => dependencies.add(ref.type));
             else if (dependencies.add(field.type), hoistRepetitions && !validSchemaNames.has(field.type.name)) {
               const fieldPath = path.concat([field.name]);
-              !repeated.has(field) && objectMap.has(field) && repeated.set(field, pickRepeatedName(fieldPath)), objectMap.add(field);
+              if (!repeated.has(field) && objectMap.has(field)) {
+                const name = pickRepeatedName(fieldPath);
+                name !== null && repeated.set(field, name);
+              }
+              objectMap.add(field);
             }
           } else field.type && dependencies.add(field.type);
           walkDependencies(field.type, dependencies, path.concat([field.name]));