@sanity/assist 5.0.4 → 6.0.0

package/src/assistDocument/AssistDocumentContext.tsx

@@ -1,51 +0,0 @@
-import {createContext, useContext} from 'react'
-import {DocumentInspector, ObjectSchemaType, PatchEvent} from 'sanity'
-
-import {InstructionTask, StudioAssistDocument} from '../types'
-import {FieldRef} from '../assistInspector/helpers'
-
-export type AssistDocumentContextValue = (
-  | {assistDocument: StudioAssistDocument; loading: false}
-  | {assistDocument: undefined; loading: true}
-) & {
-  documentIsNew: boolean
-  /**
-   * This is the _actual_ id of the current document (ie the document loaded in the pane); it contains draft. versions. prefix ect depending on context
-   */
-  assistableDocumentId: string
-  documentIsAssistable: boolean
-  documentSchemaType: ObjectSchemaType
-  openInspector: (inspectorName: string, paneParams?: Record<string, string>) => void
-  closeInspector: (inspectorName?: string) => void
-  inspector: DocumentInspector | null
-  selectedPath?: string
-  documentOnChange: (event: PatchEvent) => void
-
-  /**
-   * Synthetic task is used to display AI presence at the document level for the user who started the action.
-   * These are not persisted, so other users will not see them.
-   * It is mostly a helper to give _some_ visual feedback to the user while a custom action is running.
-   * This also means that reloading the page will remove the icon.
-   *
-   * Agent Actions add their own "real" tasks, so if a custom action calls an Agent action, _those_ tasks
-   * are visible across sessions.
-   */
-  syntheticTasks?: InstructionTask[]
-  addSyntheticTask: (syntheticTask: InstructionTask) => void
-  removeSyntheticTask: (syntheticTask: InstructionTask) => void
-
-  fieldRefs: FieldRef[]
-  fieldRefsByTypePath: Record<string, FieldRef | undefined>
-}
-
-export const AssistDocumentContext = createContext<AssistDocumentContextValue | undefined>(
-  undefined,
-)
-
-export function useAssistDocumentContext(): AssistDocumentContextValue {
-  const context = useContext(AssistDocumentContext)
-  if (!context) {
-    throw new Error('AssistDocumentContext value is missing')
-  }
-  return context
-}

package/src/assistDocument/AssistDocumentContextProvider.tsx

@@ -1,17 +0,0 @@
-import {PropsWithChildren} from 'react'
-
-import {AssistDocumentContext} from './AssistDocumentContext'
-import {useAssistDocumentContextValue} from './hooks/useAssistDocumentContextValue'
-
-export interface AIDocumentInputProps {
-  documentId: string
-  documentType: string
-}
-
-export function AssistDocumentContextProvider(props: PropsWithChildren<AIDocumentInputProps>) {
-  const {documentId, documentType} = props
-  const value = useAssistDocumentContextValue(documentId, documentType)
-  return (
-    <AssistDocumentContext.Provider value={value}>{props.children}</AssistDocumentContext.Provider>
-  )
-}

package/src/assistDocument/AssistDocumentInput.tsx

@@ -1,61 +0,0 @@
-import {useLayer} from '@sanity/ui'
-import {useMemo} from 'react'
-import type {InputProps, ObjectInputProps, ObjectSchemaType} from 'sanity'
-import {useDocumentPane} from 'sanity/structure'
-
-import {ConnectFromRegion} from '../_lib/connector'
-import {assistFormId} from '../_lib/form/constants'
-import {usePathKey} from '../helpers/misc'
-import {isType} from '../helpers/typeUtils'
-import {FirstAssistedPathProvider} from '../onboarding/FirstAssistedPathProvider'
-import {assistDocumentTypeName} from '../types'
-import {useInstructionToaster} from './hooks/useInstructionToaster'
-
-export function AssistDocumentInputWrapper(props: InputProps) {
-  if (!isType(props.schemaType, 'document') && props.id !== 'root' && props.id !== assistFormId) {
-    return <AssistInput {...props} />
-  }
-
-  const documentId = (props.value as any)?._id as string | undefined
-  if (!documentId) {
-    return props.renderDefault(props)
-  }
-
-  return <AssistDocumentInput {...(props as ObjectInputProps)} documentId={documentId} />
-}
-
-function AssistDocumentInput({documentId, ...props}: ObjectInputProps & {documentId: string}) {
-  useInstructionToaster(documentId, props.schemaType)
-
-  const schemaType = useMemo(() => {
-    if (props.schemaType.name !== assistDocumentTypeName) {
-      return props.schemaType
-    }
-    return {
-      ...props.schemaType,
-      type: {
-        ...props.schemaType.type,
-        // compatability with i18nArrays plugin that requires this to be document
-        name: 'document',
-      },
-    } as ObjectSchemaType
-  }, [props.schemaType])
-
-  return (
-    <FirstAssistedPathProvider members={props.members}>
-      {props.renderDefault({...props, schemaType})}
-    </FirstAssistedPathProvider>
-  )
-}
-
-function AssistInput(props: InputProps) {
-  const {zIndex} = useLayer()
-  const {paneKey} = useDocumentPane()
-  const pathKey = usePathKey(props.path)
-
-  return (
-    <ConnectFromRegion _key={`${paneKey}_${pathKey}`} zIndex={zIndex} style={{minWidth: 0}}>
-      {props.renderDefault(props)}
-    </ConnectFromRegion>
-  )
-}

package/src/assistDocument/AssistDocumentLayout.tsx

@@ -1,12 +0,0 @@
-import {DocumentLayoutProps} from 'sanity'
-
-import {AssistDocumentContextProvider} from './AssistDocumentContextProvider'
-
-export function AssistDocumentLayout(props: DocumentLayoutProps) {
-  const {documentId, documentType} = props
-  return (
-    <AssistDocumentContextProvider documentType={documentType} documentId={documentId}>
-      {props.renderDefault(props)}
-    </AssistDocumentContextProvider>
-  )
-}

package/src/assistDocument/RequestRunInstructionProvider.tsx

@@ -1,61 +0,0 @@
-import {useCallback, useEffect, useState} from 'react'
-import {ObjectSchemaType, PatchEvent, SanityDocument, unset} from 'sanity'
-
-import {useRunInstruction} from '../assistLayout/RunInstructionProvider'
-
-export interface DraftDelayedTaskArgs<T> {
-  documentOnChange: (event: PatchEvent) => void
-  // indicates if the document is a draft or liveEditable currently
-  isDocAssistable: boolean
-  task: (args: T) => void
-}
-
-export function isDocAssistable(
-  documentSchemaType: ObjectSchemaType,
-  published?: SanityDocument | null,
-  draft?: SanityDocument | null,
-) {
-  return !!(documentSchemaType.liveEdit ? published : draft)
-}
-
-export function useRequestRunInstruction(args: {
-  documentOnChange: (event: PatchEvent) => void
-  // indicates if the document is a draft or liveEditable currently
-  isDocAssistable: boolean
-}) {
-  const {runInstruction, instructionLoading} = useRunInstruction()
-  const requestRunInstruction = useDraftDelayedTask({
-    ...args,
-    task: runInstruction,
-  })
-
-  return {
-    instructionLoading,
-    requestRunInstruction,
-  }
-}
-
-/**
- * Ensures that the current document is a draft before running task
- */
-export function useDraftDelayedTask<T>(args: DraftDelayedTaskArgs<T>) {
-  const {documentOnChange, isDocAssistable, task} = args
-
-  const [queuedArgs, setQueuedArgs] = useState<T | undefined>(undefined)
-
-  useEffect(() => {
-    if (queuedArgs && isDocAssistable) {
-      task(queuedArgs)
-      setQueuedArgs(undefined)
-    }
-  }, [queuedArgs, isDocAssistable, task])
-
-  return useCallback(
-    (taskArgs: T) => {
-      // make a dummy edit: this will trigger the document/draft to be created
-      documentOnChange(PatchEvent.from([unset(['_force_document_creation'])]))
-      setQueuedArgs(taskArgs)
-    },
-    [setQueuedArgs, documentOnChange],
-  )
-}

package/src/assistDocument/components/AssistDocumentForm.tsx

@@ -1,287 +0,0 @@
-import {Card, Stack, Text} from '@sanity/ui'
-import {useContext, useEffect, useMemo, useRef} from 'react'
-import {
-  FieldError,
-  FormCallbacksProvider,
-  FormCallbacksValue,
-  FormInput,
-  insert,
-  KeyedSegment,
-  MemberFieldError,
-  ObjectInputProps,
-  ObjectSchemaType,
-  PatchEvent,
-  Path,
-  SchemaType,
-  set,
-  setIfMissing,
-  stringToPath,
-  typed,
-  useFormCallbacks,
-  useSchema,
-} from 'sanity'
-
-import {useAiPaneRouter} from '../../assistInspector/helpers'
-import {useAiAssistanceConfig} from '../../assistLayout/AiAssistanceConfigContext'
-import {
-  AssistDocument,
-  AssistField,
-  assistFieldTypeName,
-  AssistInspectorRouteParams,
-  documentRootKey,
-  fieldPathParam,
-  instructionParam,
-  StudioInstruction,
-} from '../../types'
-import {AssistTypeContext} from './AssistTypeContext'
-import {BackToInstructionListLink} from './instruction/BackToInstructionsLink'
-import {SelectedFieldContextProvider, SelectedFieldContextValue} from './SelectedFieldContext'
-
-const EMPTY_FIELDS: AssistField[] = []
-
-export function AssistDocumentForm(props: ObjectInputProps) {
-  if (props.readOnly) {
-    return (
-      <Card border tone="caution" padding={2}>
-        <Text size={1}> You do not have sufficient permissions to manage instructions.</Text>
-      </Card>
-    )
-  }
-  return <AssistDocumentFormEditable {...props} />
-}
-function AssistDocumentFormEditable(props: ObjectInputProps) {
-  const {onChange} = props
-  const value = props.value as AssistDocument | undefined
-  const id = value?._id
-  const fields = value?.fields
-
-  const {params, setParams} = useAiPaneRouter()
-  const pathKey = params[fieldPathParam]
-  const {typePath, documentType: targetDocumentType} = useContext(AssistTypeContext)
-  const instruction = params[instructionParam]
-
-  const activeKey = useMemo(() => {
-    if (!typePath) {
-      return undefined
-    }
-    return (fields ?? EMPTY_FIELDS).find((f) => f.path === typePath)?._key
-  }, [fields, typePath])
-
-  const activePath: Path | undefined = useMemo(() => {
-    if (!activeKey) {
-      return undefined
-    }
-    const base = ['fields', {_key: activeKey}]
-    return instruction ? [...base, 'instructions', {_key: instruction}] : base
-  }, [activeKey, instruction])
-
-  const schema = useSchema()
-  const documentSchema: ObjectSchemaType | undefined = useMemo(() => {
-    if (!targetDocumentType) {
-      return undefined
-    }
-    return schema.get(targetDocumentType) as ObjectSchemaType
-  }, [schema, targetDocumentType])
-
-  const fieldSchema = useSelectedSchema(pathKey, documentSchema)
-
-  const context: SelectedFieldContextValue = useMemo(
-    () => ({
-      documentSchema,
-      fieldSchema: fieldSchema ?? documentSchema,
-    }),
-    [fieldSchema, documentSchema],
-  )
-
-  const title = value?.title
-
-  useEffect(() => {
-    if (!title && documentSchema && !id?.startsWith('drafts.')) {
-      onChange(set(documentSchema.title ?? documentSchema.name, ['title']))
-    }
-  }, [title, documentSchema, onChange, id])
-
-  const {onPathOpen, ...formCallbacks} = useFormCallbacks()
-
-  const newCallbacks: FormCallbacksValue = useMemo(
-    () => ({
-      ...formCallbacks,
-      onPathOpen: (path) => {
-        if (!instruction && path.length === 4 && path[2] === 'instructions') {
-          setParams(
-            typed<AssistInspectorRouteParams>({
-              ...params,
-              [instructionParam]: (path[3] as KeyedSegment)?._key,
-            }) as Record<keyof AssistInspectorRouteParams, string | undefined>,
-          )
-        } else {
-          setTimeout(() => onPathOpen(path), 0)
-        }
-      },
-    }),
-    [formCallbacks, onPathOpen, params, setParams, instruction],
-  )
-
-  // When showing the instruction list (no specific instruction selected),
-  // tell the form to focus on the field path to close any open modals
-  useEffect(() => {
-    if (activePath && !instruction) {
-      onPathOpen(activePath)
-    }
-  }, [activePath, instruction, onPathOpen])
-
-  const fieldError = useMemo(() => {
-    const fieldError = props.members.find(
-      (m): m is FieldError => m.kind === 'error' && m.fieldName === 'fields',
-    )
-    if (fieldError) {
-      return <MemberFieldError member={fieldError} />
-    }
-    return undefined
-  }, [props.members])
-
-  return (
-    <SelectedFieldContextProvider value={context}>
-      <Stack space={5}>
-        <FieldsInitializer
-          key={typePath}
-          pathKey={typePath}
-          activePath={activePath}
-          fields={fields}
-          documentSchema={documentSchema}
-          onChange={onChange}
-        />
-        {instruction && <BackToInstructionListLink />}
-
-        {activePath && !fieldError && (
-          <FormCallbacksProvider {...newCallbacks}>
-            <div style={{lineHeight: '1.25em'}}>
-              <FormInput {...props} absolutePath={activePath} />
-            </div>
-          </FormCallbacksProvider>
-        )}
-
-        {fieldError}
-
-        {!activePath && props.renderDefault(props)}
-      </Stack>
-    </SelectedFieldContextProvider>
-  )
-}
-
-function useSelectedSchema(
-  fieldPath: string | undefined,
-  documentSchema: ObjectSchemaType | undefined,
-): SchemaType | undefined {
-  return useMemo(() => {
-    if (!fieldPath) {
-      return undefined
-    }
-    if (fieldPath === documentRootKey) {
-      return documentSchema
-    }
-
-    const path = stringToPath(fieldPath)
-    let currentSchema: ObjectSchemaType | undefined = documentSchema
-    for (let i = 0; i < path.length; i++) {
-      const segment = path[i]
-      const field = currentSchema?.fields.find((f) => f.name === segment)
-      if (!field) {
-        return undefined
-      }
-      if (i === path.length - 1) {
-        return field.type
-      }
-      if (field.type.jsonType !== 'object') {
-        return undefined
-      }
-      currentSchema = field.type
-    }
-    return currentSchema
-  }, [documentSchema, fieldPath])
-}
-
-function FieldsInitializer({
-  pathKey,
-  activePath,
-  fields,
-  documentSchema,
-  onChange,
-}: {
-  pathKey?: string
-  activePath?: Path
-  fields: AssistField[] | undefined
-  documentSchema: ObjectSchemaType | undefined
-  onChange: ObjectInputProps['onChange']
-}) {
-  const {
-    config: {__presets: presets},
-  } = useAiAssistanceConfig()
-
-  const existingField = fields?.find((f) => f._key === pathKey)
-  const documentPresets = !!documentSchema?.name && presets?.[documentSchema?.name]
-
-  const missingPresetInstructions = useMemo(() => {
-    if (!documentPresets || !pathKey) {
-      return undefined
-    }
-    const existingInstructions = existingField?.instructions
-    const presetField = documentPresets.fields?.find((f) => f.path === pathKey)
-    return presetField?.instructions?.filter(
-      (i) => !existingInstructions?.some((ei) => ei._key === i._key),
-    )
-  }, [documentPresets, pathKey, existingField])
-
-  // need this to not fire onChange twice in React strict mode
-  const initialized = useRef(false)
-  useEffect(() => {
-    if (initialized.current || !pathKey) {
-      return
-    }
-    if (existingField && !missingPresetInstructions?.length) {
-      return
-    }
-
-    let event = PatchEvent.from([setIfMissing([], ['fields'])])
-    if (!existingField) {
-      event = event.append(
-        insert(
-          [
-            typed<AssistField>({
-              _key: pathKey,
-              _type: assistFieldTypeName,
-              path: pathKey,
-              instructions: [],
-            }),
-          ],
-          'after',
-          ['fields', -1],
-        ),
-      )
-    }
-
-    if (!existingField?.instructions?.length) {
-      event = event.append([setIfMissing([], ['fields', {_key: pathKey}, 'instructions'])])
-    }
-
-    if (missingPresetInstructions?.length) {
-      event = event.append(
-        insert(
-          missingPresetInstructions.map(
-            (preset): StudioInstruction => ({
-              ...preset,
-              _type: 'sanity.assist.instruction',
-              prompt: preset.prompt?.map((p) => ({markDefs: [], ...p})),
-            }),
-          ),
-          'after',
-          ['fields', {_key: pathKey}, 'instructions', -1],
-        ),
-      )
-    }
-    onChange(event)
-    initialized.current = true
-  }, [activePath, onChange, pathKey, existingField, missingPresetInstructions])
-
-  return null
-}

package/src/assistDocument/components/AssistTypeContext.tsx

@@ -1,7 +0,0 @@
-import {createContext} from 'react'
-
-export interface AssistTypeContextValue {
-  typePath?: string
-  documentType?: string
-}
-export const AssistTypeContext = createContext<AssistTypeContextValue>({})

package/src/assistDocument/components/FieldRefPreview.tsx

@@ -1,26 +0,0 @@
-import {Box, Flex, Text} from '@sanity/ui'
-import {useContext} from 'react'
-import {PreviewProps} from 'sanity'
-
-import {InlineBlockValueContext} from '../../assistFormComponents/AssistInlineFormBlock'
-import {useSelectedField} from '../../assistInspector/helpers'
-import {SelectedFieldContext} from './SelectedFieldContext'
-
-export function FieldRefPreview(props: PreviewProps & {path?: string}) {
-  const {actions} = props
-  const documentSchema = useContext(SelectedFieldContext)?.documentSchema
-  const path = (useContext(InlineBlockValueContext) as {path?: string})?.path ?? props.path
-  const selectedField = useSelectedField(documentSchema, path)
-  return (
-    <Flex gap={2} align="center" style={{width: '100%'}}>
-      <Flex flex={1} gap={2} align="center" paddingY={3} paddingX={1}>
-        <Box>
-          <Text size={1} textOverflow="ellipsis">
-            {selectedField?.title ?? 'Select field'}
-          </Text>
-        </Box>
-      </Flex>
-      {actions as any}
-    </Flex>
-  )
-}

package/src/assistDocument/components/InstructionsArrayField.tsx

@@ -1,8 +0,0 @@
-import {ArrayFieldProps} from 'sanity'
-
-export function InstructionsArrayField(props: ArrayFieldProps) {
-  return props.renderDefault({
-    ...props,
-    title: ' ',
-  })
-}

package/src/assistDocument/components/InstructionsArrayInput.tsx

@@ -1,27 +0,0 @@
-import {useMemo} from 'react'
-import {ArrayOfObjectsInputProps, useCurrentUser} from 'sanity'
-
-import {StudioInstruction} from '../../types'
-
-export function InstructionsArrayInput(props: ArrayOfObjectsInputProps) {
-  const user = useCurrentUser()
-
-  const originalValue = props.value as StudioInstruction[] | undefined
-  const originalMembers = props.members
-  const value = useMemo(
-    () => (originalValue ?? []).filter((v) => !v.userId || v.userId === user?.id),
-    [originalValue, user],
-  )
-  const members = useMemo(
-    () =>
-      (originalMembers ?? []).filter((v) => {
-        if (v.kind === 'error') {
-          return true
-        }
-        const value = v?.item?.value as any
-        return !value.userId || value.userId === user?.id
-      }),
-    [originalMembers, user],
-  )
-  return props.renderDefault({...props, value, members})
-}

package/src/assistDocument/components/SelectedFieldContext.tsx

@@ -1,10 +0,0 @@
-import {createContext} from 'react'
-import {ObjectSchemaType, SchemaType} from 'sanity'
-
-export interface SelectedFieldContextValue {
-  documentSchema?: ObjectSchemaType
-  fieldSchema?: SchemaType
-}
-
-export const SelectedFieldContext = createContext<SelectedFieldContextValue | undefined>(undefined)
-export const SelectedFieldContextProvider = SelectedFieldContext.Provider

package/src/assistDocument/components/generic/HiddenFieldTitle.tsx

@@ -1,5 +0,0 @@
-import {FieldProps} from 'sanity'
-
-export function HiddenFieldTitle(props: FieldProps) {
-  return props.renderDefault({...props, title: '', level: props.level - 2, changed: false})
-}

package/src/assistDocument/components/helpers.ts

@@ -1,21 +0,0 @@
-import {FieldError, FieldMember, FieldSetMember, ObjectMember} from 'sanity'
-
-export function findFieldMember(
-  members: ObjectMember[],
-  fieldName: string,
-): FieldMember | FieldError | undefined {
-  return members.find(
-    (m): m is FieldMember | FieldError =>
-      (m.kind === 'field' && m.name === fieldName) ||
-      (m.kind === 'error' && m.fieldName === fieldName),
-  )
-}
-
-export function findFieldsetMember(
-  members: ObjectMember[],
-  fieldsetName: string,
-): FieldSetMember | undefined {
-  return members.find(
-    (m): m is FieldSetMember => m.kind === 'fieldSet' && m.fieldSet.name === fieldsetName,
-  )
-}

package/src/assistDocument/components/instruction/BackToInstructionsLink.tsx

@@ -1,32 +0,0 @@
-import {ArrowLeftIcon} from '@sanity/icons'
-import {Button} from '@sanity/ui'
-import {useCallback} from 'react'
-import {useDocumentPane} from 'sanity/structure'
-
-import {aiInspectorId} from '../../../assistInspector/constants'
-import {instructionParam} from '../../../types'
-
-export function BackToInstructionListLink() {
-  const {openInspector} = useDocumentPane()
-
-  const goBack = useCallback(
-    () => openInspector(aiInspectorId, {[instructionParam]: undefined as any}),
-    [openInspector],
-  )
-
-  return (
-    <div>
-      <Button
-        as="a"
-        fontSize={1}
-        icon={ArrowLeftIcon}
-        mode="bleed"
-        padding={1}
-        space={2}
-        onClick={goBack}
-        text="  Instructions"
-        textAlign="left"
-      />
-    </div>
-  )
-}