@sanity/agent-schema 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -1,149 +1,5 @@
+import { _ as SchemaFieldDisplayOptions, a as ValidateValueFn, b as SchemaTypes, c as ValidationErrorCode, d as DatasetStats, f as DatasetStatsSchema, g as ProcessedDocumentType, h as ManifestSchemaType, i as PatchOperations, l as ValidationResult, m as ManifestField, n as InsertOperation, o as ValidationContext, p as LexiconResponse, r as LocalizationConfig, s as ValidationError, t as FieldSchemaLookupResult, u as CompressedSchemaOptions, v as SchemaFilter, y as SchemaProcessorOptions } from "./_chunks-dts/types.js";
 import { SanityClient } from "@sanity/client";
-import { z } from "zod";
-import { LexiconResponse } from "@sanity/schema-descriptor-utils";
-type ManifestSerializable = string | number | boolean | {
-  [k: string]: ManifestSerializable;
-} | ManifestSerializable[];
-type ManifestSchemaType = {
-  type: string;
-  name: string;
-  title?: string;
-  description?: string;
-  deprecated?: {
-    reason: string;
-  };
-  readOnly?: boolean | 'conditional';
-  hidden?: boolean | 'conditional';
-  validation?: ManifestValidationGroup[];
-  fields?: ManifestField[];
-  to?: ManifestReferenceMember[];
-  of?: ManifestArrayMember[];
-  preview?: {
-    select: Record<string, string>;
-  };
-  fieldsets?: ManifestFieldset[];
-  options?: Record<string, ManifestSerializable>;
-  marks?: {
-    annotations?: ManifestArrayMember[];
-    decorators?: ManifestTitledValue[];
-  };
-  lists?: ManifestTitledValue[];
-  styles?: ManifestTitledValue[];
-  [index: string]: unknown;
-};
-type ManifestFieldset = {
-  name: string;
-  title?: string;
-  [index: string]: ManifestSerializable | undefined;
-};
-type ManifestTitledValue = {
-  value: string;
-  title?: string;
-};
-type ManifestField = ManifestSchemaType & {
-  fieldset?: string;
-};
-type ManifestArrayMember = Omit<ManifestSchemaType, 'name'> & {
-  name?: string;
-};
-type ManifestReferenceMember = Omit<ManifestSchemaType, 'name'> & {
-  name?: string;
-};
-type ManifestValidationGroup = {
-  rules: ManifestValidationRule[];
-  message?: string;
-  level?: 'error' | 'warning' | 'info';
-};
-type ManifestValidationRule = {
-  flag: 'presence' | string;
-  constraint?: 'required' | ManifestSerializable;
-  [index: string]: ManifestSerializable | undefined;
-};
-declare const DatasetStatsSchema: z.ZodObject<{
-  documentCount: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
-  referenceCount: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-    incoming: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodNumber, z.ZodLiteral<"unknown">]>>;
-    outgoing: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodNumber, z.ZodLiteral<"unknown">]>>;
-  }, "strip", z.ZodTypeAny, {
-    incoming: Record<string, number | "unknown">;
-    outgoing: Record<string, number | "unknown">;
-  }, {
-    incoming: Record<string, number | "unknown">;
-    outgoing: Record<string, number | "unknown">;
-  }>>>;
-}, "strip", z.ZodTypeAny, {
-  documentCount?: Record<string, number> | undefined;
-  referenceCount?: Record<string, {
-    incoming: Record<string, number | "unknown">;
-    outgoing: Record<string, number | "unknown">;
-  }> | undefined;
-}, {
-  documentCount?: Record<string, number> | undefined;
-  referenceCount?: Record<string, {
-    incoming: Record<string, number | "unknown">;
-    outgoing: Record<string, number | "unknown">;
-  }> | undefined;
-}>;
-type DatasetStats = z.infer<typeof DatasetStatsSchema>;
-type ReferenceInfo = {
-  type: string;
-  path: string;
-};
-type ProcessedDocumentType = {
-  name: string;
-  title?: string;
-  description?: string;
-  deprecated?: {
-    reason: string;
-  };
-  liveEdit?: boolean;
-  titleField: string;
-  fields: ManifestField[];
-  outgoingReferences: string[];
-  incomingReferences: string[];
-  outgoingReferencePaths?: ReferenceInfo[];
-  incomingReferencePaths?: ReferenceInfo[];
-};
-type SchemaTypes = {
-  documentTypes: Map<string, ProcessedDocumentType>;
-  objectTypes: Map<string, ManifestSchemaType>;
-};
-/**
- * Filter document types by GROQ expressions or an explicit list.
- * - `{ read?, write? }` — GROQ boolean expressions (requires groq-js peer dep).
- *   Types matching either expression are included (union).
- * - `string[]` — explicit list of document type names to include.
- * - `undefined` / empty — include all document types.
- */
-type SchemaFilter = {
-  read?: string;
-  write?: string;
-} | string[];
-type SchemaFieldDisplayOptions = {
-  showAll?: boolean;
-  maxCount?: number;
-  includeDescription?: boolean;
-  includeHidden?: boolean;
-  includeDeprecated?: boolean;
-  maxEnumValues?: number;
-  maxDescriptionLength?: number;
-};
-type CompressedSchemaOptions = {
-  datasetStats?: DatasetStats;
-  filter?: SchemaFilter;
-  fields?: SchemaFieldDisplayOptions;
-  /**
-   * When `true`, document types with `documentCount === 0` are still rendered
-   * (and their references fall back to the count-less format, since all edges
-   * would be zero anyway). Default `false` preserves the existing behavior of
-   * dropping empty types when `datasetStats` is provided.
-   */
-  includeEmpty?: boolean;
-};
-type SchemaProcessorOptions = {
-  filter?: SchemaFilter;
-  fields?: SchemaFieldDisplayOptions;
-};
 type DatasetStatsResult = {
   status: 'ready';
   stats: DatasetStats;
@@ -331,5 +187,5 @@ declare function shouldSkipType(typeName: string): boolean;
  * a pre-resolved `string[]` of document type names.
  */
 declare function compressedSchema(types: ManifestSchemaType[], options?: CompressedSchemaOptions): Promise<string>;
-export { ARRAY_ITEM_SYSTEM_FIELDS, BUILT_IN_TYPE_FIELDS, type CompressedSchemaOptions, DEFAULT_LINK_ANNOTATION, type DatasetStats, DatasetStatsSchema, type FetchSchemaOptions, type FullSchemaOptions, type ManifestField, type ManifestSchemaType, type ProcessedDocumentType, SCHEMA_CONSTANTS, type SchemaCache, type SchemaFieldDisplayOptions, type SchemaFilter, type SchemaTypes, compressedSchema, fetchDatasetStats, fetchSchemaByDescriptorId, filterToPath, fullSchema, isBuiltInType, isGenericObject, isPrimitiveType, resolveFieldSchema as navigateToFieldSchema, resolveFieldSchema, resolveFieldSchemaAllUnions as navigateToFieldSchemaAllUnions, resolveFieldSchemaAllUnions, processSchema, shouldSkipType, toSchemaPath };
+export { ARRAY_ITEM_SYSTEM_FIELDS, BUILT_IN_TYPE_FIELDS, type CompressedSchemaOptions, DEFAULT_LINK_ANNOTATION, type DatasetStats, DatasetStatsSchema, type FetchSchemaOptions, type FieldSchemaLookupResult, type FullSchemaOptions, type InsertOperation, type LocalizationConfig, type ManifestField, type ManifestSchemaType, type PatchOperations, type ProcessedDocumentType, SCHEMA_CONSTANTS, type SchemaCache, type SchemaFieldDisplayOptions, type SchemaFilter, type SchemaTypes, type ValidateValueFn, type ValidationContext, type ValidationError, type ValidationErrorCode, type ValidationResult, compressedSchema, fetchDatasetStats, fetchSchemaByDescriptorId, filterToPath, fullSchema, isBuiltInType, isGenericObject, isPrimitiveType, resolveFieldSchema as navigateToFieldSchema, resolveFieldSchema, resolveFieldSchemaAllUnions as navigateToFieldSchemaAllUnions, resolveFieldSchemaAllUnions, processSchema, shouldSkipType, toSchemaPath };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/types.ts","../src/fetchDatasetStats.ts","../src/fetchSchemaByDescriptorId.ts","../src/processSchema.ts","../src/navigate/constants.ts","../src/navigate/filterToPath.ts","../src/navigate/navigateAllUnions.ts","../src/navigate/navigateToField.ts","../src/navigate/path.ts","../src/navigate/types.ts","../src/fullSchema.ts","../src/constants.ts","../src/utils.ts","../src/index.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/fetchDatasetStats.ts","../src/fetchSchemaByDescriptorId.ts","../src/processSchema.ts","../src/navigate/constants.ts","../src/navigate/filterToPath.ts","../src/navigate/navigateAllUnions.ts","../src/navigate/navigateToField.ts","../src/navigate/path.ts","../src/navigate/types.ts","../src/fullSchema.ts","../src/constants.ts","../src/utils.ts","../src/index.ts"],"mappings":";;KAGK,kBAAA;EAAuB,MAAA;EAAiB,KAAA,EAAO,YAAA;AAAA;EAAmB,MAAA;AAAA;AAAA,KAElE,wBAAA;EACH,cAAA;EACA,SAAA;EACA,OAAA;AAAA;AAL2E;;;;;;;;;AAAA,iBAiBvD,iBAAA,CACpB,MAAA,EAAQ,YAAA,EACR,OAAA,EAAS,wBAAA,GACR,OAAA,CAAQ,kBAAA;;AAtBmC;;;KCelC,WAAA;EACV,GAAA,GAAM,YAAA,aAAyB,OAAA,CAAQ,eAAA;EACvC,GAAA,GAAM,YAAA,UAAsB,QAAA,EAAU,eAAA,KAAoB,OAAA;AAAA;AAAA,KAmBhD,kBAAA;EDlCiE;;AAAA;;;ECwC3E,KAAA,aAAkB,WAAA,EDrClB;ECuCA,KAAA;AAAA;;;ADzBF;;;;;;;iBCqCsB,yBAAA,CACpB,MAAA,EAAQ,YAAA,EACR,YAAA,UACA,OAAA,GAAU,kBAAA,GACT,OAAA,CAAQ,kBAAA;;;AD5DmC;;iBEqJ9B,aAAA,CACd,MAAA,EAAQ,kBAAA,IACR,OAAA,GAAU,sBAAA,GACT,WAAA;;;AFxJ2C;;cGKjC,oBAAA,EAAsB,MAAA,SAAe,MAAA,SAAe,kBAAA;;;;;cA2EpD,uBAAA,EAAyB,kBAAA;;;AH9EuC;cG0FhE,wBAAA,EAA0B,MAAA,SAAe,kBAAA;;;;;;;;;AH1FuB;;;;;;iBI+J7D,YAAA,CACd,IAAA,EAAM,kBAAA,EACN,IAAA,UACA,MAAA,EAAQ,kBAAA,KACP,kBAAA;;;AJrK2C;;;iBKQ9B,2BAAA,CACd,IAAA,UACA,UAAA,EAAY,kBAAA,EACZ,MAAA,EAAQ,kBAAA,KACP,kBAAA;;;ALZ2C;;;;;;iBMyK9B,kBAAA,CACd,IAAA,UACA,UAAA,EAAY,kBAAA,EACZ,MAAA,EAAQ,kBAAA,KACP,kBAAA;;;;AN7K2C;;;;;;;;;;iBOY9B,YAAA,CAAa,IAAA;;;;APZiB;;;;iBQU9B,eAAA,CACd,QAAA,sBACA,OAAA;EAAW,iBAAA;AAAA;;;;ARVgE;iBQuB7D,aAAA,CAAc,IAAA;;;;;;;iBA4Bd,eAAA,CAAgB,IAAA;AAAA,KCjDpB,iBAAA;wDAEV,IAAA,UTJqB;ESMrB,IAAA,WTN8D;ESQ9D,aAAA;AAAA;AAAA,KAGG,kBAAA;EACH,aAAA;EACA,IAAA;EACA,IAAA;EACA,QAAA,EAAU,KAAA;IAAQ,IAAA;IAAc,IAAA;EAAA;EAChC,IAAA;AAAA;;;;ATCF;;;;;;;;iBSagB,UAAA,CACd,MAAA,EAAQ,kBAAA,IACR,OAAA,EAAS,iBAAA,GACR,MAAA,oBAA0B,kBAAA;AAAA,cCpChB,gBAAA;EAAA,wBAkBH,MAAA;EAAA;;;;;;;;;;;;;;iBChBM,cAAA,CAAe,QAAA;;;;;;;AXkB/B;;;iBYmFsB,gBAAA,CACpB,KAAA,EAAO,kBAAA,IACP,OAAA,GAAS,uBAAA,GACR,OAAA"}

package/dist/index.js

@@ -1,4 +1,6 @@
 import { convertToDefinition } from "@sanity/schema-descriptor-utils";
+import { isPrimitiveType, isGenericObject } from "./_chunks-es/navigateToField.js";
+import { ARRAY_ITEM_SYSTEM_FIELDS, BUILT_IN_TYPE_FIELDS, DEFAULT_LINK_ANNOTATION, isBuiltInType, resolveFieldSchema, resolveFieldSchemaAllUnions, resolveFieldSchema as resolveFieldSchema2, resolveFieldSchemaAllUnions as resolveFieldSchemaAllUnions2, toSchemaPath } from "./_chunks-es/navigateToField.js";
 import { z } from "zod";
 async function fetchDatasetStats(client, options) {
   const { organizationId, projectId, dataset } = options, response = await client.request({
@@ -181,86 +183,6 @@ function processSchema(schema, options) {
     doc.titleField = findTitleField(doc.fields);
   return { documentTypes, objectTypes };
 }
-const BUILT_IN_TYPE_FIELDS = {
-  slug: {
-    current: { name: "current", type: "string" },
-    _type: { name: "_type", type: "string" }
-  },
-  geopoint: {
-    lat: { name: "lat", type: "number" },
-    lng: { name: "lng", type: "number" },
-    alt: { name: "alt", type: "number" },
-    _type: { name: "_type", type: "string" }
-  },
-  reference: {
-    _ref: { name: "_ref", type: "string" },
-    _type: { name: "_type", type: "string" },
-    _weak: { name: "_weak", type: "boolean" }
-  },
-  image: {
-    asset: { name: "asset", type: "reference" },
-    hotspot: {
-      name: "hotspot",
-      type: "object",
-      fields: [
-        { name: "x", type: "number" },
-        { name: "y", type: "number" },
-        { name: "height", type: "number" },
-        { name: "width", type: "number" }
-      ]
-    },
-    crop: {
-      name: "crop",
-      type: "object",
-      fields: [
-        { name: "top", type: "number" },
-        { name: "bottom", type: "number" },
-        { name: "left", type: "number" },
-        { name: "right", type: "number" }
-      ]
-    },
-    _type: { name: "_type", type: "string" }
-  },
-  file: {
-    asset: { name: "asset", type: "reference" },
-    _type: { name: "_type", type: "string" }
-  },
-  block: {
-    style: { name: "style", type: "string" },
-    listItem: { name: "listItem", type: "string" },
-    level: { name: "level", type: "number" },
-    children: {
-      name: "children",
-      type: "array",
-      of: [{ name: "span", type: "span" }]
-    },
-    markDefs: {
-      name: "markDefs",
-      type: "array",
-      of: [{ name: "object", type: "object" }]
-    },
-    _type: { name: "_type", type: "string" }
-  },
-  span: {
-    text: { name: "text", type: "string" },
-    marks: {
-      name: "marks",
-      type: "array",
-      of: [{ name: "string", type: "string" }]
-    },
-    _type: { name: "_type", type: "string" }
-  }
-}, DEFAULT_LINK_ANNOTATION = {
-  name: "link",
-  type: "object",
-  fields: [
-    { name: "href", type: "string" },
-    { name: "blank", type: "boolean" }
-  ]
-}, ARRAY_ITEM_SYSTEM_FIELDS = {
-  _key: { name: "_key", type: "string" },
-  _type: { name: "_type", type: "string" }
-};
 function parseOfIndexSyntax(segment) {
   const match = segment.match(/^of\[(\d+)\]$/);
   return match ? parseInt(match[1], 10) : null;
@@ -432,188 +354,6 @@ function filterToPath(type, path, schema) {
   }
   return { ...type, fields: [] };
 }
-function toSchemaPath(path) {
-  return path ? path.replace(/\[append:\d+\]/g, "").replace(/\[_key\s*==\s*["'][^"']*["']\]/g, "").replace(/\[\d+\]/g, "").replace(/\[\]/g, "").replace(/\.{2,}/g, ".").replace(/^\.+|\.+$/g, "") : "";
-}
-const BASE_PRIMITIVES = ["string", "number", "boolean", "date", "datetime", "text", "url", "email"], BLOCK_TYPES = ["block", "reference"];
-function isPrimitiveType(typeName, options = {}) {
-  return typeName ? options.includeBlockTypes ? BASE_PRIMITIVES.includes(typeName) || BLOCK_TYPES.includes(typeName) : BASE_PRIMITIVES.includes(typeName) : !1;
-}
-function isBuiltInType(type) {
-  return BUILT_IN_TYPES.has(type);
-}
-const BUILT_IN_TYPES = /* @__PURE__ */ new Set([
-  "string",
-  "text",
-  "number",
-  "boolean",
-  "array",
-  "object",
-  "reference",
-  "image",
-  "file",
-  "date",
-  "datetime",
-  "url",
-  "slug",
-  "block",
-  "geopoint"
-]);
-function isGenericObject(node) {
-  if (typeof node != "object" || node === null || Array.isArray(node)) return !1;
-  const obj = node;
-  return !obj.fields && !(obj.type === "array" && Array.isArray(obj.of));
-}
-function resolveFieldSchemaAllUnions(path, typeSchema, schema) {
-  const pathParts = toSchemaPath(path).split(".").filter(Boolean);
-  let currentSchemas = [typeSchema];
-  for (let i = 0; i < pathParts.length; i++) {
-    const part = pathParts[i], isLastPart = i === pathParts.length - 1, nextSchemas = [];
-    for (const currentSchema of currentSchemas) {
-      if (!currentSchema?.fields || !Array.isArray(currentSchema.fields))
-        continue;
-      const field = currentSchema.fields.find((f) => f.name === part);
-      if (field)
-        if (field.type === "array" && field.of && field.of.length > 0)
-          for (const itemSchema of field.of) {
-            const itemType = typeof itemSchema.type == "string" ? itemSchema.type : void 0;
-            if (isLastPart && (itemType === "image" || itemType === "file"))
-              nextSchemas.push(itemSchema);
-            else if (itemType && !isBuiltInType(itemType)) {
-              const foundSchema = schema.find((s) => s.name === itemType);
-              foundSchema && nextSchemas.push(foundSchema);
-            } else itemSchema.fields && nextSchemas.push(itemSchema);
-          }
-        else if (field.type && !isBuiltInType(field.type)) {
-          const foundSchema = schema.find((s) => s.name === field.type);
-          if (foundSchema)
-            if (foundSchema.type === "array" && foundSchema.of && foundSchema.of.length > 0)
-              for (const itemSchema of foundSchema.of) {
-                const itemType = typeof itemSchema.type == "string" ? itemSchema.type : void 0;
-                if (isLastPart && (itemType === "image" || itemType === "file"))
-                  nextSchemas.push(itemSchema);
-                else if (itemType && !isBuiltInType(itemType)) {
-                  const itemFoundSchema = schema.find((s) => s.name === itemType);
-                  itemFoundSchema && nextSchemas.push(itemFoundSchema);
-                } else itemSchema.fields && nextSchemas.push(itemSchema);
-              }
-            else
-              nextSchemas.push(foundSchema);
-        } else
-          nextSchemas.push(field);
-    }
-    currentSchemas = nextSchemas;
-  }
-  return currentSchemas;
-}
-function getBuiltInFieldSchema(segment, currentSchema) {
-  if (!currentSchema?.type || !BUILT_IN_TYPE_FIELDS[currentSchema.type]?.[segment])
-    return null;
-  let builtInField = BUILT_IN_TYPE_FIELDS[currentSchema.type][segment];
-  if (currentSchema.type === "block" && segment === "children" && currentSchema.of && (builtInField = {
-    ...builtInField,
-    of: [...builtInField.of || [], ...currentSchema.of]
-  }), currentSchema.type === "block" && segment === "markDefs") {
-    const annotations = currentSchema.marks?.annotations;
-    annotations ? builtInField = {
-      ...builtInField,
-      of: [...builtInField.of || [], ...annotations]
-    } : builtInField = {
-      ...builtInField,
-      of: [...builtInField.of || [], DEFAULT_LINK_ANNOTATION]
-    };
-  }
-  return builtInField;
-}
-function findSchemaInUnionArray(segment, arraySchema, allSchemas, isLastSegment) {
-  if (!arraySchema.of || arraySchema.of.length === 0)
-    return { schema: null, earlyReturn: null };
-  for (const itemSchema of arraySchema.of) {
-    if (BUILT_IN_TYPE_FIELDS[itemSchema.type]?.[segment]) {
-      const builtInField = BUILT_IN_TYPE_FIELDS[itemSchema.type][segment];
-      return isLastSegment ? { schema: null, earlyReturn: builtInField } : { schema: builtInField, earlyReturn: null };
-    }
-    if (itemSchema.fields?.some((f) => f.name === segment))
-      return { schema: itemSchema, earlyReturn: null };
-    if (itemSchema.type && !isPrimitiveType(itemSchema.type)) {
-      const referencedSchema2 = allSchemas.find((s) => s.name === itemSchema.type);
-      if (referencedSchema2?.fields?.some((f) => f.name === segment))
-        return { schema: referencedSchema2, earlyReturn: null };
-    }
-  }
-  const firstItem = arraySchema.of[0];
-  if (firstItem.fields)
-    return { schema: firstItem, earlyReturn: null };
-  const referencedSchema = allSchemas.find((s) => s.name === firstItem.type);
-  return referencedSchema?.fields ? { schema: referencedSchema, earlyReturn: null } : { schema: null, earlyReturn: null };
-}
-function resolveCurrentSchema(segment, currentSchema, allSchemas, isLastSegment) {
-  if (!currentSchema?.type)
-    return { schema: null, earlyReturn: null };
-  if (currentSchema.type === "array" && currentSchema.of && currentSchema.of.length > 0)
-    return findSchemaInUnionArray(segment, currentSchema, allSchemas, isLastSegment);
-  const referencedSchema = allSchemas.find((s) => s.name === currentSchema.type);
-  if (referencedSchema?.fields)
-    return { schema: referencedSchema, earlyReturn: null };
-  if (BUILT_IN_TYPE_FIELDS[currentSchema.type]?.[segment]) {
-    const builtInField = BUILT_IN_TYPE_FIELDS[currentSchema.type][segment];
-    return isLastSegment ? { schema: null, earlyReturn: builtInField } : { schema: builtInField, earlyReturn: null };
-  }
-  return { schema: null, earlyReturn: null };
-}
-function getNextSchemaForField(field, nextSegment, allSchemas) {
-  let resolvedField = field;
-  if (field.type && !isPrimitiveType(field.type) && field.type !== "array") {
-    const referencedSchema = allSchemas.find((s) => s.name === field.type);
-    referencedSchema && (resolvedField = referencedSchema);
-  }
-  if (resolvedField.type === "array" && resolvedField.of && resolvedField.of.length > 0) {
-    for (const itemSchema of resolvedField.of) {
-      if (BUILT_IN_TYPE_FIELDS[itemSchema.type]?.[nextSegment] || itemSchema.fields?.some((f) => f.name === nextSegment))
-        return itemSchema;
-      if (itemSchema.type && !isPrimitiveType(itemSchema.type)) {
-        const refSchema = allSchemas.find((s) => s.name === itemSchema.type);
-        if (refSchema?.fields?.some((f) => f.name === nextSegment))
-          return refSchema;
-      }
-    }
-    return resolvedField.of[0];
-  }
-  return resolvedField;
-}
-function resolveFieldSchema(path, typeSchema, schema) {
-  const segments = toSchemaPath(path).split(".").filter(Boolean);
-  let currentSchema = typeSchema;
-  for (let i = 0; i < segments.length; i++) {
-    const segment = segments[i], isLastSegment = i === segments.length - 1;
-    if (ARRAY_ITEM_SYSTEM_FIELDS[segment])
-      return ARRAY_ITEM_SYSTEM_FIELDS[segment];
-    const builtInField = getBuiltInFieldSchema(segment, currentSchema);
-    if (builtInField) {
-      if (isLastSegment) return builtInField;
-      currentSchema = builtInField;
-      continue;
-    }
-    if (!currentSchema?.fields) {
-      const resolved = resolveCurrentSchema(segment, currentSchema, schema, isLastSegment);
-      if (resolved.earlyReturn) return resolved.earlyReturn;
-      if (!resolved.schema) return null;
-      currentSchema = resolved.schema;
-      const resolvedBuiltInField = getBuiltInFieldSchema(segment, currentSchema);
-      if (resolvedBuiltInField) {
-        if (isLastSegment) return resolvedBuiltInField;
-        currentSchema = resolvedBuiltInField;
-        continue;
-      }
-    }
-    if (!currentSchema?.fields) return null;
-    const field = currentSchema.fields.find((f) => f.name === segment);
-    if (!field) return null;
-    if (isLastSegment) return field;
-    currentSchema = getNextSchemaForField(field, segments[i + 1], schema);
-  }
-  return currentSchema || null;
-}
 function shouldSkipType(typeName) {
   return SCHEMA_CONSTANTS.SKIP_PATTERNS.test(typeName);
 }
@@ -950,8 +690,8 @@ export {
   resolveFieldSchema as navigateToFieldSchema,
   resolveFieldSchemaAllUnions as navigateToFieldSchemaAllUnions,
   processSchema,
-  resolveFieldSchema,
-  resolveFieldSchemaAllUnions,
+  resolveFieldSchema2 as resolveFieldSchema,
+  resolveFieldSchemaAllUnions2 as resolveFieldSchemaAllUnions,
   shouldSkipType,
   toSchemaPath
 };