@sanity/assist 5.0.4 → 6.0.0

package/src/fieldActions/generateCaptionActions.tsx

@@ -1,77 +0,0 @@
-import {ImageIcon} from '@sanity/icons'
-import {Box, Spinner} from '@sanity/ui'
-import {useContext, useMemo} from 'react'
-import type {DocumentFieldAction, DocumentFieldActionGroup, DocumentFieldActionItem} from 'sanity'
-import {useDocumentPane} from 'sanity/structure'
-
-import {useAssistDocumentContext} from '../assistDocument/AssistDocumentContext'
-import {aiInspectorId} from '../assistInspector/constants'
-import {useAiAssistanceConfig} from '../assistLayout/AiAssistanceConfigContext'
-import {ImageContext} from '../components/ImageContext'
-import {usePathKey} from '../helpers/misc'
-import {fieldPathParam, instructionParam} from '../types'
-import {canUseAssist, useApiClient, useGenerateCaption} from '../useApiClient'
-
-function node(node: DocumentFieldActionItem | DocumentFieldActionGroup) {
-  return node
-}
-
-export const generateCaptionsActions: DocumentFieldAction = {
-  name: 'sanity-assist-generate-captions',
-  useAction(props) {
-    const pathKey = usePathKey(props.path)
-    const {openInspector} = useDocumentPane()
-
-    const {config, status} = useAiAssistanceConfig()
-    const apiClient = useApiClient(config?.__customApiClient)
-    const {generateCaption, loading} = useGenerateCaption(apiClient)
-    const imageContext = useContext(ImageContext)
-
-    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 {assistableDocumentId} = 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 description',
-          onAction: () => {
-            if (loading) {
-              return
-            }
-            if (!canUseAssist(status)) {
-              openInspector(aiInspectorId, {
-                [fieldPathParam]: pathKey,
-                [instructionParam]: undefined as any,
-              })
-              return
-            }
-            generateCaption({path: pathKey, documentId: assistableDocumentId})
-          },
-          renderAsButton: true,
-          disabled: loading,
-          hidden: !imageContext.assetRef,
-        })
-      }, [
-        generateCaption,
-        pathKey,
-        assistableDocumentId,
-        loading,
-        imageContext,
-        status,
-        openInspector,
-      ])
-    }
-
-    // works but not supported by types
-    return undefined as unknown as DocumentFieldActionItem
-  },
-}

package/src/fieldActions/generateImageActions.tsx

@@ -1,58 +0,0 @@
-import {ImageIcon} from '@sanity/icons'
-import {Box, Spinner} from '@sanity/ui'
-import {useContext, useMemo} from 'react'
-import {DocumentFieldAction, DocumentFieldActionGroup, DocumentFieldActionItem} from 'sanity'
-
-import {useAssistDocumentContext} from '../assistDocument/AssistDocumentContext'
-import {useAiAssistanceConfig} from '../assistLayout/AiAssistanceConfigContext'
-import {ImageContext} from '../components/ImageContext'
-import {usePathKey} from '../helpers/misc'
-import {useApiClient, useGenerateImage} from '../useApiClient'
-
-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 {assistableDocumentId} = 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: assistableDocumentId})
-          },
-          renderAsButton: true,
-          disabled: loading,
-        })
-      }, [generateImage, pathKey, assistableDocumentId, loading])
-    }
-
-    // works but not supported by types
-    return undefined as unknown as DocumentFieldActionItem
-  },
-}

package/src/fieldActions/useUserInput.ts

@@ -1,107 +0,0 @@
-import {useRunInstruction} from '../assistLayout/RunInstructionProvider'
-
-export type GetUserInput = (args: {
-  /**
-   * Dialog title
-   */
-  title: string
-  /**
-   * One titled input per array item
-   */
-  inputs: CustomInput[]
-}) => Promise<CustomInputResult[] | undefined>
-
-/**
- *
- */
-export interface CustomInput {
-  /**
-   * Id for the input
-   */
-  id: string
-  /**
-   * Title of the input field
-   */
-  title: string
-  /**
-   * Additional info that will be displayed over the input
-   */
-  description?: string
-}
-
-export type CustomInputResult = {
-  /**
-   * Identifies which custom input the `result`belongs to
-   */
-  input: CustomInput
-
-  /**
-   * The text provided by the user in the input
-   */
-  result: string
-}
-
-/**
- * `useUserInput` returns a function that can be used to await user input.
- *
- * Useful for custom `fieldActions` to get user input for populating Agent Action requests,.
- *
- * ```ts
- *  fieldActions: {
- *   useFieldActions: (props) => {
- *     const {
- *       documentSchemaType,
- *       schemaId,
- *       getDocumentValue,
- *       getConditionalPaths,
- *       documentIdForAction,
- *     } = props
- *     const client = useClient({apiVersion: 'vX'})
- *     const getUserInput = useUserInput()
- *     return useMemo(() => {
- *       return [
- *         defineAssistFieldAction({
- *           title: 'Log user input',
- *           icon: UserIcon,
- *           onAction: async () => {
- *             const input = await getUserInput({
- *               title: 'Topic',
- *               inputs: [{id: 'about', title: 'What should the article be about?'}],
- *             })
- *             if (!input) return // user canceled input
- *             await client.agent.action.generate({
- *               schemaId,
- *               targetDocument: {
- *                 operation: 'createIfNotExists',
- *                 _id: documentIdForAction,
- *                 _type: documentSchemaType.name,
- *                 initialValues: getDocumentValue(),
- *               },
- *               instruction: `
- *                   Create a document about the following topic:
- *                   $about
- *                   ---
- *                `,
- *               instructionParams: {about: input[0].result},
- *               conditionalPaths: {paths: getConditionalPaths()},
- *             })
- *           },
- *         }),
- *       ]
- *     }, [
- *       client,
- *       documentSchemaType,
- *       schemaId,
- *       getDocumentValue,
- *       getConditionalPaths,
- *       documentIdForAction,
- *       getUserInput,
- *     ])
- *   },
- * }
- * ```
- */
-export function useUserInput(): GetUserInput {
-  const {getUserInput} = useRunInstruction()
-  return getUserInput
-}

package/src/globals.d.ts

@@ -1,4 +0,0 @@
-declare module '*.png'
-declare module '*.svg'
-declare module '*.jpeg'
-declare module '*.jpg'

package/src/helpers/assistSupported.ts

@@ -1,49 +0,0 @@
-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)?.aiAssist?.exclude
-}
-
-export function isAssistSupported(type: SchemaType) {
-  if (!isSchemaAssistEnabled(type)) {
-    return false
-  }
-
-  if (isDisabled(type)) {
-    return false
-  }
-
-  if (type.jsonType === 'array') {
-    const unsupportedArray = type.of.every((t) => isDisabled(t))
-    return !unsupportedArray
-  }
-
-  if (type.jsonType === 'object') {
-    const unsupportedObject = type.fields.every((field) => isDisabled(field.type))
-    return (
-      !unsupportedObject ||
-      /* to allow attaching custom actions on fieldless images */
-      isType(type, 'image')
-    )
-  }
-  return true
-}
-
-function isDisabled(type: SchemaType) {
-  return !isSchemaAssistEnabled(type) || isUnsupportedType(type)
-}
-
-function isUnsupportedType(type: SchemaType) {
-  return (
-    type.name === 'sanity.imageCrop' ||
-    type.name === 'sanity.imageHotspot' ||
-    isType(type, 'globalDocumentReference') ||
-    (isType(type, 'reference') &&
-      !(type?.options as ReferenceOptions)?.aiAssist?.embeddingsIndex) ||
-    isType(type, 'crossDatasetReference') ||
-    isType(type, 'file')
-  )
-}

package/src/helpers/conditionalMembers.test.ts

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