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

package/lib/_internal.js

@@ -1,8 +1,17 @@
 import { SetBuilder, processSetSynchronization } from "@sanity/descriptors";
-import { isObject, isEqual, difference, flatten, get, uniq, partition, omit, isPlainObject, cloneDeep } from "lodash-es";
+import isEqual from "lodash/isEqual.js";
+import isObject from "lodash/isObject.js";
 import { OWN_PROPS_NAME, Rule, Schema } from "./_chunks-es/Rule.js";
 import { ALL_FIELDS_GROUP_NAME, DEFAULT_MAX_FIELD_DEPTH, resolveSearchConfig, resolveSearchConfigForBaseFieldPaths } from "./_chunks-es/Rule.js";
+import difference from "lodash/difference.js";
+import cloneDeep from "lodash/cloneDeep.js";
+import flatten from "lodash/flatten.js";
+import get from "lodash/get.js";
+import uniq from "lodash/uniq.js";
 import humanizeList from "humanize-list";
+import partition from "lodash/partition.js";
+import isPlainObject from "lodash/isPlainObject.js";
+import omit from "lodash/omit.js";
 import leven from "leven";
 import inspect from "object-inspect";
 import { createReferenceTypeNode } from "groq-js";
@@ -2305,7 +2314,7 @@ const documentDefaultFields = (typeName) => ({
   ["email", { type: "string" }]
 ]);
 function extractSchema(schemaDef, extractOptions = {}) {
-  const inlineFields = /* @__PURE__ */ new Set(), documentTypes = /* @__PURE__ */ new Map(), schema = [], hoistedRefMap = /* @__PURE__ */ new Map(), { sortedSchemaTypeNames, repeated } = sortByDependencies(schemaDef);
+  const inlineFields = /* @__PURE__ */ new Set(), documentTypes = /* @__PURE__ */ new Map(), schema = [], generatedTypes = /* @__PURE__ */ new Map(), { sortedSchemaTypeNames, repeated } = sortByDependencies(schemaDef);
   repeated.forEach((key, objectField) => {
     const base = convertSchemaType(objectField.type);
     if (base !== null) {
@@ -2319,7 +2328,7 @@ function extractSchema(schemaDef, extractOptions = {}) {
       }
       schema.push({
         type: "type",
-        name: key,
+        name: getGeneratedTypeName(key),
         value: base
       });
     }
@@ -2330,15 +2339,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 reserveRefName(refName) {
-    const name = hoistedRefMap.get(refName);
+  function getGeneratedTypeName(typeName, suffix = "") {
+    const name = generatedTypes.get(typeName);
     if (name) return name;
     for (let i = 0; i < 5; i++) {
-      const uniqueName = `${refName}${i || ""}`;
-      if (!schemaDef.has(uniqueName))
-        return hoistedRefMap.set(refName, uniqueName), uniqueName;
+      const uniqueName = `${typeName}${suffix}${i || ""}`;
+      if (!sortedSchemaTypeNames.includes(uniqueName))
+        return generatedTypes.set(typeName, uniqueName), uniqueName;
     }
-    return null;
+    throw new Error(`Unable to generate unique type name for ${typeName}.`);
   }
   function convertBaseType(schemaType) {
     let typeName;
@@ -2409,7 +2418,7 @@ function extractSchema(schemaDef, extractOptions = {}) {
       if (hoisted && !isTopLevelSchemaType)
         value = {
           type: "inline",
-          name: hoisted
+          name: getGeneratedTypeName(hoisted)
         };
       else {
         if (value = convertSchemaType(field.type), value === null)
@@ -2461,34 +2470,22 @@ function extractSchema(schemaDef, extractOptions = {}) {
   }
   function createReferenceTypeNodeDefintion(reference2) {
     const references = gatherReferenceNames(reference2);
-    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 {
+    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") } : {
       type: "union",
-      of: references.map((name) => {
-        const inlined = hoistedRefMap.get(getInlineRefName(name));
-        return inlined ? { type: "inline", name: inlined } : createReferenceTypeNode(name);
-      })
+      of: references.map((name) => ({
+        type: "inline",
+        name: getGeneratedTypeName(name, ".reference")
+      }))
     };
   }
   return schema;
 }
-function getInlineRefName(typeName) {
-  return `${typeName}.reference`;
-}
 function createKeyField() {
   return {
     type: "objectAttribute",
@@ -2607,18 +2604,12 @@ 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 >= 1; idx--) {
+    for (let idx = path.length - 1; idx >= 0; idx--) {
       const name = path.slice(idx).join(".");
-      if (!repeatedNames.has(name) && !compiledSchema.get(name))
+      if (!repeatedNames.has(name))
         return repeatedNames.add(name), name;
     }
-    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;
+    throw new Error(`Unable to pick repeated name: ${path.join(".")}`);
   }
   function walkDependencies(schemaType, dependencies, path, hoistRepetitions = !0) {
     if (!seen.has(schemaType)) {
@@ -2635,11 +2626,7 @@ 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]);
-              if (!repeated.has(field) && objectMap.has(field)) {
-                const name = pickRepeatedName(fieldPath);
-                name !== null && repeated.set(field, name);
-              }
-              objectMap.add(field);
+              !repeated.has(field) && objectMap.has(field) && repeated.set(field, pickRepeatedName(fieldPath)), objectMap.add(field);
             }
           } else field.type && dependencies.add(field.type);
           walkDependencies(field.type, dependencies, path.concat([field.name]));