@sanity/assist 1.2.14 → 1.2.15-lang.10

package/src/fieldActions/assistFieldActions.tsx

@@ -3,11 +3,12 @@ import {
   DocumentFieldActionGroup,
   DocumentFieldActionItem,
   ObjectSchemaType,
+  typed,
   useCurrentUser,
 } from 'sanity'
 import {ControlsIcon, SparklesIcon} from '@sanity/icons'
-import {useCallback, useMemo} from 'react'
-import {pluginTitle, pluginTitleShort} from '../constants'
+import {useCallback, useMemo, useRef} from 'react'
+import {pluginTitleShort} from '../constants'
 import {useAssistSupported} from '../helpers/useAssistSupported'
 import {useAssistDocumentContext} from '../assistDocument/AssistDocumentContext'
 import {getInstructionTitle, usePathKey} from '../helpers/misc'
@@ -24,6 +25,9 @@ import {generateCaptionsActions} from './generateCaptionActions'
 import {useDocumentPane} from 'sanity/desk'
 import {useSelectedField, useTypePath} from '../assistInspector/helpers'
 import {isSchemaAssistEnabled} from '../helpers/assistSupported'
+import {translateActions, TranslateProps} from '../translate/translateActions'
+import {generateImagActions} from './generateImageActions'
+import {getConditionalMembers} from '../helpers/conditionalMembers'
 
 function node(node: DocumentFieldActionItem | DocumentFieldActionGroup) {
   return node
@@ -47,6 +51,7 @@ export const assistFieldActions: DocumentFieldAction = {
       documentSchemaType,
       documentId,
       selectedPath,
+      assistableDocumentId,
     } =
       // document field actions do not have access to the document context
       // conditional hook _should_ be safe here since the logical path will be stable
@@ -56,7 +61,10 @@ export const assistFieldActions: DocumentFieldAction = {
         : // eslint-disable-next-line react-hooks/rules-of-hooks
           useAssistDocumentContext()
 
-    const {value: docValue} = useDocumentPane()
+    const {value: docValue, formState} = useDocumentPane()
+    const formStateRef = useRef(formState)
+    formStateRef.current = formState
+
     const currentUser = useCurrentUser()
     const isHidden = !assistDocument
     const pathKey = usePathKey(props.path)
@@ -73,7 +81,8 @@ export const assistFieldActions: DocumentFieldAction = {
     const assistSupported =
       useAssistSupported(props.path, schemaType) &&
       isSelectable &&
-      isSchemaAssistEnabled(documentSchemaType)
+      isSchemaAssistEnabled(documentSchemaType) &&
+      schemaType.readOnly !== true
 
     const fieldAssist = useMemo(
       () =>
@@ -89,7 +98,15 @@ export const assistFieldActions: DocumentFieldAction = {
     const isSelected = isInspectorOpen && isPathSelected
 
     const imageCaptionAction = generateCaptionsActions.useAction(props)
-
+    const imageGenAction = generateImagActions.useAction(props)
+    const translateAction = translateActions.useAction(
+      typed<TranslateProps>({
+        ...props,
+        documentId: assistableDocumentId,
+        documentIsAssistable,
+        documentSchemaType,
+      })
+    )
     const manageInstructions = useCallback(
       () =>
         isSelected
@@ -112,6 +129,9 @@ export const assistFieldActions: DocumentFieldAction = {
           path: pathKey,
           typePath,
           instruction,
+          conditionalMembers: formStateRef.current
+            ? getConditionalMembers(formStateRef.current)
+            : [],
         })
       },
       [requestRunInstruction, assistableDocId, pathKey, typePath, assistDocumentId, fieldAssistKey]
@@ -134,7 +154,7 @@ export const assistFieldActions: DocumentFieldAction = {
     )
 
     const runInstructionsGroup = useMemo(() => {
-      return instructions?.length || imageCaptionAction
+      return instructions?.length || imageCaptionAction || translateAction || imageGenAction
         ? node({
             type: 'group',
             icon: () => null,
@@ -151,7 +171,8 @@ export const assistFieldActions: DocumentFieldAction = {
                 })
               ),
               imageCaptionAction,
-            ].filter(Boolean),
+              imageGenAction,
+            ].filter((a): a is DocumentFieldActionItem => !!a),
             expanded: true,
           })
         : undefined
@@ -163,6 +184,8 @@ export const assistFieldActions: DocumentFieldAction = {
       documentIsNew,
       assistSupported,
       imageCaptionAction,
+      translateAction,
+      imageGenAction,
     ])
 
     const instructionsLength = instructions?.length || 0
@@ -185,12 +208,16 @@ export const assistFieldActions: DocumentFieldAction = {
           type: 'group',
           icon: SparklesIcon,
           title: pluginTitleShort,
-          children: [runInstructionsGroup, assistSupported && manageInstructionsItem].filter(
-            (c): c is DocumentFieldActionItem | DocumentFieldActionGroup => !!c
-          ),
+          children: [
+            runInstructionsGroup,
+            translateAction,
+            assistSupported && manageInstructionsItem,
+          ]
+            .filter((c): c is DocumentFieldActionItem | DocumentFieldActionGroup => !!c)
+            .filter((c) => (c.type === 'group' ? c.children.length : true)),
           expanded: false,
           renderAsButton: true,
-          hidden: !assistSupported && !imageCaptionAction,
+          hidden: !assistSupported && !imageCaptionAction && !translateAction && !imageGenAction,
         }),
       [
         //documentIsNew,
@@ -198,6 +225,8 @@ export const assistFieldActions: DocumentFieldAction = {
         manageInstructionsItem,
         assistSupported,
         imageCaptionAction,
+        translateAction,
+        imageGenAction,
       ]
     )
 
@@ -216,7 +245,7 @@ export const assistFieldActions: DocumentFieldAction = {
     )
 
     // If there are no instructions, we don't want to render the group
-    if (instructionsLength === 0 && !imageCaptionAction) {
+    if (instructionsLength === 0 && !imageCaptionAction && !translateAction && !imageGenAction) {
       return emptyAction
     }
 
@@ -239,7 +268,7 @@ function instructionItem(props: {
     iconRight: isPrivate ? PrivateIcon : undefined,
     title: getInstructionTitle(instruction),
     onAction: () => onInstructionAction(instruction),
-    disabled: assistSupported ? false : {reason: `${pluginTitle} is not supported for this field`},
+    disabled: !assistSupported,
     hidden,
   })
 }

package/src/fieldActions/generateCaptionActions.tsx

@@ -23,7 +23,7 @@ export const generateCaptionsActions: DocumentFieldAction = {
 
     const imageContext = useContext(ImageContext)
 
-    if (imageContext && pathKey === imageContext?.captionPath) {
+    if (imageContext && pathKey === imageContext?.imageDescriptionPath) {
       //if this is true, it is stable, and not breaking rules of hooks
       // eslint-disable-next-line react-hooks/rules-of-hooks
       const {documentId} = useAssistDocumentContext()
@@ -38,7 +38,7 @@ export const generateCaptionsActions: DocumentFieldAction = {
                 </Box>
               )
             : ImageIcon,
-          title: 'Generate caption',
+          title: 'Generate image description',
           onAction: () => {
             if (loading) {
               return

package/src/fieldActions/generateImageActions.tsx

@@ -0,0 +1,57 @@
+import {DocumentFieldAction, DocumentFieldActionGroup, DocumentFieldActionItem} from 'sanity'
+import {ImageIcon} from '@sanity/icons'
+import {useContext, useMemo} from 'react'
+import {usePathKey} from '../helpers/misc'
+import {useApiClient, useGenerateImage} from '../useApiClient'
+import {useAiAssistanceConfig} from '../assistLayout/AiAssistanceConfigContext'
+import {useAssistDocumentContext} from '../assistDocument/AssistDocumentContext'
+import {ImageContext} from '../components/ImageContext'
+import {Box, Spinner} from '@sanity/ui'
+
+function node(node: DocumentFieldActionItem | DocumentFieldActionGroup) {
+  return node
+}
+
+export const generateImagActions: DocumentFieldAction = {
+  name: 'sanity-assist-generate-image',
+  useAction(props) {
+    const pathKey = usePathKey(props.path)
+
+    const {config} = useAiAssistanceConfig()
+    const apiClient = useApiClient(config?.__customApiClient)
+    const {generateImage, loading} = useGenerateImage(apiClient)
+
+    const imageContext = useContext(ImageContext)
+
+    if (imageContext && pathKey === imageContext?.imageInstructionPath) {
+      //if this is true, it is stable, and not breaking rules of hooks
+      // eslint-disable-next-line react-hooks/rules-of-hooks
+      const {documentId} = useAssistDocumentContext()
+      // eslint-disable-next-line react-hooks/rules-of-hooks
+      return useMemo(() => {
+        return node({
+          type: 'action',
+          icon: loading
+            ? () => (
+                <Box style={{height: 17}}>
+                  <Spinner style={{transform: 'translateY(6px)'}} />
+                </Box>
+              )
+            : ImageIcon,
+          title: 'Generate image from prompt',
+          onAction: () => {
+            if (loading) {
+              return
+            }
+            generateImage({path: pathKey, documentId: documentId ?? ''})
+          },
+          renderAsButton: true,
+          disabled: loading,
+        })
+      }, [generateImage, pathKey, documentId, loading])
+    }
+
+    // works but not supported by types
+    return undefined as unknown as DocumentFieldActionItem
+  },
+}

package/src/helpers/assistSupported.ts

@@ -1,41 +1,34 @@
-import {SchemaType} from 'sanity'
+import {ReferenceOptions, SchemaType} from 'sanity'
 import {AssistOptions} from '../schemas/typeDefExtensions'
 import {isType} from './typeUtils'
 
 export function isSchemaAssistEnabled(type: SchemaType) {
-  return !(type.options as AssistOptions | undefined)?.aiWritingAssistance?.exclude
+  return !(type.options as AssistOptions | undefined)?.aiAssist?.exclude
 }
 
-export function isAssistSupported(type: SchemaType, allowReadonlyHidden = false) {
+export function isAssistSupported(type: SchemaType) {
   if (!isSchemaAssistEnabled(type)) {
     return false
   }
 
-  if (isDisabled(type, allowReadonlyHidden)) {
+  if (isDisabled(type)) {
     return false
   }
 
   if (type.jsonType === 'array') {
-    const unsupportedArray = type.of.every((t) => isDisabled(t, allowReadonlyHidden))
+    const unsupportedArray = type.of.every((t) => isDisabled(t))
     return !unsupportedArray
   }
 
   if (type.jsonType === 'object') {
-    const unsupportedObject = type.fields.every((field) =>
-      isDisabled(field.type, allowReadonlyHidden)
-    )
+    const unsupportedObject = type.fields.every((field) => isDisabled(field.type))
     return !unsupportedObject
   }
   return true
 }
 
-function isDisabled(type: SchemaType, allowReadonlyHidden: boolean) {
-  const readonlyHidden = !!type.readOnly || !!type.hidden
-  return (
-    !isSchemaAssistEnabled(type) ||
-    isUnsupportedType(type) ||
-    (!allowReadonlyHidden && readonlyHidden)
-  )
+function isDisabled(type: SchemaType) {
+  return !isSchemaAssistEnabled(type) || isUnsupportedType(type)
 }
 
 function isUnsupportedType(type: SchemaType) {
@@ -43,7 +36,8 @@ function isUnsupportedType(type: SchemaType) {
     type.jsonType === 'number' ||
     type.name === 'sanity.imageCrop' ||
     type.name === 'sanity.imageHotspot' ||
-    isType(type, 'reference') ||
+    (isType(type, 'reference') &&
+      !(type?.options as ReferenceOptions)?.aiAssist?.embeddingsIndex) ||
     isType(type, 'crossDatasetReference') ||
     isType(type, 'slug') ||
     isType(type, 'url') ||

package/src/helpers/conditionalMembers.test.ts

@@ -0,0 +1,200 @@
+import {describe, expect, test} from 'vitest'
+import {Schema} from '@sanity/schema'
+import {ArraySchemaType, defineField, defineType, ObjectSchemaType} from 'sanity'
+import {getConditionalMembers} from './conditionalMembers'
+
+describe('conditionalMembers', () => {
+  test('should not include paths without conditional hidden/readonly', () => {
+    const docSchema: ObjectSchemaType = Schema.compile({
+      name: 'test',
+      types: [
+        defineType({
+          type: 'document',
+          name: 'article',
+          fields: [{type: 'string', name: 'title'}],
+        }),
+      ],
+    }).get('article')
+
+    const docState = {
+      path: [],
+      schemaType: docSchema,
+      members: [
+        {
+          kind: 'field',
+          field: {path: [docSchema.fields[0].name], schemaType: docSchema.fields[0].type},
+        },
+      ],
+    } as any
+    const conditionalMembers = getConditionalMembers(docState)
+
+    expect(conditionalMembers).toEqual([])
+  })
+
+  test('should include path with conditional readonly', () => {
+    const docSchema: ObjectSchemaType = Schema.compile({
+      name: 'test',
+      types: [
+        defineType({
+          type: 'document',
+          name: 'article',
+          fields: [{type: 'string', name: 'title', readOnly: () => false}],
+        }),
+      ],
+    }).get('article')
+
+    const docState = {
+      path: [],
+      schemaType: docSchema,
+      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 include array item path with conditional readonly', () => {
+    const docSchema: ObjectSchemaType = Schema.compile({
+      name: 'test',
+      types: [
+        defineType({
+          type: 'document',
+          name: 'article',
+          fields: [{type: 'array', name: 'array', of: [{type: 'string', readOnly: () => true}]}],
+        }),
+      ],
+    }).get('article')
+
+    const docState = {
+      path: [],
+      schemaType: docSchema,
+      members: [
+        {
+          kind: 'field',
+          field: {
+            path: [docSchema.fields[0].name],
+            schemaType: docSchema.fields[0].type,
+            members: [
+              {
+                kind: 'item',
+                item: {
+                  path: [docSchema.fields[0].name, 0],
+                  schemaType: (docSchema.fields[0].type as ArraySchemaType).of[0],
+                  readOnly: true,
+                },
+              },
+            ],
+          },
+        },
+      ],
+    } as any
+    const conditionalMembers = getConditionalMembers(docState)
+
+    expect(conditionalMembers).toEqual([
+      {
+        path: 'array[0]',
+        hidden: false,
+        readOnly: true,
+      },
+    ])
+  })
+
+  test('should include object path with conditional hidden', () => {
+    const docSchema: ObjectSchemaType = Schema.compile({
+      name: 'test',
+      types: [
+        defineType({
+          type: 'document',
+          name: 'article',
+          fields: [
+            defineField({
+              type: 'object',
+              name: 'object',
+              fields: [{type: 'string', name: 'title', hidden: () => false}],
+            }),
+          ],
+        }),
+      ],
+    }).get('article')
+
+    const docState = {
+      path: [],
+      schemaType: docSchema,
+      members: [
+        {
+          kind: 'field',
+          field: {
+            path: [docSchema.fields[0].name],
+            schemaType: docSchema.fields[0].type,
+            members: [
+              {
+                kind: 'field',
+                field: {
+                  path: [docSchema.fields[0].name, 'title'],
+                  schemaType: (docSchema.fields[0].type as ObjectSchemaType).fields[0].type,
+                },
+              },
+            ],
+          },
+        },
+      ],
+    } as any
+    const conditionalMembers = getConditionalMembers(docState)
+
+    expect(conditionalMembers).toEqual([
+      {
+        path: 'object.title',
+        hidden: false,
+        readOnly: false,
+      },
+    ])
+  })
+
+  test('should include path with fieldset with conditional state', () => {
+    const docSchema: ObjectSchemaType = Schema.compile({
+      name: 'test',
+      types: [
+        defineType({
+          type: 'document',
+          name: 'article',
+          fieldsets: [{name: 'set', hidden: () => false}],
+          fields: [{type: 'string', fieldset: 'set', name: 'title'}],
+        }),
+      ],
+    }).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,
+      },
+    ])
+  })
+})

package/src/helpers/conditionalMembers.ts

@@ -0,0 +1,127 @@
+/* eslint-disable max-depth */
+import {
+  ArrayOfObjectsFormNode,
+  ArrayOfObjectsItemMember,
+  ArrayOfPrimitivesFormNode,
+  DocumentFormNode,
+  FieldsetState,
+  isObjectSchemaType,
+  ObjectFormNode,
+  Path,
+  pathToString,
+  SchemaType,
+} from 'sanity'
+
+const MAX_DEPTH = 8
+
+export interface ConditionalMemberState {
+  path: string
+  hidden: boolean
+  readOnly: boolean
+}
+
+interface ConditionalMemberInnerState extends ConditionalMemberState {
+  conditional: boolean
+}
+
+/**
+ * This is used to statically determine the state of the functions on the server-side.
+ * Paths which has a schema with conditional config should be considered hidden: true and/or readOnly: true
+ * Only conditional paths are included, as static props can be determined from schema.
+ *
+ * Returns paths that has conditional hidden or readOnly schema config (function) and that.
+ * Form-state does not contain hidden members.
+ *
+ * Note:
+ * * If a parent path is hidden, no child paths are included
+ * * If a parent path is readOnly, no child paths are included
+ * * If a path is hidden, it is not included; only conditionally visible paths will be returned, with hidden: false
+ */
+export function getConditionalMembers(docState: DocumentFormNode): ConditionalMemberState[] {
+  const doc: ConditionalMemberInnerState = {
+    path: '',
+    hidden: false,
+    readOnly: !!docState.readOnly,
+    conditional: typeof docState.schemaType.hidden === 'function',
+  }
+  return [doc, ...extractConditionalPaths(docState, MAX_DEPTH)]
+    .filter((v) => v.conditional)
+    .map(({conditional, ...state}) => ({...state}))
+}
+
+function isConditional(schemaType: SchemaType) {
+  return typeof schemaType.hidden === 'function' || typeof schemaType.readOnly === 'function'
+}
+
+function conditionalState(memberState: {
+  path: Path
+  schemaType: SchemaType
+  readOnly?: boolean
+}): ConditionalMemberInnerState {
+  return {
+    path: pathToString(memberState.path),
+    readOnly: !!memberState.readOnly,
+    hidden: false, // if its in members, its not hidden
+    conditional: isConditional(memberState.schemaType),
+  }
+}
+
+function extractConditionalPaths(
+  node: ObjectFormNode | FieldsetState,
+  maxDepth: number
+): ConditionalMemberInnerState[] {
+  if (node.path.length >= maxDepth) {
+    return []
+  }
+
+  return node.members.reduce<ConditionalMemberInnerState[]>((acc, member) => {
+    if (member.kind === 'error') {
+      return acc
+    }
+    if (member.kind === 'field') {
+      const schemaType = member.field.schemaType
+      if (schemaType.jsonType === 'object') {
+        const innerFields = member.field.readOnly
+          ? []
+          : extractConditionalPaths(member.field as ObjectFormNode, maxDepth)
+        return [...acc, conditionalState(member.field), ...innerFields]
+      } else if (schemaType.jsonType === 'array') {
+        const array = member.field as ArrayOfObjectsFormNode | ArrayOfPrimitivesFormNode
+
+        let arrayPaths: ConditionalMemberInnerState[] = []
+        const isObjectsArray = array.members.some(
+          (m) => m.kind === 'item' && isObjectSchemaType(m.item.schemaType)
+        )
+        if (!array.readOnly) {
+          for (const arrayMember of array.members) {
+            if (arrayMember.kind === 'error') {
+              continue
+            }
+
+            const innerFields =
+              isObjectsArray && !arrayMember.item.readOnly
+                ? extractConditionalPaths((arrayMember as ArrayOfObjectsItemMember).item, maxDepth)
+                : []
+
+            arrayPaths = [...arrayPaths, conditionalState(arrayMember.item), ...innerFields]
+          }
+        }
+        return [...acc, conditionalState(array), ...arrayPaths]
+      }
+
+      return [...acc, conditionalState(member.field)]
+    } else if (member.kind === 'fieldSet') {
+      const conditionalFieldset = !!(node as ObjectFormNode).schemaType?.fieldsets?.some(
+        (f) => !f.single && f.name === member.fieldSet.name && typeof f.hidden === 'function'
+      )
+      const innerFields = extractConditionalPaths(member.fieldSet, maxDepth).map((f) => ({
+        ...f,
+        // if fieldset is conditional, visible fields must also be considered conditional
+        conditional: conditionalFieldset ?? f.conditional,
+      }))
+      return [...acc, ...innerFields]
+    }
+
+    return acc
+  }, [])
+}

package/src/helpers/typeUtils.ts

@@ -18,13 +18,27 @@ export function isImage(schemaType: SchemaType) {
   return isType(schemaType, 'image')
 }
 
-export function getCaptionFieldOption(schemaType: SchemaType | undefined): string | undefined {
+export function getDescriptionFieldOption(schemaType: SchemaType | undefined): string | undefined {
   if (!schemaType) {
     return undefined
   }
-  const captionField = (schemaType.options as ImageOptions)?.captionField
-  if (captionField) {
-    return captionField
+  const descriptionField = (schemaType.options as ImageOptions)?.aiAssist?.imageDescriptionField
+  if (descriptionField) {
+    return descriptionField
   }
-  return getCaptionFieldOption(schemaType.type)
+  return getDescriptionFieldOption(schemaType.type)
+}
+
+export function getImageInstructionFieldOption(
+  schemaType: SchemaType | undefined
+): string | undefined {
+  if (!schemaType) {
+    return undefined
+  }
+  const imageInstructionField = (schemaType.options as ImageOptions)?.aiAssist
+    ?.imageInstructionField
+  if (imageInstructionField) {
+    return imageInstructionField
+  }
+  return getImageInstructionFieldOption(schemaType.type)
 }

package/src/index.ts

@@ -1,6 +1,9 @@
 export * from './schemas/typeDefExtensions'
 export * from './schemas/serialize/SchemTypeTool'
 
+export {defaultLanguageOutputs} from './translate/paths'
+export * from './translate/types'
+
 export {contextDocumentTypeName} from './types'
 
 export {assist} from './plugin'

package/src/node_modules/.vitest/deps/_metadata.json

@@ -0,0 +1,8 @@
+{
+  "hash": "6b9f27e8",
+  "configHash": "36395290",
+  "lockfileHash": "8eb2d291",
+  "browserHash": "2b6c636b",
+  "optimized": {},
+  "chunks": {}
+}

package/src/node_modules/.vitest/deps/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/src/node_modules/.vitest/results.json

@@ -0,0 +1 @@
+{"version":"0.32.2","results":[[":schemas/serialize/serializeSchema.test.ts",{"duration":13,"failed":false}],[":translate/paths.test.ts",{"duration":6,"failed":false}],[":helpers/conditionalMembers.test.ts",{"duration":4,"failed":false}]]}