@sanity/assist 1.2.15-lang.2 → 1.2.15-lang.4

package/src/{fieldActions → translate}/translateActions.tsx

@@ -13,33 +13,50 @@ import {useAiAssistanceConfig} from '../assistLayout/AiAssistanceConfigContext'
 import {Box, Spinner} from '@sanity/ui'
 import {isAssistSupported} from '../helpers/assistSupported'
 import {useDocumentPane} from 'sanity/desk'
-import {useFieldTranslation} from '../translate/FieldTranslationProvider'
+import {useFieldTranslation} from './FieldTranslationProvider'
 import {useDraftDelayedTask} from '../assistDocument/RequestRunInstructionProvider'
-import {getLanguageParams} from '../translate/getLanguageParams'
+import {AssistOptions} from '../schemas/typeDefExtensions'
+import {extractWithPath} from '@sanity/mutator'
 
 function node(node: DocumentFieldActionItem | DocumentFieldActionGroup) {
   return node
 }
 
-export type TranslateProps = DocumentFieldActionProps & {documentIsAssistable?: boolean}
+export type TranslateProps = DocumentFieldActionProps & {
+  documentIsAssistable?: boolean
+  documentSchemaType?: ObjectSchemaType
+}
 export const translateActions: DocumentFieldAction = {
   name: 'sanity-assist-translate',
   useAction(props: TranslateProps) {
     const {config} = useAiAssistanceConfig()
     const apiClient = useApiClient(config?.__customApiClient)
 
-    const isDocumentLevel = props.path.length === 0
-    const {schemaType, documentId, documentIsAssistable} = props
+    const {
+      schemaType: fieldSchemaType,
+      path,
+      documentId,
+      documentSchemaType,
+      documentIsAssistable,
+    } = props
+    const isDocumentLevel = path.length === 0
 
-    const fieldTransEnabled = config.translate?.field?.documentTypes?.includes(schemaType.name)
     const docTransTypes = config.translate?.document?.documentTypes
+    const options = fieldSchemaType?.options as AssistOptions | undefined
+    const addFieldAction = isDocumentLevel || options?.aiWritingAssistance?.translateAction
+
+    const fieldTransEnabled =
+      addFieldAction &&
+      documentSchemaType &&
+      config.translate?.field?.documentTypes?.includes(documentSchemaType.name)
     const documentTranslationEnabled =
-      isDocumentLevel &&
-      ((!docTransTypes && isAssistSupported(schemaType)) ||
-        docTransTypes?.includes(schemaType.name))
+      addFieldAction &&
+      documentSchemaType &&
+      ((!docTransTypes && isAssistSupported(fieldSchemaType)) ||
+        docTransTypes?.includes(documentSchemaType.name))
 
     // these checks are stable (ie, does not change after mount), so not breaking rules of hooks
-    if (documentTranslationEnabled || fieldTransEnabled) {
+    if (documentSchemaType && (documentTranslationEnabled || fieldTransEnabled)) {
       const {value: documentValue, onChange: documentOnChange} = useDocumentPane()
       const docRef = useRef(documentValue)
 
@@ -52,33 +69,47 @@ export const translateActions: DocumentFieldAction = {
       docRef.current = documentValue
       const languagePath = config.translate?.document?.languageField
 
-      //const {value: languageId} = extractWithPath(languagePath, documentValue)[0] ?? {}
       // if this is true, it is stable, and not breaking rules of hooks
-      const translateDocumentAction = useMemo(
-        () =>
-          languagePath && documentTranslationEnabled
-            ? node({
-                type: 'action',
-                icon: translationApi.loading
-                  ? () => (
-                      <Box style={{height: 17}}>
-                        <Spinner style={{transform: 'translateY(6px)'}} />
-                      </Box>
-                    )
-                  : TranslateIcon,
-                title: `Translate document`,
-                onAction: () => {
-                  if (translationApi.loading || !languagePath || !documentId) {
-                    return
-                  }
-                  translate({languagePath, documentId: documentId ?? ''})
-                },
-                renderAsButton: true,
-                disabled: translationApi.loading,
-              })
-            : undefined,
-        [languagePath, translate, documentId, translationApi.loading, documentTranslationEnabled]
-      )
+      const translateDocumentAction = useMemo(() => {
+        if (!languagePath || !documentTranslationEnabled) {
+          return undefined
+        }
+        const {value: languageId} = extractWithPath(languagePath, documentValue)[0] ?? {}
+        const title = path.length ? `Translate` : `Translate document`
+        return node({
+          type: 'action',
+          icon: translationApi.loading
+            ? () => (
+                <Box style={{height: 17}}>
+                  <Spinner style={{transform: 'translateY(6px)'}} />
+                </Box>
+              )
+            : TranslateIcon,
+          title,
+          onAction: () => {
+            if (translationApi.loading || !languagePath || !documentId) {
+              return
+            }
+            translate({
+              languagePath,
+              translatePath: path,
+              documentId: documentId ?? '',
+            })
+          },
+          renderAsButton: true,
+          disabled:
+            translationApi.loading || !languageId
+              ? {reason: 'Language is not set for this document'}
+              : undefined,
+        })
+      }, [
+        languagePath,
+        translate,
+        documentId,
+        translationApi.loading,
+        documentTranslationEnabled,
+        path,
+      ])
 
       const fieldTranslate = useFieldTranslation()
       const openFieldTranslation = useDraftDelayedTask({
@@ -99,14 +130,15 @@ export const translateActions: DocumentFieldAction = {
                       </Box>
                     )
                   : TranslateIcon,
-                title: `Translate fields`,
+                title: `Translate fields...`,
                 onAction: () => {
                   if (fieldTranslate.translationLoading || !documentId) {
                     return
                   }
                   openFieldTranslation({
                     document: docRef.current,
-                    documentSchema: schemaType as ObjectSchemaType,
+                    documentSchema: documentSchemaType,
+                    translatePath: path,
                   })
                 },
                 renderAsButton: true,
@@ -115,10 +147,11 @@ export const translateActions: DocumentFieldAction = {
             : undefined,
         [
           openFieldTranslation,
-          schemaType,
+          documentSchemaType,
           documentId,
           fieldTranslate.translationLoading,
           fieldTransEnabled,
+          path,
         ]
       )
 
@@ -127,7 +160,7 @@ export const translateActions: DocumentFieldAction = {
         return node({
           type: 'group',
           icon: () => null,
-          title: 'Translate',
+          title: 'Translation',
           children: [translateDocumentAction, translateFieldsAction].filter(
             (c): c is DocumentFieldActionItem => !!c
           ),

package/src/useApiClient.ts

@@ -1,9 +1,10 @@
-import {useClient, useCurrentUser, useSchema} from 'sanity'
+import {Path, pathToString, useClient, useCurrentUser, useSchema} from 'sanity'
 import {useCallback, useMemo, useState} from 'react'
 import {serializeSchema} from './schemas/serialize/serializeSchema'
 import {useToast} from '@sanity/ui'
 import {SanityClient} from '@sanity/client'
-import {TranslationMap} from './translate/paths'
+import {FieldLanguageMap} from './translate/paths'
+import {documentRootKey} from './types'
 
 export interface UserTextInstance {
   blockKey: string
@@ -26,6 +27,13 @@ export interface InstructStatus {
   validToken: boolean
 }
 
+export interface TranslateRequest {
+  documentId: string
+  translatePath: Path
+  languagePath?: string
+  fieldLanguageMap?: FieldLanguageMap[]
+}
+
 const basePath = '/assist/tasks/instruction'
 
 export function useApiClient(customApiClient?: (defaultClient: SanityClient) => SanityClient) {
@@ -44,15 +52,7 @@ export function useTranslate(apiClient: SanityClient) {
   const toast = useToast()
 
   const translate = useCallback(
-    ({
-      documentId,
-      languagePath,
-      fieldLanguageMap,
-    }: {
-      documentId: string
-      languagePath?: string
-      fieldLanguageMap?: TranslationMap[]
-    }) => {
+    ({documentId, languagePath, translatePath, fieldLanguageMap}: TranslateRequest) => {
       setLoading(true)
 
       return apiClient
@@ -66,6 +66,8 @@ export function useTranslate(apiClient: SanityClient) {
             types,
             languagePath,
             fieldLanguageMap,
+            translatePath:
+              translatePath.length === 0 ? documentRootKey : pathToString(translatePath),
             userId: user?.id,
           },
         })
@@ -151,6 +153,59 @@ export function useGenerateCaption(apiClient: SanityClient) {
   )
 }
 
+export function useGenerateImage(apiClient: SanityClient) {
+  const [loading, setLoading] = useState(false)
+  const user = useCurrentUser()
+  const schema = useSchema()
+  const types = useMemo(() => serializeSchema(schema, {leanFormat: true}), [schema])
+  const toast = useToast()
+
+  const generateImage = useCallback(
+    ({path, documentId}: {path: string; documentId: string}) => {
+      setLoading(true)
+
+      return apiClient
+        .request({
+          method: 'POST',
+          url: `/assist/tasks/generate-image/${apiClient.config().dataset}?projectId=${
+            apiClient.config().projectId
+          }`,
+          body: {
+            path,
+            documentId,
+            types,
+            userId: user?.id,
+          },
+        })
+        .catch((e) => {
+          toast.push({
+            status: 'error',
+            title: 'Generate image from prompt failed',
+            description: e.message,
+          })
+          setLoading(false)
+          throw e
+        })
+        .finally(() => {
+          // adding some artificial delay here
+          // server responds with 201 then proceeds; we dont need to allow spamming the button
+          setTimeout(() => {
+            setLoading(false)
+          }, 2000)
+        })
+    },
+    [setLoading, apiClient, toast, user, types]
+  )
+
+  return useMemo(
+    () => ({
+      generateImage,
+      loading,
+    }),
+    [generateImage, loading]
+  )
+}
+
 export function useGetInstructStatus(apiClient: SanityClient) {
   const [loading, setLoading] = useState(true)