@sanity/assist 4.4.6 → 4.4.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/assist",
-  "version": "4.4.6",
+  "version": "4.4.8",
   "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/hooks/useAssistDocumentContextValue.tsx

@@ -1,16 +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} from '../AssistDocumentContext'
 import {isDocAssistable} from '../RequestRunInstructionProvider'
 import {useStudioAssistDocument} from './useStudioAssistDocument'
+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) {
@@ -20,13 +21,11 @@ export function useAssistDocumentContextValue(documentId: string, documentType:
   }, [documentType, 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,

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,18 +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 {serializeSchema} from '../schemas/serialize/serializeSchema'
-import {useSchema} from 'sanity'
+import {FieldRef} from '../assistInspector/helpers'
 
 export interface AiAssistanceConfigContextValue {
   config: AssistPluginConfig
@@ -22,6 +13,8 @@ export interface AiAssistanceConfigContextValue {
   init: () => void
   error?: Error
   serializedTypes: SerializedSchemaType[]
+  getFieldRefs: (documentType: string) => FieldRef[]
+  getFieldRefsByTypePath: (documentType: string) => Record<string, FieldRef | undefined>
 }
 
 export const AiAssistanceConfigContext = createContext<AiAssistanceConfigContextValue>({} as any)
@@ -37,58 +30,3 @@ export function useAiAssistanceConfig() {
 export function useSerializedTypes() {
   return useAiAssistanceConfig().serializedTypes
 }
-
-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])
-
-  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,
-    }
-  }, [config, status, init, statusLoading, initLoading, error, serializedTypes])
-
-  return (
-    <AiAssistanceConfigContext.Provider value={context}>
-      {children}
-    </AiAssistanceConfigContext.Provider>
-  )
-}

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/helpers/conditionalMembers.test.ts

@@ -227,6 +227,49 @@ describe('conditionalMembers', () => {
     ])
   })
 
+  test('should include field with conditional state inside fieldset', () => {
+    const docSchema: ObjectSchemaType = Schema.compile({
+      name: 'test',
+      types: [
+        defineType({
+          type: 'document',
+          name: 'article',
+          fieldsets: [{name: 'set'}],
+          fields: [{type: 'string', fieldset: 'set', name: 'title', hidden: () => false}],
+        }),
+      ],
+    }).get('article')
+
+    const docState = {
+      path: [],
+      schemaType: docSchema,
+      members: [
+        {
+          kind: 'fieldSet',
+          fieldSet: {
+            name: 'set',
+            path: ['set'],
+            members: [
+              {
+                kind: 'field',
+                field: {path: [docSchema.fields[0].name], schemaType: docSchema.fields[0].type},
+              },
+            ],
+          },
+        },
+      ],
+    } as any
+    const conditionalMembers = getConditionalMembers(docState)
+
+    expect(conditionalMembers).toEqual([
+      {
+        path: 'title',
+        hidden: false,
+        readOnly: false,
+      },
+    ])
+  })
+
   test('should respect max-depth', () => {
     const docSchema: ObjectSchemaType = Schema.compile({
       name: 'test',

package/src/helpers/conditionalMembers.ts

@@ -67,8 +67,8 @@ function conditionalState(memberState: {
 }): ConditionalMemberInnerState {
   return {
     path: pathToString(memberState.path),
-    readOnly: !!memberState.readOnly,
-    hidden: false, // if its in members, its not hidden
+    readOnly: !!memberState.readOnly, // Use actual form state readOnly value
+    hidden: false, // If it's in form state members, it's not hidden
     conditional: isConditional(memberState.schemaType),
   }
 }
@@ -124,7 +124,7 @@ function extractConditionalPaths(
       const innerFields = extractConditionalPaths(member.fieldSet, maxDepth).map((f) => ({
         ...f,
         // if fieldset is conditional, visible fields must also be considered conditional
-        conditional: conditionalFieldset ?? f.conditional,
+        conditional: conditionalFieldset || f.conditional,
       }))
       return [...acc, ...innerFields]
     }

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?: {