@sanity/assist 5.0.4 → 6.0.1

package/src/fieldActions/assistFieldActions.tsx

@@ -1,320 +0,0 @@
-import {ControlsIcon, SparklesIcon} from '@sanity/icons'
-import {useCallback, useMemo, useRef} from 'react'
-import {
-  type DocumentFieldAction,
-  type DocumentFieldActionGroup,
-  type DocumentFieldActionItem,
-  pathToString,
-  stringToPath,
-  typed,
-  useCurrentUser,
-} from 'sanity'
-import {useDocumentPane} from 'sanity/structure'
-
-import {useAssistDocumentContext} from '../assistDocument/AssistDocumentContext'
-import {getIcon} from '../assistDocument/components/instruction/appearance/IconInput'
-import {useRequestRunInstruction} from '../assistDocument/RequestRunInstructionProvider'
-import {aiInspectorId} from '../assistInspector/constants'
-import {getTypePath, useSelectedField, useTypePath} from '../assistInspector/helpers'
-import {pluginTitleShort} from '../constants'
-import {isSchemaAssistEnabled} from '../helpers/assistSupported'
-import {getConditionalMembers} from '../helpers/conditionalMembers'
-import {getInstructionTitle, usePathKey} from '../helpers/misc'
-import {useAssistSupported} from '../helpers/useAssistSupported'
-import {translateActions, type TranslateProps} from '../translate/translateActions'
-import {documentRootKey, fieldPathParam, instructionParam, type StudioInstruction} from '../types'
-import {generateCaptionsActions} from './generateCaptionActions'
-import {generateImagActions} from './generateImageActions'
-import {PrivateIcon} from './PrivateIcon'
-import {AgentActionConditionalPath, useCustomFieldActions} from './customFieldActions'
-import {AgentActionPath} from '@sanity/client/stega'
-
-function node(node: DocumentFieldActionItem | DocumentFieldActionGroup) {
-  return node
-}
-
-export const assistFieldActions: DocumentFieldAction = {
-  name: 'sanity-assist-actions',
-  useAction(props) {
-    const {schemaType} = props
-
-    const {
-      assistDocument,
-      documentIsNew,
-      documentIsAssistable,
-      openInspector,
-      closeInspector,
-      inspector,
-      documentOnChange,
-      documentSchemaType,
-      selectedPath,
-      assistableDocumentId,
-      fieldRefsByTypePath,
-    } = useAssistDocumentContext()
-
-    const {value: docValue, formState} = useDocumentPane()
-    const docValueRef = useRef(docValue)
-    const formStateRef = useRef(formState)
-    formStateRef.current = formState
-
-    const currentUser = useCurrentUser()
-    const isHidden = !assistDocument
-    const pathKey = usePathKey(props.path)
-    const typePath = useTypePath(docValue, pathKey)
-    const assistDocumentId = assistDocument?._id
-
-    const {requestRunInstruction} = useRequestRunInstruction({
-      documentOnChange,
-      isDocAssistable: documentIsAssistable ?? false,
-    })
-
-    const isSelectable = !!useSelectedField(documentSchemaType, typePath)
-    const assistSupported =
-      useAssistSupported(props.path, schemaType) &&
-      isSelectable &&
-      isSchemaAssistEnabled(documentSchemaType) &&
-      schemaType.readOnly !== true
-
-    const fieldAssist = useMemo(
-      () =>
-        (assistDocument?.fields ?? []).find(
-          (f) => f.path === typePath || (pathKey === documentRootKey && f.path === pathKey),
-        ),
-      [assistDocument?.fields, pathKey, typePath],
-    )
-
-    const fieldAssistKey = fieldAssist?._key
-    const isInspectorOpen = inspector?.name === aiInspectorId
-    const isPathSelected = pathKey === selectedPath
-    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
-          ? closeInspector(aiInspectorId)
-          : openInspector(aiInspectorId, {
-              [fieldPathParam]: pathKey,
-              [instructionParam]: undefined as any,
-            }),
-      [openInspector, closeInspector, isSelected, pathKey],
-    )
-
-    const onInstructionAction = useCallback(
-      (instruction: StudioInstruction) => {
-        if (!pathKey || !fieldAssistKey || !assistDocumentId || !assistableDocumentId) {
-          return
-        }
-        requestRunInstruction({
-          documentId: assistableDocumentId,
-          assistDocumentId,
-          path: pathKey,
-          typePath,
-          instruction,
-          conditionalMembers: formStateRef.current
-            ? getConditionalMembers(formStateRef.current)
-            : [],
-        })
-      },
-      [
-        requestRunInstruction,
-        assistableDocumentId,
-        pathKey,
-        typePath,
-        assistDocumentId,
-        fieldAssistKey,
-      ],
-    )
-
-    const privateInstructions = useMemo(
-      () =>
-        fieldAssist?.instructions?.filter((i) => i.userId && i.userId === currentUser?.id) || [],
-      [fieldAssist?.instructions, currentUser],
-    )
-
-    const sharedInstructions = useMemo(
-      () => fieldAssist?.instructions?.filter((i) => !i.userId) || [],
-      [fieldAssist?.instructions],
-    )
-
-    const instructions = useMemo(
-      () => [...privateInstructions, ...sharedInstructions],
-      [privateInstructions, sharedInstructions],
-    )
-
-    const runInstructionsGroup = useMemo(() => {
-      return instructions?.length || imageCaptionAction || translateAction || imageGenAction
-        ? node({
-            type: 'group',
-            icon: () => null,
-            title: 'Run instructions',
-            children: [
-              ...(instructions?.map((instruction) =>
-                instructionItem({
-                  instruction,
-                  isPrivate: Boolean(instruction.userId && instruction.userId === currentUser?.id),
-                  onInstructionAction,
-                  hidden: isHidden,
-                  documentIsNew: !!documentIsNew,
-                  assistSupported,
-                }),
-              ) || []),
-              imageCaptionAction,
-              imageGenAction,
-            ].filter((a): a is DocumentFieldActionItem => !!a),
-            expanded: true,
-          })
-        : undefined
-    }, [
-      instructions,
-      currentUser?.id,
-      onInstructionAction,
-      isHidden,
-      documentIsNew,
-      assistSupported,
-      imageCaptionAction,
-      translateAction,
-      imageGenAction,
-    ])
-
-    const getDocumentValue = useCallback(() => {
-      return docValueRef.current
-    }, [])
-
-    const getConditionalPaths: () => AgentActionConditionalPath[] = useCallback(() => {
-      return (formStateRef.current ? getConditionalMembers(formStateRef.current) : []).flatMap(
-        (cm) => {
-          const path = stringToPath(cm.path)
-          if (path.some((s) => typeof s === 'number')) {
-            //agent actions does not support indexed paths
-            return []
-          }
-          return {
-            ...cm,
-            path: path as AgentActionPath,
-          }
-        },
-      )
-    }, [])
-
-    const parentSchemaType = useMemo(() => {
-      if (!props.path.length) {
-        return undefined
-      } else if (props.path.length === 1) {
-        return documentSchemaType
-      }
-      const parentPath = props.path.slice(0, -1)
-      const typePath = getTypePath(docValueRef.current, pathToString(parentPath))
-      return typePath ? fieldRefsByTypePath[typePath]?.schemaType : undefined
-    }, [fieldRefsByTypePath, props.path, documentSchemaType])
-
-    const customActions = useCustomFieldActions({
-      actionType: props.path.length ? 'field' : 'document',
-      documentIdForAction: assistableDocumentId,
-      schemaType,
-      documentSchemaType,
-      path: props.path,
-      getDocumentValue,
-      getConditionalPaths,
-      parentSchemaType,
-    })
-
-    const manageInstructionsItem = useMemo(
-      () =>
-        node({
-          type: 'action',
-          icon: ControlsIcon,
-          title: 'Manage instructions',
-          onAction: manageInstructions,
-          selected: isSelected,
-        }),
-      [manageInstructions, isSelected],
-    )
-
-    const group = useMemo(
-      () =>
-        node({
-          type: 'group',
-          icon: SparklesIcon,
-          title: pluginTitleShort,
-          children: [
-            runInstructionsGroup,
-            translateAction,
-            ...customActions,
-            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 && !translateAction && !imageGenAction,
-        }),
-      [
-        //documentIsNew,
-        runInstructionsGroup,
-        manageInstructionsItem,
-        assistSupported,
-        imageCaptionAction,
-        translateAction,
-        imageGenAction,
-        customActions,
-      ],
-    )
-
-    const emptyAction = useMemo(
-      () =>
-        node({
-          type: 'action',
-          hidden: !assistSupported,
-          icon: SparklesIcon,
-          onAction: manageInstructions,
-          renderAsButton: true,
-          title: pluginTitleShort,
-          selected: isSelected,
-        }),
-      [assistSupported, manageInstructions, isSelected],
-    )
-
-    // If there are no instructions, we don't want to render the group
-    if (
-      !instructions?.length &&
-      !imageCaptionAction &&
-      !translateAction &&
-      !imageGenAction &&
-      !customActions.length
-    ) {
-      return emptyAction
-    }
-
-    return group
-  },
-}
-
-function instructionItem(props: {
-  instruction: StudioInstruction
-  isPrivate: boolean
-  onInstructionAction: (ins: StudioInstruction) => void
-  assistSupported: boolean
-  documentIsNew: boolean
-  hidden: boolean
-}) {
-  const {hidden, isPrivate, onInstructionAction, assistSupported, instruction} = props
-  return node({
-    type: 'action',
-    icon: getIcon(instruction.icon),
-    iconRight: isPrivate ? PrivateIcon : undefined,
-    title: getInstructionTitle(instruction),
-    onAction: () => onInstructionAction(instruction),
-    disabled: !assistSupported,
-    hidden,
-  })
-}

package/src/fieldActions/customFieldActions.tsx

@@ -1,333 +0,0 @@
-import {
-  DocumentFieldActionDivider,
-  DocumentFieldActionGroup,
-  DocumentFieldActionItem,
-  DocumentFieldActionNode,
-  ObjectSchemaType,
-  Path,
-  SanityDocumentLike,
-  SchemaType,
-  useWorkspaceSchemaId,
-} from 'sanity'
-import {useMemo} from 'react'
-import {useAiAssistanceConfig} from '../assistLayout/AiAssistanceConfigContext'
-import {ToastParams, useToast} from '@sanity/ui'
-import {AgentActionPath} from '@sanity/client/stega'
-import {useAssistDocumentContext} from '../assistDocument/AssistDocumentContext'
-import {
-  documentRootKey,
-  fieldPresenceTypeName,
-  InstructionTask,
-  instructionTaskTypeName,
-} from '../types'
-import {randomKey} from '../_lib/randomKey'
-import {isDefined} from '../helpers/misc'
-
-export interface AgentActionConditionalPath {
-  path: AgentActionPath
-  readOnly: boolean
-  hidden: boolean
-}
-
-export interface AssistFieldActionProps {
-  /**
-   * `actionType` will be `document` for action invoked from the top right document action menu, and
-   * `field` when invoked from a field action menu.
-   */
-  actionType: 'document' | 'field'
-  /**
-   * This is the id of the current document pane; it contains `drafts.`or `versions. prefix` ect depending on context.
-   * Use this for `documentId` when calling any `client.agent.action`.
-   *
-   * It is generally recommended to call actions from the studio like this:
-   * ```ts
-   * await client.agent.action.generate({
-   *   targetDocument: {
-   *      operation: 'createIfNotExists',
-   *      _id: props.documentIdForAction,
-   *      _type: props.documentSchemaType.name,
-   *      initialValues: props.getDocumentValue()
-   *   },
-   *   //...
-   * })
-   * ```
-   */
-  documentIdForAction: string
-
-  /**
-   * Schema type of the current document.
-   * @see documentIdForAction
-   */
-  documentSchemaType: ObjectSchemaType
-
-  /**
-   * Returns the current document value.
-   *
-   * Prefer passing this function to your hooks instead of passing the document value directly to avoid unnecessary re-renders.
-   * @see documentIdForAction
-   */
-  getDocumentValue: () => SanityDocumentLike
-
-  /**
-   * Returns the current readOnly and hidden state of all conditional members in the current document form.
-   *
-   * Intended to be passed to agent actions `conditionalPaths.paths`.
-   */
-  getConditionalPaths: () => AgentActionConditionalPath[]
-
-  /**
-   * `schemaId` for the current workspace.
-   *
-   * Note: the workspace schema has to be deployed using `sanity schema deploy` or `sanity deploy`.
-   *
-   * Use this for `schemaId` when calling any `client.agent.action`.
-   *
-   * It is generally recommended to call actions from the studio like this:
-   * ```ts
-   * await client.agent.action.generate({
-   *   targetDocument: {
-   *      operation: 'createIfNotExists',
-   *      _id: props.documentIdForAction,
-   *      _type: props.documentSchemaType.name,
-   *      initialValues: props.getDocumentValue()
-   *   },
-   *   //...
-   * })
-   *
-   * ```
-   */
-  schemaId: string
-
-  /**
-   * This is the schema type of the field the actions will be attached to (ie, schemaType for `path`)
-   *
-   * It can be used with agent actions using `target.path`, to scope the action to a specific field.
-   *
-   * It is generally recommended to call actions from the studio like this:
-   * ```ts
-   * await client.agent.action.generate({
-   *   targetDocument: {
-   *      operation: 'createIfNotExists',
-   *      _id: props.documentIdForAction,
-   *      _type: props.documentSchemaType.name,
-   *      initialValues: props.getDocumentValue()
-   *   },
-   *   target: {
-   *      path: props.path
-   *   },
-   * })
-   * ```
-   */
-  path: AgentActionPath
-
-  /**
-   * This is the schema type of the field the actions will be attached to (ie, schemaType for `path`).
-   *
-   * Typically useful to dynamically return different actions based on the schema type of the field.
-   *
-   * ```ts
-   * if(isObjectSchemaType(schemaType)) {
-   *   return [
-   *     defineAssistFieldAction({
-   *       title: 'Fill the object fields',
-   *       icon: RobotIcon,
-   *       onAction: () => {
-   *         //...
-   *       }
-   *     })
-   *   ]
-   * }
-   * return useMemo(() => {
-   *
-   *
-   * }, [])
-   *
-   * ```
-   */
-  schemaType: SchemaType
-
-  /**
-   * Schema type of the parent field or array item holding this field.
-   *
-   * This can be undefined if the action was unable to resolve the parent type is excluded from AI Assist.
-   *
-   * @see schemaType
-   * @see documentSchemaType
-   */
-  parentSchemaType?: SchemaType
-}
-
-export type AssistFieldActionNode =
-  | AssistFieldActionItem
-  | AssistFieldActionGroup
-  | DocumentFieldActionDivider
-
-export type AssistFieldActionItem = Omit<
-  DocumentFieldActionItem,
-  'renderAsButton' | 'selected' | 'onAction'
-> & {
-  onAction: () => void | Promise<void>
-}
-
-export type AssistFieldActionGroup = Omit<
-  DocumentFieldActionGroup,
-  'renderAsButton' | 'expanded' | 'children'
-> & {
-  /**
-   * `children` can include undefined entries in the action array. These will be filtered out.
-   * If the group has no defined children, the group will also be filtered out.
-   */
-  children: (AssistFieldActionNode | undefined)[]
-}
-
-type PushToast = (params: ToastParams) => string
-
-export function defineAssistFieldAction(
-  action: Omit<AssistFieldActionItem, 'type'>,
-): AssistFieldActionItem {
-  return {
-    ...action,
-    type: 'action',
-  }
-}
-
-export function defineFieldActionDivider(): DocumentFieldActionDivider {
-  return {
-    type: 'divider',
-  }
-}
-
-export function defineAssistFieldActionGroup(
-  group: Omit<AssistFieldActionGroup, 'type'>,
-): AssistFieldActionGroup {
-  return {
-    ...group,
-    type: 'group',
-  }
-}
-
-export function useCustomFieldActions(
-  props: Omit<AssistFieldActionProps, 'schemaId' | 'path'> & {path: Path},
-) {
-  const {
-    config: {fieldActions},
-  } = useAiAssistanceConfig()
-  const {addSyntheticTask, removeSyntheticTask} = useAssistDocumentContext()
-
-  const schemaId = useWorkspaceSchemaId()
-  const {push: pushToast} = useToast()
-  const configActions = fieldActions?.useFieldActions?.({
-    ...props,
-    schemaId,
-    path: props.path as AgentActionPath,
-  })
-
-  return useMemo(() => {
-    const title = fieldActions?.title
-    const customActions = configActions
-      ?.filter(isDefined)
-      .map((node) => {
-        return createSafeNode({
-          node,
-          pushToast,
-          addSyntheticTask,
-          removeSyntheticTask,
-        })
-      })
-      .filter(isDefined)
-    const onlyGroups =
-      customActions?.length && customActions?.every((node) => node.type === 'group')
-    const groups = customActions?.length
-      ? onlyGroups
-        ? customActions
-        : [
-            {
-              type: 'group',
-              title: title || 'Custom actions',
-              children: customActions,
-              expanded: true,
-            } satisfies DocumentFieldActionGroup,
-          ]
-      : []
-    return groups ?? []
-  }, [configActions, fieldActions, pushToast])
-}
-
-function createSafeNode(args: {
-  node: AssistFieldActionNode
-  pushToast: PushToast
-  addSyntheticTask: (task: InstructionTask) => void
-  removeSyntheticTask: (task: InstructionTask) => void
-}): DocumentFieldActionNode | undefined {
-  const {node} = args
-  switch (node.type) {
-    case 'action':
-      return createSafeAction({...args, action: node})
-    case 'group':
-      // eslint-disable-next-line no-case-declarations
-      const children = node.children
-        ?.filter(isDefined)
-        .map((child) => createSafeNode({...args, node: child}))
-        .filter(isDefined)
-      if (!children?.length) {
-        return undefined
-      }
-      return {
-        ...node,
-        renderAsButton: false,
-        expanded: true,
-        children,
-      }
-    case 'divider':
-    default:
-      return node
-  }
-}
-
-function createSafeAction(args: {
-  action: AssistFieldActionItem
-  pushToast: PushToast
-  addSyntheticTask: (task: InstructionTask) => void
-  removeSyntheticTask: (task: InstructionTask) => void
-}) {
-  const {action, pushToast, addSyntheticTask, removeSyntheticTask} = args
-  return {
-    ...action,
-    onAction: () => {
-      async function runAction() {
-        const task: InstructionTask = {
-          _type: instructionTaskTypeName,
-          _key: randomKey(12),
-          started: new Date().toISOString(),
-          presence: [
-            {
-              _type: fieldPresenceTypeName,
-              _key: randomKey(12),
-              path: documentRootKey,
-              started: new Date().toISOString(),
-            },
-          ],
-        }
-        try {
-          addSyntheticTask(task)
-          const actionResult = action.onAction?.()
-          if (actionResult instanceof Promise) {
-            await actionResult
-          }
-        } catch (err: any) {
-          console.error('Failed to execute action', action, err)
-          pushToast({
-            title: 'Failed to execute action',
-            description: err?.message,
-            status: 'error',
-          })
-        } finally {
-          removeSyntheticTask(task)
-        }
-      }
-      runAction()
-    },
-    renderAsButton: false,
-    selected: false,
-  }
-}