@sanity/assist 5.0.4 → 6.0.0

package/src/helpers/conditionalMembers.ts

@@ -1,134 +0,0 @@
-/* eslint-disable max-depth */
-import {
-  type ArrayOfObjectsFormNode,
-  type ArrayOfObjectsItemMember,
-  type ArrayOfPrimitivesFormNode,
-  type DocumentFormNode,
-  type FieldsetState,
-  isObjectSchemaType,
-  type ObjectFormNode,
-  type Path,
-  pathToString,
-  type SchemaType,
-} from 'sanity'
-
-const DEFAULT_MAX_DEPTH = 8
-const ABSOLUTE_MAX_DEPTH = 50
-
-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,
-  maxDepth = DEFAULT_MAX_DEPTH,
-): ConditionalMemberState[] {
-  const doc: ConditionalMemberInnerState = {
-    path: '',
-    hidden: false,
-    readOnly: !!docState.readOnly,
-    conditional: isConditional(docState.schemaType),
-  }
-  return (
-    [doc, ...extractConditionalPaths(docState, Math.min(maxDepth, ABSOLUTE_MAX_DEPTH))]
-      .filter((v) => v.conditional)
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      .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, // Use actual form state readOnly value
-    hidden: false, // If it's in form state members, it's 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/ids.test.ts

@@ -1,28 +0,0 @@
-import {describe, expect, test} from 'vitest'
-
-import {assistDocumentId, assistTasksStatusId} from './ids'
-
-describe('ids', () => {
-  test('assistDocumentId should replace illegal id chars with _', () => {
-    const testCases = [
-      {schemaType: 'test', assistId: 'sanity.assist.schemaType.test'},
-      {schemaType: 'test-type', assistId: 'sanity.assist.schemaType.test-type'},
-      {schemaType: 'test/type', assistId: 'sanity.assist.schemaType.test_type'},
-      {schemaType: '%broken©™£€∞', assistId: 'sanity.assist.schemaType._broken_____'},
-    ]
-    const outputs = testCases.map((testCase) => assistDocumentId(testCase.schemaType))
-    const expected = testCases.map((testCase) => testCase.assistId)
-    expect(outputs).toEqual(expected)
-  })
-
-  test.each([
-    {documentId: 'foo', assistId: 'sanity.assist.status.foo'},
-    {documentId: 'drafts.foo', assistId: 'sanity.assist.status.foo'},
-    {documentId: 'versions.r12332.foo', assistId: 'sanity.assist.status.r12332.foo'},
-  ])(
-    "assistTasksStatusId should return the documentId with 'sanity.assist.status' prefix for $documentId",
-    ({documentId, assistId}) => {
-      expect(assistTasksStatusId(documentId)).toEqual(assistId)
-    },
-  )
-})

package/src/helpers/ids.ts

@@ -1,23 +0,0 @@
-import {getPublishedId, getVersionFromId, isVersionId} from 'sanity'
-
-import {assistDocumentIdPrefix, assistDocumentStatusIdPrefix} from '../types'
-
-const illegalIdChars = /[^a-zA-Z0-9._-]/g
-
-export function publicId(id: string) {
-  return id.replace('drafts.', '')
-}
-
-export function assistDocumentId(documentType: string) {
-  return `${assistDocumentIdPrefix}${documentType}`.replace(illegalIdChars, '_')
-}
-
-export function assistTasksStatusId(documentId: string) {
-  if (isVersionId(documentId)) {
-    // Creates an id: sanity.assist.status.<versionName>.<documentId>
-    return `${assistDocumentStatusIdPrefix}${getVersionFromId(documentId)}.${getPublishedId(documentId)}`
-  }
-
-  // Creates an id: sanity.assist.status<documentId>
-  return `${assistDocumentStatusIdPrefix}${getPublishedId(documentId)}`
-}

package/src/helpers/misc.ts

@@ -1,25 +0,0 @@
-import {useMemo} from 'react'
-import {Path, pathToString} from 'sanity'
-
-import {documentRootKey, StudioInstruction} from '../types'
-
-export function usePathKey(path: Path | string) {
-  return useMemo(() => {
-    return getPathKey(path)
-  }, [path])
-}
-
-export function getPathKey(path: Path | string) {
-  if (path.length) {
-    return Array.isArray(path) ? pathToString(path) : path
-  }
-  return documentRootKey
-}
-
-export function getInstructionTitle(instruction?: StudioInstruction) {
-  return instruction?.title ?? 'Untitled'
-}
-
-export function isDefined<T>(t: T | undefined | null): t is T {
-  return t !== undefined && t !== null
-}

package/src/helpers/styleguide.ts

@@ -1,24 +0,0 @@
-import {packageName} from '../constants'
-import {TranslateStyleguide, TranslateStyleguideContext} from '../translate/types'
-
-export function validateStyleguide(styleguide: string | undefined) {
-  if (styleguide && styleguide.length > 2000) {
-    throw new Error(
-      `[${packageName}]: \`translate.styleguide\` value is too long. It must be 2000 characters or less, but was ${styleguide.length} characters`,
-    )
-  }
-  return styleguide
-}
-
-export function createStyleGuideResolver(
-  styleguide: TranslateStyleguide | undefined,
-  context: TranslateStyleguideContext,
-) {
-  return async () => {
-    if (typeof styleguide !== 'function') {
-      return styleguide
-    }
-    const styleguideResult = await styleguide(context)
-    return validateStyleguide(styleguideResult)
-  }
-}

package/src/helpers/typeUtils.ts

@@ -1,60 +0,0 @@
-import {ArraySchemaType, ImageOptions, SchemaType} from 'sanity'
-
-export function isPortableTextArray(type: ArraySchemaType) {
-  return type.of.find((t) => isType(t, 'block'))
-}
-
-/**
- * Returns true if the `schemaType` or any of its parent types (`schemaType.type`)` has `name` equal
- * to `typeName`.
- *
- * Useful for checking if `schemaType` is a type alias of `ìmage`, `code` or similar.
- */
-export function isType(schemaType: SchemaType, typeName: string): boolean {
-  if (schemaType.name === typeName) {
-    return true
-  }
-  if (!schemaType.type) {
-    return false
-  }
-  return isType(schemaType.type, typeName)
-}
-
-export function isImage(schemaType: SchemaType) {
-  return isType(schemaType, 'image')
-}
-
-export function getDescriptionFieldOption(
-  schemaType: SchemaType | undefined,
-): {path: string; updateOnImageChange: boolean} | undefined {
-  if (!schemaType) {
-    return undefined
-  }
-  const descriptionField = (schemaType.options as ImageOptions)?.aiAssist?.imageDescriptionField
-  if (typeof descriptionField === 'string') {
-    return {
-      path: descriptionField,
-      updateOnImageChange: true,
-    }
-  } else if (descriptionField) {
-    return {
-      path: descriptionField.path,
-      updateOnImageChange: descriptionField.updateOnImageChange ?? true,
-    }
-  }
-  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/helpers/useAssistSupported.ts

@@ -1,8 +0,0 @@
-import {useMemo} from 'react'
-import {Path, SchemaType} from 'sanity'
-
-import {isAssistSupported} from './assistSupported'
-
-export function useAssistSupported(path: Path, schemaType: SchemaType) {
-  return useMemo(() => isAssistSupported(schemaType), [schemaType])
-}

package/src/index.ts

@@ -1,26 +0,0 @@
-export {assist} from './plugin'
-export * from './schemas/serialize/SchemTypeTool'
-export * from './schemas/typeDefExtensions'
-export {defaultLanguageOutputs} from './translate/paths'
-export * from './translate/types'
-export {contextDocumentTypeName} from './types'
-export * from './assistTypes'
-
-export {
-  type AssistFieldActionProps,
-  type AssistFieldActionGroup,
-  type AssistFieldActionItem,
-  type AssistFieldActionNode,
-  defineAssistFieldAction,
-  defineFieldActionDivider,
-  defineAssistFieldActionGroup,
-} from './fieldActions/customFieldActions'
-
-export {
-  type GetUserInput,
-  type CustomInput,
-  type CustomInputResult,
-  useUserInput,
-} from './fieldActions/useUserInput'
-
-export {isType} from './helpers/typeUtils'

package/src/onboarding/FirstAssistedPathProvider.tsx

@@ -1,30 +0,0 @@
-import {createContext, PropsWithChildren, useMemo} from 'react'
-import {FieldMember, ObjectInputProps, pathToString} from 'sanity'
-
-import {isAssistSupported} from '../helpers/assistSupported'
-
-export const FirstAssistedPathContext = createContext<string | undefined>(undefined)
-
-export interface FirstAssistedPathProviderProps {
-  members: ObjectInputProps['members']
-}
-
-export function FirstAssistedPathProvider(
-  props: PropsWithChildren<FirstAssistedPathProviderProps>,
-) {
-  const {members} = props
-
-  const firstAssistedPath = useMemo(() => {
-    const firstAssisted = members.find(
-      (member): member is FieldMember =>
-        member.kind === 'field' && isAssistSupported(member.field.schemaType),
-    )
-    return firstAssisted?.field.path ? pathToString(firstAssisted?.field.path) : undefined
-  }, [members])
-
-  return (
-    <FirstAssistedPathContext.Provider value={firstAssistedPath}>
-      {props.children}
-    </FirstAssistedPathContext.Provider>
-  )
-}

package/src/onboarding/InspectorOnboarding.tsx

@@ -1,47 +0,0 @@
-import {SparklesIcon} from '@sanity/icons'
-import {Box, Button, Container, Flex, Stack, Text} from '@sanity/ui'
-import {styled} from 'styled-components'
-
-import {releaseAnnouncementUrl} from '../constants'
-
-const SparklesIllustration = styled(SparklesIcon)({
-  fontSize: '3.125em',
-  '& path': {
-    strokeWidth: `0.6px !important`,
-  },
-})
-
-export function InspectorOnboarding(props: {onDismiss: () => void}) {
-  const {onDismiss} = props
-  return (
-    <Box padding={4}>
-      <Container width={0}>
-        <Stack space={4}>
-          <div style={{textAlign: 'center'}}>
-            <SparklesIllustration />
-          </div>
-          <Text align="center" size={1}>
-            Create reusable AI instructions that can be applied across all documents of a certain
-            type.
-          </Text>
-
-          <Flex align="center" gap={2} justify="center">
-            <Button
-              as="a"
-              href={releaseAnnouncementUrl}
-              rel="noreferrer"
-              target="_blank"
-              fontSize={1}
-              mode="default"
-              onClick={onDismiss}
-              padding={2}
-              text="Learn more"
-              tone="primary"
-            />
-            <Button fontSize={1} mode="bleed" onClick={onDismiss} padding={2} text="Dismiss" />
-          </Flex>
-        </Stack>
-      </Container>
-    </Box>
-  )
-}

package/src/onboarding/onboardingStore.ts

@@ -1,32 +0,0 @@
-import {useCallback, useState} from 'react'
-
-export const inspectorOnboardingKey = 'sanityStudio:assist:inspector:onboarding:dismissed'
-
-export function isFeatureOnboardingDismissed(featureKey: string): boolean {
-  if (typeof localStorage === 'undefined') {
-    return false
-  }
-
-  const value = localStorage.getItem(featureKey)
-  return value === 'true'
-}
-
-export function dismissFeatureOnboarding(featureKey: string) {
-  if (typeof localStorage === 'undefined') {
-    return
-  }
-
-  localStorage.setItem(featureKey, 'true')
-}
-
-export function useOnboardingFeature(featureKey: string) {
-  const [showOnboarding, setShowOnboarding] = useState(
-    () => !isFeatureOnboardingDismissed(featureKey),
-  )
-  const dismissOnboarding = useCallback(() => {
-    setShowOnboarding(false)
-    dismissFeatureOnboarding(featureKey)
-  }, [setShowOnboarding, featureKey])
-
-  return {showOnboarding, dismissOnboarding}
-}

package/src/plugin.tsx

@@ -1,162 +0,0 @@
-import type {SanityClient} from '@sanity/client'
-import {definePlugin, isObjectSchemaType} from 'sanity'
-
-import {AssistDocumentInputWrapper} from './assistDocument/AssistDocumentInput'
-import {AssistDocumentLayout} from './assistDocument/AssistDocumentLayout'
-import {AssistFieldWrapper} from './assistFormComponents/AssistField'
-import {AssistFormBlock} from './assistFormComponents/AssistFormBlock'
-import {AssistInlineFormBlock} from './assistFormComponents/AssistInlineFormBlock'
-import {AssistItem} from './assistFormComponents/AssistItem'
-import {assistInspector} from './assistInspector'
-import {AssistLayout} from './assistLayout/AssistLayout'
-import {AssistConfig} from './assistTypes'
-import {ImageContextProvider} from './components/ImageContext'
-import {SafeValueInput} from './components/SafeValueInput'
-import {packageName} from './constants'
-import {assistFieldActions} from './fieldActions/assistFieldActions'
-import {isSchemaAssistEnabled} from './helpers/assistSupported'
-import {validateStyleguide} from './helpers/styleguide'
-import {isImage} from './helpers/typeUtils'
-import {createAssistDocumentPresence} from './presence/AssistDocumentPresence'
-import {schemaTypes} from './schemas'
-import {TranslationConfig} from './translate/types'
-import {assistDocumentTypeName, AssistPreset} from './types'
-import {AssistFieldActionNode, AssistFieldActionProps} from './fieldActions/customFieldActions'
-
-export interface AssistPluginConfig {
-  translate?: TranslationConfig
-
-  /**
-   * Config that affects all instructions
-   */
-  assist?: AssistConfig
-
-  fieldActions?: {
-    title?: string
-    /**
-     * The returned array can include `undefined` entries in the action array. These will be filtered out.
-     */
-    useFieldActions?: (props: AssistFieldActionProps) => (AssistFieldActionNode | undefined)[]
-  }
-
-  /**
-   * @internal
-   */
-  __customApiClient?: (defaultClient: SanityClient) => SanityClient
-
-  /**
-   * @internal
-   */
-  __presets?: Record<string, AssistPreset>
-}
-
-export const assist = definePlugin<AssistPluginConfig | void>((config) => {
-  const configWithDefaults = config ?? {}
-  const styleguide = configWithDefaults.translate?.styleguide || ''
-  const maxPathDepth = configWithDefaults.assist?.maxPathDepth
-  const temperature = configWithDefaults.assist?.temperature
-
-  if (typeof styleguide === 'string') {
-    validateStyleguide(styleguide)
-  }
-
-  if (maxPathDepth !== undefined && (maxPathDepth < 1 || maxPathDepth > 12)) {
-    throw new Error(
-      `[${packageName}]: \`assist.maxPathDepth\` must be be in the range [1,12] inclusive, but was ${maxPathDepth}`,
-    )
-  }
-
-  if (temperature !== undefined && (temperature < 0 || temperature > 1)) {
-    throw new Error(
-      `[${packageName}]: \`assist.maxPathDepth\` must be be in the range [0,1] inclusive, but was ${temperature}`,
-    )
-  }
-
-  return {
-    name: packageName,
-    // the addition of global references broke auto updating studios
-    // new versions of studio know to look for this prop on assist plugin, and filter + console.warn if it is missing
-    ...({handlesGDR: true} as any),
-    schema: {
-      types: schemaTypes,
-    },
-    i18n: {
-      bundles: [{}],
-    },
-
-    document: {
-      inspectors: (prev, context) => {
-        const documentType = context.documentType
-        const docSchema = context.schema.get(documentType)
-        if (docSchema && isSchemaAssistEnabled(docSchema)) {
-          return [...prev, assistInspector]
-        }
-        return prev
-      },
-      unstable_fieldActions: (prev, {documentType, schema}) => {
-        if (documentType === assistDocumentTypeName) {
-          return []
-        }
-        const docSchema = schema.get(documentType)
-        if (docSchema && isSchemaAssistEnabled(docSchema)) {
-          return [...prev, assistFieldActions]
-        }
-        return prev
-      },
-      unstable_languageFilter: (prev, {documentId, schema, schemaType}) => {
-        if (schemaType === assistDocumentTypeName) {
-          return []
-        }
-        const docSchema = schema.get(schemaType)
-        if (docSchema && isObjectSchemaType(docSchema) && isSchemaAssistEnabled(docSchema)) {
-          return [...prev, createAssistDocumentPresence(documentId)]
-        }
-        return prev
-      },
-      components: {
-        unstable_layout: AssistDocumentLayout,
-      },
-    },
-
-    studio: {
-      components: {
-        layout: function Layout(props) {
-          return <AssistLayout {...props} config={configWithDefaults} />
-        },
-      },
-    },
-
-    form: {
-      components: {
-        input: AssistDocumentInputWrapper,
-        field: AssistFieldWrapper,
-        item: AssistItem,
-        block: AssistFormBlock,
-        inlineBlock: AssistInlineFormBlock,
-      },
-    },
-
-    plugins: [
-      definePlugin({
-        name: `${packageName}/safe-value-input`,
-        form: {components: {input: SafeValueInput}},
-      })(),
-
-      definePlugin({
-        name: `${packageName}/generate-caption`,
-        form: {
-          components: {
-            input: (props) => {
-              const {schemaType} = props
-
-              if (isImage(schemaType)) {
-                return <ImageContextProvider {...props} />
-              }
-              return props.renderDefault(props)
-            },
-          },
-        },
-      })(),
-    ],
-  }
-})

package/src/presence/AiFieldPresence.tsx

@@ -1,28 +0,0 @@
-// eslint-disable-next-line react/no-unused-prop-types
-import {Card, Flex, Text, Tooltip} from '@sanity/ui'
-import type {FormNodePresence} from 'sanity'
-
-import {FadeInContent} from '../components/FadeInContent'
-import {AssistAvatar} from './AssistAvatar'
-
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export function AiFieldPresence(props: {presence: FormNodePresence}) {
-  return (
-    <Card style={{position: 'relative', background: 'transparent'}} contentEditable={false}>
-      <Tooltip
-        placement="left"
-        content={
-          <Card padding={3} border>
-            <Flex align="center">
-              <Text size={1}>Running instruction...</Text>
-            </Flex>
-          </Card>
-        }
-      >
-        <FadeInContent durationMs={300}>
-          <AssistAvatar state="active" />
-        </FadeInContent>
-      </Tooltip>
-    </Card>
-  )
-}