@sanity/assist 4.4.5 → 4.4.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/assist",
-  "version": "4.4.5",
+  "version": "4.4.7",
   "description": "You create the instructions; Sanity AI Assist does the rest.",
   "keywords": [
     "sanity",
@@ -83,7 +83,7 @@
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "rimraf": "^5.0.5",
-    "sanity": "^3.93.0",
+    "sanity": "^4.0.0",
     "semantic-release": "^23.0.8",
     "styled-components": "^6.1.16",
     "typescript": "^5.7.2",

package/src/assistDocument/AssistDocumentContext.tsx

@@ -1,7 +1,7 @@
 import {createContext, useContext} from 'react'
 import {DocumentInspector, ObjectSchemaType, PatchEvent} from 'sanity'
 
-import {InstructionTask, SerializedSchemaType, StudioAssistDocument} from '../types'
+import {InstructionTask, StudioAssistDocument} from '../types'
 import {FieldRef} from '../assistInspector/helpers'
 
 export type AssistDocumentContextValue = (
@@ -36,8 +36,6 @@ export type AssistDocumentContextValue = (
 
   fieldRefs: FieldRef[]
   fieldRefsByTypePath: Record<string, FieldRef | undefined>
-
-  serializedTypes: SerializedSchemaType[]
 }
 
 export const AssistDocumentContext = createContext<AssistDocumentContextValue | undefined>(

package/src/assistDocument/hooks/useAssistDocumentContextValue.tsx

@@ -1,21 +1,17 @@
 import {useCallback, useEffect, useMemo, useState} from 'react'
 import {getDraftId, getVersionId, type ObjectSchemaType, useSchema} from 'sanity'
 import {useDocumentPane} from 'sanity/structure'
-
-import {asFieldRefsByTypePath, getFieldRefs, useAiPaneRouter} from '../../assistInspector/helpers'
 import {fieldPathParam, InstructionTask} from '../../types'
-import {AssistDocumentContextValue, useAssistDocumentContext} from '../AssistDocumentContext'
+import {AssistDocumentContextValue} from '../AssistDocumentContext'
 import {isDocAssistable} from '../RequestRunInstructionProvider'
 import {useStudioAssistDocument} from './useStudioAssistDocument'
-import {serializeSchema} from '../../schemas/serialize/serializeSchema'
-
-export function useSerializedTypes() {
-  return useAssistDocumentContext().serializedTypes
-}
+import {useAiAssistanceConfig} from '../../assistLayout/AiAssistanceConfigContext'
+import {useAiPaneRouter} from '../../assistInspector/helpers'
 
 export function useAssistDocumentContextValue(documentId: string, documentType: string) {
   const schema = useSchema()
 
+  const {getFieldRefs, getFieldRefsByTypePath} = useAiAssistanceConfig()
   const documentSchemaType = useMemo(() => {
     const schemaType = schema.get(documentType) as ObjectSchemaType | undefined
     if (!schemaType) {
@@ -24,16 +20,12 @@ export function useAssistDocumentContextValue(documentId: string, documentType:
     return schemaType
   }, [documentType, schema])
 
-  const serializedTypes = useMemo(() => serializeSchema(schema, {leanFormat: true}), [schema])
-
   const {fieldRefs, fieldRefsByTypePath} = useMemo(() => {
-    const fieldRefs = getFieldRefs(documentSchemaType)
-    const fieldRefsByTypePath = asFieldRefsByTypePath(fieldRefs)
     return {
-      fieldRefs,
-      fieldRefsByTypePath,
+      fieldRefs: getFieldRefs(documentType),
+      fieldRefsByTypePath: getFieldRefsByTypePath(documentType),
     }
-  }, [documentSchemaType])
+  }, [getFieldRefs, getFieldRefsByTypePath, documentType])
 
   const {
     openInspector,
@@ -86,7 +78,6 @@ export function useAssistDocumentContextValue(documentId: string, documentType:
       removeSyntheticTask,
       fieldRefs,
       fieldRefsByTypePath,
-      serializedTypes,
     }
     if (!assistDocument) {
       return {...base, loading: true, assistDocument: undefined}
@@ -112,7 +103,6 @@ export function useAssistDocumentContextValue(documentId: string, documentType:
     removeSyntheticTask,
     fieldRefs,
     fieldRefsByTypePath,
-    serializedTypes,
   ])
 
   return value

package/src/assistInspector/FieldAutocomplete.tsx

@@ -4,7 +4,8 @@ import {createElement, useCallback, useMemo} from 'react'
 import {ObjectSchemaType} from 'sanity'
 
 import {isType} from '../helpers/typeUtils'
-import {FieldRef, getFieldRefs, getFieldRefsWithDocument} from './helpers'
+import {FieldRef, getDocumentFieldRef} from './helpers'
+import {useAiAssistanceConfig} from '../assistLayout/AiAssistanceConfigContext'
 
 interface FieldSelectorProps {
   id: string
@@ -18,12 +19,16 @@ interface FieldSelectorProps {
 export function FieldAutocomplete(props: FieldSelectorProps) {
   const {id, schemaType, fieldPath, onSelect, includeDocument, filter} = props
 
+  const {getFieldRefs} = useAiAssistanceConfig()
+
   const fieldRefs = useMemo(() => {
+    const refs = getFieldRefs(schemaType.name)
     if (includeDocument) {
-      return getFieldRefsWithDocument(schemaType)
+      return [getDocumentFieldRef(schemaType), ...refs]
     }
-    return getFieldRefs(schemaType)
-  }, [schemaType, includeDocument])
+    return refs
+  }, [schemaType, includeDocument, getFieldRefs])
+
   const currentField = useMemo(
     () => fieldRefs.find((f) => f.key === fieldPath),
     [fieldPath, fieldRefs],

package/src/assistInspector/helpers.ts

@@ -8,7 +8,7 @@ import {
   StringIcon,
 } from '@sanity/icons'
 import {extractWithPath} from '@sanity/mutator'
-import {type ComponentType, useContext, useMemo} from 'react'
+import {type ComponentType, useMemo} from 'react'
 import {
   type ArraySchemaType,
   isKeySegment,
@@ -21,11 +21,10 @@ import {
   stringToPath,
 } from 'sanity'
 import {type PaneRouterContextValue, usePaneRouter} from 'sanity/structure'
-
-import {SelectedFieldContext} from '../assistDocument/components/SelectedFieldContext'
 import {isAssistSupported} from '../helpers/assistSupported'
 import {isPortableTextArray, isType} from '../helpers/typeUtils'
-import {type AssistInspectorRouteParams, documentRootKey, fieldPathParam} from '../types'
+import {type AssistInspectorRouteParams, documentRootKey} from '../types'
+import {useAiAssistanceConfig} from '../assistLayout/AiAssistanceConfigContext'
 
 export interface FieldRef {
   key: string
@@ -65,19 +64,14 @@ export function asFieldRefsByTypePath(fieldRefs: FieldRef[]): Record<string, Fie
   return lookup
 }
 
-export function getFieldRefsWithDocument(schemaType: ObjectSchemaType): FieldRef[] {
-  const fields = getFieldRefs(schemaType)
-  return [
-    {
-      key: documentRootKey,
-      icon: schemaType.icon ?? DocumentIcon,
-      title: `The entire document`,
-      path: [],
-      schemaType: schemaType,
-    },
-
-    ...fields,
-  ]
+export function getDocumentFieldRef(schemaType: ObjectSchemaType) {
+  return {
+    key: documentRootKey,
+    icon: schemaType.icon ?? DocumentIcon,
+    title: `The entire document`,
+    path: [],
+    schemaType: schemaType,
+  }
 }
 
 export function getFieldRefs(
@@ -182,12 +176,14 @@ export function useSelectedField(
   documentSchemaType?: SchemaType,
   path?: string,
 ): FieldRef | undefined {
+  const {getFieldRefs} = useAiAssistanceConfig()
+
   const selectableFields = useMemo(
     () =>
       documentSchemaType && isObjectSchemaType(documentSchemaType)
-        ? getFieldRefsWithDocument(documentSchemaType)
+        ? [getDocumentFieldRef(documentSchemaType), ...getFieldRefs(documentSchemaType.name)]
         : [],
-    [documentSchemaType],
+    [documentSchemaType, getFieldRefs],
   )
 
   return useMemo(() => {
@@ -195,13 +191,6 @@ export function useSelectedField(
   }, [selectableFields, path])
 }
 
-export function useSelectedFieldTitle() {
-  const {params} = useAiPaneRouter()
-  const {documentSchema} = useContext(SelectedFieldContext) ?? {}
-  const selectedField = useSelectedField(documentSchema, params[fieldPathParam])
-  return getFieldTitle(selectedField)
-}
-
 export function getFieldTitle(field?: FieldRef) {
   const schemaType = field?.schemaType
   return field?.title ?? schemaType?.title ?? schemaType?.name ?? 'Untitled'

package/src/assistLayout/AiAssistanceConfigContext.tsx

@@ -1,15 +1,9 @@
-import {
-  createContext,
-  ReactNode,
-  useCallback,
-  useContext,
-  useEffect,
-  useMemo,
-  useState,
-} from 'react'
+import {createContext, useContext} from 'react'
 
 import {AssistPluginConfig} from '../plugin'
-import {InstructStatus, useApiClient, useGetInstructStatus, useInitInstruct} from '../useApiClient'
+import {InstructStatus} from '../useApiClient'
+import {SerializedSchemaType} from '../types'
+import {FieldRef} from '../assistInspector/helpers'
 
 export interface AiAssistanceConfigContextValue {
   config: AssistPluginConfig
@@ -18,6 +12,9 @@ export interface AiAssistanceConfigContextValue {
   initLoading: boolean
   init: () => void
   error?: Error
+  serializedTypes: SerializedSchemaType[]
+  getFieldRefs: (documentType: string) => FieldRef[]
+  getFieldRefsByTypePath: (documentType: string) => Record<string, FieldRef | undefined>
 }
 
 export const AiAssistanceConfigContext = createContext<AiAssistanceConfigContextValue>({} as any)
@@ -30,53 +27,6 @@ export function useAiAssistanceConfig() {
   return context
 }
 
-export function AiAssistanceConfigProvider(props: {
-  children?: ReactNode
-  config: AssistPluginConfig
-}) {
-  const [status, setStatus] = useState<InstructStatus | undefined>()
-  const [error, setError] = useState<Error | undefined>()
-
-  const apiClient = useApiClient(props.config?.__customApiClient)
-  const {getInstructStatus, loading: statusLoading} = useGetInstructStatus(apiClient)
-  const {initInstruct, loading: initLoading} = useInitInstruct(apiClient)
-
-  useEffect(() => {
-    getInstructStatus()
-      .then((s) => setStatus(s))
-      .catch((e) => {
-        console.error(e)
-        setError(e as Error)
-      })
-  }, [getInstructStatus])
-
-  const init = useCallback(async () => {
-    setError(undefined)
-    try {
-      await initInstruct()
-      const status = await getInstructStatus()
-      setStatus(status)
-    } catch (e) {
-      console.error('Failed to init ai assistance', e)
-      setError(e as Error)
-    }
-  }, [initInstruct, getInstructStatus, setStatus])
-
-  const {config, children} = props
-  const context = useMemo<AiAssistanceConfigContextValue>(() => {
-    return {
-      config,
-      status,
-      statusLoading,
-      init,
-      initLoading,
-      error,
-    }
-  }, [config, status, init, statusLoading, initLoading, error])
-
-  return (
-    <AiAssistanceConfigContext.Provider value={context}>
-      {children}
-    </AiAssistanceConfigContext.Provider>
-  )
+export function useSerializedTypes() {
+  return useAiAssistanceConfig().serializedTypes
 }

package/src/assistLayout/AiAssistanceConfigProvider.tsx

@@ -0,0 +1,98 @@
+import {ReactNode, useCallback, useEffect, useMemo, useState} from 'react'
+import {AssistPluginConfig} from '../plugin'
+import {InstructStatus, useApiClient, useGetInstructStatus, useInitInstruct} from '../useApiClient'
+import {type ObjectSchemaType, Schema, useSchema} from 'sanity'
+import {serializeSchema} from '../schemas/serialize/serializeSchema'
+import {
+  AiAssistanceConfigContext,
+  AiAssistanceConfigContextValue,
+} from './AiAssistanceConfigContext'
+import {createFieldRefCache} from './fieldRefCache'
+
+export function AiAssistanceConfigProvider(props: {
+  children?: ReactNode
+  config: AssistPluginConfig
+}) {
+  const [status, setStatus] = useState<InstructStatus | undefined>()
+  const [error, setError] = useState<Error | undefined>()
+
+  const apiClient = useApiClient(props.config?.__customApiClient)
+  const {getInstructStatus, loading: statusLoading} = useGetInstructStatus(apiClient)
+  const {initInstruct, loading: initLoading} = useInitInstruct(apiClient)
+
+  const schema = useSchema()
+  const serializedTypes = useMemo(() => serializeSchema(schema, {leanFormat: true}), [schema])
+  const {getFieldRefs, getFieldRefsByTypePath} = useFieldRefGetters(schema)
+
+  useEffect(() => {
+    getInstructStatus()
+      .then((s) => setStatus(s))
+      .catch((e) => {
+        console.error(e)
+        setError(e as Error)
+      })
+  }, [getInstructStatus])
+
+  const init = useCallback(async () => {
+    setError(undefined)
+    try {
+      await initInstruct()
+      const status = await getInstructStatus()
+      setStatus(status)
+    } catch (e) {
+      console.error('Failed to init ai assistance', e)
+      setError(e as Error)
+    }
+  }, [initInstruct, getInstructStatus, setStatus])
+
+  const {config, children} = props
+  const context = useMemo<AiAssistanceConfigContextValue>(() => {
+    return {
+      config,
+      status,
+      statusLoading,
+      init,
+      initLoading,
+      error,
+      serializedTypes,
+      getFieldRefs,
+      getFieldRefsByTypePath,
+    }
+  }, [
+    config,
+    status,
+    init,
+    statusLoading,
+    initLoading,
+    error,
+    serializedTypes,
+    getFieldRefs,
+    getFieldRefsByTypePath,
+  ])
+
+  return (
+    <AiAssistanceConfigContext.Provider value={context}>
+      {children}
+    </AiAssistanceConfigContext.Provider>
+  )
+}
+
+function useFieldRefGetters(schema: Schema) {
+  return useMemo(() => {
+    const getForSchemaType = createFieldRefCache()
+
+    function getRefsForType(documentType: string) {
+      const schemaType = schema.get(documentType) as ObjectSchemaType | undefined
+      if (!schemaType) {
+        throw new Error(`Schema type "${documentType}" not found`)
+      }
+      return getForSchemaType(schemaType)
+    }
+
+    return {
+      getFieldRefs: (documentType: string) => getRefsForType(documentType).fieldRefs,
+      getFieldRefsByTypePath: (documentType: string) =>
+        getRefsForType(documentType).fieldRefsByTypePath,
+    }
+  }, [schema])
+}

package/src/assistLayout/AssistLayout.tsx

@@ -8,8 +8,8 @@ import {AssistPluginConfig} from '../plugin'
 import {FieldTranslationProvider} from '../translate/FieldTranslationProvider'
 import {StudioInstruction} from '../types'
 import {RunInstructionRequest} from '../useApiClient'
-import {AiAssistanceConfigProvider} from './AiAssistanceConfigContext'
 import {RunInstructionProvider} from './RunInstructionProvider'
+import {AiAssistanceConfigProvider} from './AiAssistanceConfigProvider'
 
 export interface AIStudioLayoutProps extends LayoutProps {
   config: AssistPluginConfig

package/src/assistLayout/fieldRefCache.tsx

@@ -0,0 +1,34 @@
+import {
+  asFieldRefsByTypePath,
+  FieldRef,
+  getFieldRefs as createFieldRefs,
+} from '../assistInspector/helpers'
+import type {ObjectSchemaType} from 'sanity'
+
+export function createFieldRefCache() {
+  const byType: Record<
+    string,
+    | {
+        fieldRefs: FieldRef[]
+        fieldRefsByTypePath: Record<string, FieldRef | undefined>
+      }
+    | undefined
+  > = {}
+
+  function getRefsForType(schemaType: ObjectSchemaType) {
+    const documentType = schemaType.name
+    const cached = byType[documentType]
+    if (cached) return cached
+
+    const fieldRefs = createFieldRefs(schemaType)
+    const fieldRefsByTypePath = asFieldRefsByTypePath(fieldRefs)
+    const refs = {
+      fieldRefs,
+      fieldRefsByTypePath,
+    }
+    byType[documentType] = refs
+    return refs
+  }
+
+  return getRefsForType
+}

package/src/fieldActions/customFieldActions.tsx

@@ -4,10 +4,11 @@ import {
   DocumentFieldActionItem,
   DocumentFieldActionNode,
   ObjectSchemaType,
+  Path,
   SanityDocumentLike,
+  SchemaType,
   useWorkspaceSchemaId,
 } from 'sanity'
-import {Path, SchemaType} from '@sanity/types'
 import {useMemo} from 'react'
 import {useAiAssistanceConfig} from '../assistLayout/AiAssistanceConfigContext'
 import {ToastParams, useToast} from '@sanity/ui'

package/src/schemas/assistDocumentSchema.tsx

@@ -24,7 +24,6 @@ import {InstructionOutputInput} from '../assistDocument/components/instruction/I
 import {PromptInput} from '../assistDocument/components/instruction/PromptInput'
 import {InstructionsArrayField} from '../assistDocument/components/InstructionsArrayField'
 import {InstructionsArrayInput} from '../assistDocument/components/InstructionsArrayInput'
-import {getFieldRefsWithDocument} from '../assistInspector/helpers'
 import {instructionGuideUrl} from '../constants'
 import {getInstructionTitle} from '../helpers/misc'
 import {
@@ -43,6 +42,8 @@ import {
 } from '../types'
 import {contextDocumentSchema} from './contextDocumentSchema'
 
+import {createFieldRefCache} from '../assistLayout/fieldRefCache'
+
 export const fieldReference = defineType({
   type: 'object',
   name: fieldReferenceTypeName,
@@ -57,8 +58,9 @@ export const fieldReference = defineType({
       components: {
         input: FieldRefPathInput,
       },
-      validation: (rule) =>
-        rule.custom((value, context) => {
+      validation: (rule) => {
+        const getForSchemaType = createFieldRefCache()
+        return rule.custom((value, context) => {
           if (!value) {
             return 'Please select a field'
           }
@@ -72,8 +74,8 @@ export const fieldReference = defineType({
             if (!schema) {
               return `Field reference cannot be used outside document inspector context. Could not resolve schema: ${targetDocType}`
             }
-            const refs = getFieldRefsWithDocument(schema as ObjectSchemaType)
-            const fieldRef = refs.find((r) => r.key === value)
+            const {fieldRefs} = getForSchemaType(schema as ObjectSchemaType)
+            const fieldRef = fieldRefs.find((r) => r.key === value)
             if (!fieldRef) {
               return `Field with path "${value}" does not exist in the schema.`
             }
@@ -82,7 +84,8 @@ export const fieldReference = defineType({
             console.error('Failed to resolve field reference', e)
             return 'Invalid field reference.'
           }
-        }),
+        })
+      },
     }),
   ],
   preview: {

package/src/schemas/typeDefExtensions.ts

@@ -1,3 +1,4 @@
+import 'sanity'
 /* eslint-disable no-unused-vars */
 export interface AssistOptions {
   aiAssist?: {

package/src/useApiClient.ts

@@ -3,11 +3,10 @@ import {useToast} from '@sanity/ui'
 import {useCallback, useMemo, useState} from 'react'
 import {Path, pathToString, useClient, useCurrentUser} from 'sanity'
 
-import {useAiAssistanceConfig} from './assistLayout/AiAssistanceConfigContext'
+import {useAiAssistanceConfig, useSerializedTypes} from './assistLayout/AiAssistanceConfigContext'
 import {ConditionalMemberState} from './helpers/conditionalMembers'
 import {FieldLanguageMap} from './translate/paths'
 import {documentRootKey} from './types'
-import {useSerializedTypes} from './assistDocument/hooks/useAssistDocumentContextValue'
 
 export interface UserTextInstance {
   blockKey: string