@sanity/agent-schema 0.1.0 → 0.3.0

package/dist/_chunks-dts/types.d.ts

@@ -0,0 +1,266 @@
+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;
+};
+/** Insert operation structure for patch operations. */
+interface InsertOperation {
+  arrayPath: string;
+  key: string;
+  items: unknown[];
+}
+/** Localization configuration for document-level and field-level translations. */
+type LocalizationConfig = {
+  isFieldLevel: boolean;
+  isDocumentLevel: boolean;
+  isUnknown: boolean;
+  fieldLevel: {
+    languages: Array<{
+      id: string;
+      title: string | null;
+    }>;
+    pluginVersion: 'v4' | 'v5';
+    isV5: boolean;
+  } | null;
+  documentLevel: {
+    languageField: string | null;
+    currentLanguage: string | null;
+    existingTranslations: Array<{
+      locale: string;
+      documentId: string | null;
+    }>;
+    availableLanguages: string[];
+    pluginVersion: 'v4' | 'v5';
+  } | null;
+};
+/**
+ * Error codes for validation errors.
+ * Used for programmatic handling of specific error types.
+ */
+type ValidationErrorCode = 'TYPE_MISMATCH' | 'REQUIRED_FIELD_MISSING' | 'FIELD_NOT_IN_SCHEMA' | 'INVALID_FORMAT' | 'INVALID_REFERENCE' | 'REFERENCE_NOT_FOUND' | 'REFERENCE_WRONG_TYPE' | 'ARRAY_ITEM_INVALID' | 'VALUE_OUT_OF_RANGE' | 'INVALID_ENUM_VALUE' | 'DUPLICATE_ARRAY_ITEM' | 'INVALID_IMAGE_PATH' | 'IMAGE_NOT_FOUND' | 'INVALID_MARK_REFERENCE' | 'INVALID_PATH' | 'INVALID_LANGUAGE';
+/**
+ * A validation error with actionable information.
+ *
+ * Error messages follow the format:
+ * At path "{path}": {message}
+ *   Received: {received}
+ *   Expected: {expected}
+ *   Fix: {fix}
+ */
+interface ValidationError {
+  /** Field path (e.g., "author.name", "tags[0]") */
+  path: string;
+  /** Error code for programmatic handling */
+  code: ValidationErrorCode;
+  /** Human-readable error message */
+  message: string;
+  /** String representation of actual value received */
+  received: string;
+  /** Description of expected value */
+  expected: string;
+  /** Actionable fix advice */
+  fix: string;
+  /** When set, this error is for a specific item in an array and can be resolved by filtering that item */
+  itemIndex?: number;
+  /** The array field path this item belongs to (e.g., "content") — set alongside itemIndex */
+  arrayPath?: string;
+}
+/**
+ * Result of a validation operation.
+ */
+interface ValidationResult {
+  /** Whether validation passed with no errors */
+  valid: boolean;
+  /** List of validation errors (empty if valid) */
+  errors: ValidationError[];
+  /** List of warning-level validation issues (non-blocking) */
+  warnings: ValidationError[];
+}
+/**
+ * Context for validation operations.
+ */
+interface ValidationContext {
+  /** The document type name */
+  documentType: string;
+  /** Target document ID (for reference validation in drafts) */
+  targetDocumentId?: string;
+  /** Existing document state (for patch operations) */
+  existingDocument?: Record<string, unknown>;
+  /** Sanity client for reference existence checks */
+  client?: SanityClient;
+  /** Localization config for language field validation */
+  localizationConfig?: LocalizationConfig;
+}
+/**
+ * Patch operations structure from patch.tool.ts
+ */
+interface PatchOperations {
+  set?: Array<{
+    path: string;
+    value?: unknown;
+  }>;
+  unset?: string[];
+  append?: Array<{
+    path: string;
+    items: unknown[];
+  }>;
+  insertBefore?: InsertOperation[];
+  insertAfter?: InsertOperation[];
+}
+/**
+ * Result of field schema lookup at a path.
+ */
+interface FieldSchemaLookupResult {
+  /** All possible schemas at the path (for union types in arrays) */
+  schemas: ManifestSchemaType[] | null;
+  /** Validation errors if path is invalid */
+  errors: ValidationError[];
+}
+/**
+ * Type for the recursive validateValue function.
+ * Used to pass validateValue to validators that need recursion.
+ */
+type ValidateValueFn = (value: unknown, fieldSchema: ManifestSchemaType, path: string, errors: ValidationError[], context: ValidationContext, schema: ManifestSchemaType[], warnings?: ValidationError[]) => Promise<void>;
+export { SchemaFieldDisplayOptions as _, ValidateValueFn as a, SchemaTypes as b, ValidationErrorCode as c, DatasetStats as d, DatasetStatsSchema as f, ProcessedDocumentType as g, ManifestSchemaType as h, PatchOperations as i, ValidationResult as l, ManifestField as m, InsertOperation as n, ValidationContext as o, LexiconResponse as p, LocalizationConfig as r, ValidationError as s, FieldSchemaLookupResult as t, CompressedSchemaOptions as u, SchemaFilter as v, SchemaProcessorOptions as y };
+//# sourceMappingURL=types.d.ts.map

package/dist/_chunks-dts/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/types.ts","../../src/validation/types.ts"],"mappings":"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"}

package/dist/_chunks-es/walkTree.js

@@ -0,0 +1,312 @@
+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 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;
+}
+const joinSchemaPath = (parent, child) => parent ? `${parent}.${child}` : child, findReferencedType = (field, schema) => {
+  if (!isPrimitiveType(field.type))
+    return schema.find((s) => s.name === field.type);
+};
+function walkArrayItems(field, path, schema, visited, visit) {
+  if (field.of?.length)
+    for (const rawItem of field.of) {
+      const item = rawItem;
+      if (item.fields?.length) {
+        walkFields(item.fields, path, schema, visited, visit);
+        continue;
+      }
+      if (!item.type || isPrimitiveType(item.type)) continue;
+      const referenced = schema.find((s) => s.name === item.type);
+      !referenced || visited.has(referenced.name) || referenced.fields?.length && (visited.add(referenced.name), walkFields(referenced.fields, path, schema, visited, visit));
+    }
+}
+function walkFields(fields, path, schema, visited, visit) {
+  for (const field of fields) {
+    const fieldPath = joinSchemaPath(path, field.name);
+    if (visit(field, fieldPath), field.fields?.length) {
+      walkFields(field.fields, fieldPath, schema, visited, visit);
+      continue;
+    }
+    if (field.of?.length) {
+      walkArrayItems(field, fieldPath, schema, visited, visit);
+      continue;
+    }
+    const referenced = findReferencedType(field, schema);
+    referenced?.fields?.length && (visited.has(referenced.name) || (visited.add(referenced.name), walkFields(referenced.fields, fieldPath, schema, visited, visit)));
+  }
+}
+function walkSchemaTree(documentType, schema, visit) {
+  const typeSchema = schema.find((s) => s.name === documentType);
+  typeSchema?.fields?.length && walkFields(typeSchema.fields, "", schema, /* @__PURE__ */ new Set([typeSchema.name]), visit);
+}
+export {
+  ARRAY_ITEM_SYSTEM_FIELDS,
+  BUILT_IN_TYPE_FIELDS,
+  DEFAULT_LINK_ANNOTATION,
+  isBuiltInType,
+  isGenericObject,
+  isPrimitiveType,
+  joinSchemaPath,
+  resolveFieldSchema,
+  resolveFieldSchemaAllUnions,
+  toSchemaPath,
+  walkSchemaTree
+};
+//# sourceMappingURL=walkTree.js.map

package/dist/_chunks-es/walkTree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"walkTree.js","sources":["../../src/navigate/constants.ts","../../src/navigate/path.ts","../../src/navigate/types.ts","../../src/navigate/navigateAllUnions.ts","../../src/navigate/navigateToField.ts","../../src/navigate/walkTree.ts"],"sourcesContent":["import type { ManifestSchemaType } from '../types.js'\n\n/**\n * Built-in Sanity type fields that exist implicitly (not in schema).\n * Maps type name to field definitions.\n */\nexport const BUILT_IN_TYPE_FIELDS: Record<string, Record<string, ManifestSchemaType>> = {\n  slug: {\n    current: { name: 'current', type: 'string' } as ManifestSchemaType,\n    _type: { name: '_type', type: 'string' } as ManifestSchemaType,\n  },\n  geopoint: {\n    lat: { name: 'lat', type: 'number' } as ManifestSchemaType,\n    lng: { name: 'lng', type: 'number' } as ManifestSchemaType,\n    alt: { name: 'alt', type: 'number' } as ManifestSchemaType,\n    _type: { name: '_type', type: 'string' } as ManifestSchemaType,\n  },\n  reference: {\n    _ref: { name: '_ref', type: 'string' } as ManifestSchemaType,\n    _type: { name: '_type', type: 'string' } as ManifestSchemaType,\n    _weak: { name: '_weak', type: 'boolean' } as ManifestSchemaType,\n  },\n  image: {\n    asset: { name: 'asset', type: 'reference' } as ManifestSchemaType,\n    hotspot: {\n      name: 'hotspot',\n      type: 'object',\n      fields: [\n        { name: 'x', type: 'number' },\n        { name: 'y', type: 'number' },\n        { name: 'height', type: 'number' },\n        { name: 'width', type: 'number' },\n      ],\n    } as ManifestSchemaType,\n    crop: {\n      name: 'crop',\n      type: 'object',\n      fields: [\n        { name: 'top', type: 'number' },\n        { name: 'bottom', type: 'number' },\n        { name: 'left', type: 'number' },\n        { name: 'right', type: 'number' },\n      ],\n    } as ManifestSchemaType,\n    _type: { name: '_type', type: 'string' } as ManifestSchemaType,\n  },\n  file: {\n    asset: { name: 'asset', type: 'reference' } as ManifestSchemaType,\n    _type: { name: '_type', type: 'string' } as ManifestSchemaType,\n  },\n  block: {\n    style: { name: 'style', type: 'string' } as ManifestSchemaType,\n    listItem: { name: 'listItem', type: 'string' } as ManifestSchemaType,\n    level: { name: 'level', type: 'number' } as ManifestSchemaType,\n    children: {\n      name: 'children',\n      type: 'array',\n      of: [{ name: 'span', type: 'span' }],\n    } as ManifestSchemaType,\n    markDefs: {\n      name: 'markDefs',\n      type: 'array',\n      of: [{ name: 'object', type: 'object' }],\n    } as ManifestSchemaType,\n    _type: { name: '_type', type: 'string' } as ManifestSchemaType,\n  },\n  span: {\n    text: { name: 'text', type: 'string' } as ManifestSchemaType,\n    marks: {\n      name: 'marks',\n      type: 'array',\n      of: [{ name: 'string', type: 'string' }],\n    } as ManifestSchemaType,\n    _type: { name: '_type', type: 'string' } as ManifestSchemaType,\n  },\n}\n\n/**\n * Default annotation type for Portable Text blocks.\n * Sanity implicitly includes \"link\" when no marks.annotations are declared.\n */\nexport const DEFAULT_LINK_ANNOTATION: ManifestSchemaType = {\n  name: 'link',\n  type: 'object',\n  fields: [\n    { name: 'href', type: 'string' },\n    { name: 'blank', type: 'boolean' },\n  ],\n} as ManifestSchemaType\n\n/**\n * System fields that exist on all array items.\n */\nexport const ARRAY_ITEM_SYSTEM_FIELDS: Record<string, ManifestSchemaType> = {\n  _key: { name: '_key', type: 'string' } as ManifestSchemaType,\n  _type: { name: '_type', type: 'string' } as ManifestSchemaType,\n}\n","/**\n * Convert a document path string to a schema path string.\n * Strips array indices, _key selectors, and internal markers.\n *\n * Examples:\n * - `\"content[_key==\\\"abc\\\"].children[0].text\"` → `\"content.children.text\"`\n * - `\"tags[0]\"` → `\"tags\"`\n * - `\"seo.image.asset\"` → `\"seo.image.asset\"`\n * - `\"items[append:3]\"` → `\"items\"`\n *\n * This is a self-contained implementation that avoids depending on\n * `@sanity/types` for path segment parsing.\n */\nexport function toSchemaPath(path: string): string {\n  if (!path) return ''\n\n  return (\n    path\n      // Strip internal markers: [append:N]\n      .replace(/\\[append:\\d+\\]/g, '')\n      // Strip _key selectors: [_key==\"value\"] or [_key=='value']\n      .replace(/\\[_key\\s*==\\s*[\"'][^\"']*[\"']\\]/g, '')\n      // Strip numeric indices: [0], [123]\n      .replace(/\\[\\d+\\]/g, '')\n      // Strip empty brackets: []\n      .replace(/\\[\\]/g, '')\n      // Collapse any resulting double dots\n      .replace(/\\.{2,}/g, '.')\n      // Trim leading/trailing dots\n      .replace(/^\\.+|\\.+$/g, '')\n  )\n}\n","const BASE_PRIMITIVES = ['string', 'number', 'boolean', 'date', 'datetime', 'text', 'url', 'email']\n\nconst BLOCK_TYPES = ['block', 'reference']\n\n/**\n * Check if a type name represents a primitive type.\n *\n * When `includeBlockTypes` is true, 'block' and 'reference' are also\n * considered primitive (useful for navigator/large-node detection where\n * you don't want to drill into these).\n */\nexport function isPrimitiveType(\n  typeName: string | undefined,\n  options: { includeBlockTypes?: boolean } = {},\n): boolean {\n  if (!typeName) return false\n  if (options.includeBlockTypes) {\n    return BASE_PRIMITIVES.includes(typeName) || BLOCK_TYPES.includes(typeName)\n  }\n  return BASE_PRIMITIVES.includes(typeName)\n}\n\n/**\n * Check if a type is a built-in Sanity type (superset of primitives).\n * Includes complex built-in types like array, object, image, file, slug, etc.\n */\nexport function isBuiltInType(type: string): boolean {\n  return BUILT_IN_TYPES.has(type)\n}\n\nconst BUILT_IN_TYPES = new Set([\n  'string',\n  'text',\n  'number',\n  'boolean',\n  'array',\n  'object',\n  'reference',\n  'image',\n  'file',\n  'date',\n  'datetime',\n  'url',\n  'slug',\n  'block',\n  'geopoint',\n])\n\n/**\n * Check if a node is a generic object-like node.\n * Generic objects are objects that don't have a `fields` array and\n * aren't array types with `of`. These include block types and other\n * object-shaped schemas with properties like marks, lists, styles, etc.\n */\nexport function isGenericObject(node: unknown): boolean {\n  if (typeof node !== 'object' || node === null || Array.isArray(node)) return false\n  const obj = node as Record<string, unknown>\n  return !obj.fields && !(obj.type === 'array' && Array.isArray(obj.of))\n}\n","import type { ManifestSchemaType } from '../types.js'\nimport { toSchemaPath } from './path.js'\nimport { isBuiltInType } from './types.js'\n\n/**\n * Resolves a document path to field schemas, returning ALL possible schemas for union types.\n * This is important for arrays with multiple `of` types where a field might exist\n * in some but not all union types.\n */\nexport function resolveFieldSchemaAllUnions(\n  path: string,\n  typeSchema: ManifestSchemaType,\n  schema: ManifestSchemaType[],\n): ManifestSchemaType[] {\n  const pathParts = toSchemaPath(path).split('.').filter(Boolean)\n\n  let currentSchemas: ManifestSchemaType[] = [typeSchema]\n\n  for (let i = 0; i < pathParts.length; i++) {\n    const part = pathParts[i]\n    const isLastPart = i === pathParts.length - 1\n    const nextSchemas: ManifestSchemaType[] = []\n\n    for (const currentSchema of currentSchemas) {\n      if (!currentSchema?.fields || !Array.isArray(currentSchema.fields)) {\n        continue\n      }\n\n      const field = currentSchema.fields.find((f) => f.name === part)\n      if (!field) continue\n\n      if (field.type === 'array' && field.of && field.of.length > 0) {\n        for (const itemSchema of field.of) {\n          const itemType = typeof itemSchema.type === 'string' ? itemSchema.type : undefined\n          if (isLastPart && (itemType === 'image' || itemType === 'file')) {\n            nextSchemas.push(itemSchema as ManifestSchemaType)\n          } else if (itemType && !isBuiltInType(itemType)) {\n            const foundSchema = schema.find((s) => s.name === itemType)\n            if (foundSchema) nextSchemas.push(foundSchema)\n          } else if ((itemSchema as ManifestSchemaType).fields) {\n            nextSchemas.push(itemSchema as ManifestSchemaType)\n          }\n        }\n      } else if (field.type && !isBuiltInType(field.type)) {\n        const foundSchema = schema.find((s) => s.name === field.type)\n        if (foundSchema) {\n          if (foundSchema.type === 'array' && foundSchema.of && foundSchema.of.length > 0) {\n            for (const itemSchema of foundSchema.of) {\n              const itemType = typeof itemSchema.type === 'string' ? itemSchema.type : undefined\n              if (isLastPart && (itemType === 'image' || itemType === 'file')) {\n                nextSchemas.push(itemSchema as ManifestSchemaType)\n              } else if (itemType && !isBuiltInType(itemType)) {\n                const itemFoundSchema = schema.find((s) => s.name === itemType)\n                if (itemFoundSchema) nextSchemas.push(itemFoundSchema)\n              } else if ((itemSchema as ManifestSchemaType).fields) {\n                nextSchemas.push(itemSchema as ManifestSchemaType)\n              }\n            }\n          } else {\n            nextSchemas.push(foundSchema)\n          }\n        }\n      } else {\n        nextSchemas.push(field as ManifestSchemaType)\n      }\n    }\n\n    currentSchemas = nextSchemas\n  }\n\n  return currentSchemas\n}\n","import type { ManifestField, ManifestSchemaType } from '../types.js'\nimport {\n  ARRAY_ITEM_SYSTEM_FIELDS,\n  BUILT_IN_TYPE_FIELDS,\n  DEFAULT_LINK_ANNOTATION,\n} from './constants.js'\nimport { toSchemaPath } from './path.js'\nimport { isPrimitiveType } from './types.js'\n\ninterface SchemaResolutionResult {\n  schema: ManifestSchemaType | null\n  earlyReturn: ManifestSchemaType | null\n}\n\nfunction getBuiltInFieldSchema(\n  segment: string,\n  currentSchema: ManifestSchemaType,\n): ManifestSchemaType | null {\n  if (!currentSchema?.type || !BUILT_IN_TYPE_FIELDS[currentSchema.type]?.[segment]) {\n    return null\n  }\n\n  let builtInField: ManifestSchemaType = BUILT_IN_TYPE_FIELDS[currentSchema.type][segment]\n\n  // For block.children, merge in block.of (inline objects) from the schema\n  if (currentSchema.type === 'block' && segment === 'children' && currentSchema.of) {\n    builtInField = {\n      ...builtInField,\n      of: [...(builtInField.of || []), ...(currentSchema.of as ManifestSchemaType[])],\n    }\n  }\n\n  // For block.markDefs, merge in block.marks.annotations from the schema\n  // If no annotations are declared, add default \"link\" annotation (Sanity built-in)\n  if (currentSchema.type === 'block' && segment === 'markDefs') {\n    const annotations = (\n      currentSchema as ManifestSchemaType & { marks?: { annotations?: ManifestSchemaType[] } }\n    ).marks?.annotations\n    if (annotations) {\n      builtInField = {\n        ...builtInField,\n        of: [...(builtInField.of || []), ...annotations],\n      }\n    } else {\n      builtInField = {\n        ...builtInField,\n        of: [...(builtInField.of || []), DEFAULT_LINK_ANNOTATION],\n      }\n    }\n  }\n\n  return builtInField\n}\n\nfunction findSchemaInUnionArray(\n  segment: string,\n  arraySchema: ManifestSchemaType,\n  allSchemas: ManifestSchemaType[],\n  isLastSegment: boolean,\n): SchemaResolutionResult {\n  if (!arraySchema.of || arraySchema.of.length === 0) {\n    return { schema: null, earlyReturn: null }\n  }\n\n  for (const itemSchema of arraySchema.of as ManifestSchemaType[]) {\n    if (BUILT_IN_TYPE_FIELDS[itemSchema.type]?.[segment]) {\n      const builtInField = BUILT_IN_TYPE_FIELDS[itemSchema.type][segment]\n      if (isLastSegment) {\n        return { schema: null, earlyReturn: builtInField }\n      }\n      return { schema: builtInField, earlyReturn: null }\n    }\n\n    if (itemSchema.fields?.some((f) => f.name === segment)) {\n      return { schema: itemSchema, earlyReturn: null }\n    }\n\n    if (itemSchema.type && !isPrimitiveType(itemSchema.type)) {\n      const referencedSchema = allSchemas.find((s) => s.name === itemSchema.type)\n      if (referencedSchema?.fields?.some((f) => f.name === segment)) {\n        return { schema: referencedSchema, earlyReturn: null }\n      }\n    }\n  }\n\n  const firstItem = arraySchema.of[0] as ManifestSchemaType\n  if (firstItem.fields) {\n    return { schema: firstItem, earlyReturn: null }\n  }\n\n  const referencedSchema = allSchemas.find((s) => s.name === firstItem.type)\n  if (referencedSchema?.fields) {\n    return { schema: referencedSchema, earlyReturn: null }\n  }\n\n  return { schema: null, earlyReturn: null }\n}\n\nfunction resolveCurrentSchema(\n  segment: string,\n  currentSchema: ManifestSchemaType,\n  allSchemas: ManifestSchemaType[],\n  isLastSegment: boolean,\n): SchemaResolutionResult {\n  if (!currentSchema?.type) {\n    return { schema: null, earlyReturn: null }\n  }\n\n  if (currentSchema.type === 'array' && currentSchema.of && currentSchema.of.length > 0) {\n    return findSchemaInUnionArray(segment, currentSchema, allSchemas, isLastSegment)\n  }\n\n  const referencedSchema = allSchemas.find((s) => s.name === currentSchema.type)\n  if (referencedSchema?.fields) {\n    return { schema: referencedSchema, earlyReturn: null }\n  }\n\n  if (BUILT_IN_TYPE_FIELDS[currentSchema.type]?.[segment]) {\n    const builtInField = BUILT_IN_TYPE_FIELDS[currentSchema.type][segment]\n    if (isLastSegment) {\n      return { schema: null, earlyReturn: builtInField }\n    }\n    return { schema: builtInField, earlyReturn: null }\n  }\n\n  return { schema: null, earlyReturn: null }\n}\n\nfunction getNextSchemaForField(\n  field: ManifestField,\n  nextSegment: string,\n  allSchemas: ManifestSchemaType[],\n): ManifestSchemaType {\n  let resolvedField: ManifestSchemaType = field as ManifestSchemaType\n  if (field.type && !isPrimitiveType(field.type) && field.type !== 'array') {\n    const referencedSchema = allSchemas.find((s) => s.name === field.type)\n    if (referencedSchema) {\n      resolvedField = referencedSchema\n    }\n  }\n\n  if (resolvedField.type === 'array' && resolvedField.of && resolvedField.of.length > 0) {\n    for (const itemSchema of resolvedField.of as ManifestSchemaType[]) {\n      if (BUILT_IN_TYPE_FIELDS[itemSchema.type]?.[nextSegment]) {\n        return itemSchema\n      }\n      if (itemSchema.fields?.some((f) => f.name === nextSegment)) {\n        return itemSchema\n      }\n      if (itemSchema.type && !isPrimitiveType(itemSchema.type)) {\n        const refSchema = allSchemas.find((s) => s.name === itemSchema.type)\n        if (refSchema?.fields?.some((f) => f.name === nextSegment)) {\n          return refSchema\n        }\n      }\n    }\n    return resolvedField.of[0] as ManifestSchemaType\n  }\n\n  return resolvedField\n}\n\n/**\n * Resolves a document path to the field schema at that location.\n * Handles nested paths like \"author.name\" and array paths like \"tags[0]\".\n *\n * Returns the field schema at the path, NOT navigating into arrays.\n * For \"tags\" (an array field), returns the array field schema (with 'of').\n * For \"tags[0].foo\", returns the \"foo\" field from the array item schema.\n */\nexport function resolveFieldSchema(\n  path: string,\n  typeSchema: ManifestSchemaType,\n  schema: ManifestSchemaType[],\n): ManifestSchemaType | null {\n  const segments = toSchemaPath(path).split('.').filter(Boolean)\n\n  let currentSchema: ManifestSchemaType | undefined = typeSchema\n\n  for (let i = 0; i < segments.length; i++) {\n    const segment = segments[i]\n    const isLastSegment = i === segments.length - 1\n\n    if (ARRAY_ITEM_SYSTEM_FIELDS[segment]) {\n      return ARRAY_ITEM_SYSTEM_FIELDS[segment]\n    }\n\n    const builtInField = getBuiltInFieldSchema(segment, currentSchema!)\n    if (builtInField) {\n      if (isLastSegment) return builtInField\n      currentSchema = builtInField\n      continue\n    }\n\n    if (!currentSchema?.fields) {\n      const resolved = resolveCurrentSchema(segment, currentSchema!, schema, isLastSegment)\n      if (resolved.earlyReturn) return resolved.earlyReturn\n      if (!resolved.schema) return null\n      currentSchema = resolved.schema\n\n      const resolvedBuiltInField = getBuiltInFieldSchema(segment, currentSchema)\n      if (resolvedBuiltInField) {\n        if (isLastSegment) return resolvedBuiltInField\n        currentSchema = resolvedBuiltInField\n        continue\n      }\n    }\n\n    if (!currentSchema?.fields) return null\n\n    const field = currentSchema.fields.find((f) => f.name === segment)\n    if (!field) return null\n    if (isLastSegment) return field\n\n    currentSchema = getNextSchemaForField(field, segments[i + 1], schema)\n  }\n\n  return currentSchema || null\n}\n","/**\n * Whole-tree schema walker.\n *\n * Where `navigateToField` and `navigateAllUnions` resolve a single path string\n * to its field schema, this walks every reachable field in a document type.\n * Used by validators that need to inspect the full schema graph (required\n * fields, custom validators).\n *\n * Handles:\n * - Inline objects (`field.fields`)\n * - Aliased object types (looked up in the schema array)\n * - Arrays of objects (`field.of` items recursed with the same logic)\n *\n * Cycles are guarded by tracking visited type names. Built-in primitive types\n * are skipped: there's nothing to walk into.\n */\n\nimport type { ManifestField, ManifestSchemaType } from '../types.js'\nimport { isPrimitiveType } from './types.js'\n\nexport type WalkVisitor = (field: ManifestField, path: string) => void\n\nexport const joinSchemaPath = (parent: string, child: string): string =>\n  parent ? `${parent}.${child}` : child\n\nconst findReferencedType = (\n  field: ManifestField,\n  schema: ManifestSchemaType[],\n): ManifestSchemaType | undefined => {\n  if (isPrimitiveType(field.type)) return undefined\n  return schema.find((s) => s.name === field.type)\n}\n\nfunction walkArrayItems(\n  field: ManifestField,\n  path: string,\n  schema: ManifestSchemaType[],\n  visited: Set<string>,\n  visit: WalkVisitor,\n): void {\n  if (!field.of?.length) return\n\n  for (const rawItem of field.of) {\n    const item = rawItem as ManifestSchemaType\n    // Inline object items in `of` carry their own fields; aliased items just\n    // reference a type by name and need a schema lookup.\n    if (item.fields?.length) {\n      walkFields(item.fields, path, schema, visited, visit)\n      continue\n    }\n    if (!item.type || isPrimitiveType(item.type)) continue\n    const referenced = schema.find((s) => s.name === item.type)\n    if (!referenced || visited.has(referenced.name)) continue\n    if (referenced.fields?.length) {\n      visited.add(referenced.name)\n      walkFields(referenced.fields, path, schema, visited, visit)\n    }\n  }\n}\n\nfunction walkFields(\n  fields: ManifestField[],\n  path: string,\n  schema: ManifestSchemaType[],\n  visited: Set<string>,\n  visit: WalkVisitor,\n): void {\n  for (const field of fields) {\n    const fieldPath = joinSchemaPath(path, field.name)\n    visit(field, fieldPath)\n\n    if (field.fields?.length) {\n      walkFields(field.fields, fieldPath, schema, visited, visit)\n      continue\n    }\n\n    if (field.of?.length) {\n      walkArrayItems(field, fieldPath, schema, visited, visit)\n      continue\n    }\n\n    const referenced = findReferencedType(field, schema)\n    if (!referenced?.fields?.length) continue\n    if (visited.has(referenced.name)) continue\n\n    visited.add(referenced.name)\n    walkFields(referenced.fields, fieldPath, schema, visited, visit)\n  }\n}\n\n/**\n * Visit every field reachable from a document type. The visitor is called once\n * per field with the field schema and its dotted path from the document root.\n */\nexport function walkSchemaTree(\n  documentType: string,\n  schema: ManifestSchemaType[],\n  visit: WalkVisitor,\n): void {\n  const typeSchema = schema.find((s) => s.name === documentType)\n  if (!typeSchema?.fields?.length) return\n\n  walkFields(typeSchema.fields, '', schema, new Set([typeSchema.name]), visit)\n}\n"],"names":["referencedSchema"],"mappings":"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"}