@sanity/assist 1.2.14 → 1.2.15-lang.10

package/src/plugin.tsx

@@ -15,12 +15,11 @@ import {createAssistDocumentPresence} from './presence/AssistDocumentPresence'
 import {isSchemaAssistEnabled} from './helpers/assistSupported'
 import {isImage} from './helpers/typeUtils'
 import {ImageContextProvider} from './components/ImageContext'
+import {TranslationConfig} from './translate/types'
+import {assistDocumentTypeName} from './types'
 
 export interface AssistPluginConfig {
-  /**
-   * Set this to false to disable model migration from the alpha version of this plugin
-   */
-  alphaMigration?: boolean
+  translate?: TranslationConfig
 
   /**
    * @internal
@@ -36,16 +35,23 @@ export const assist = definePlugin<AssistPluginConfig | void>((config) => {
     schema: {
       types: schemaTypes,
     },
+    i18n: {
+      bundles: [{}],
+    },
 
     document: {
       inspectors: (prev, context) => {
-        const docSchema = context.schema.get(context.documentType)
+        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]
@@ -53,6 +59,9 @@ export const assist = definePlugin<AssistPluginConfig | void>((config) => {
         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, docSchema)]

package/src/presence/AssistAvatar.tsx

@@ -88,7 +88,7 @@ export function AssistAvatar(props: {state?: 'present' | 'active'}) {
       </Outline>
       <IconDisc>
         <Text as="span" size={0} style={{color: 'inherit'}}>
-          <SparklesIcon />
+          <SparklesIcon style={{color: 'inherit'}} />
         </Text>
       </IconDisc>
     </Root>

package/src/schemas/assistDocumentSchema.tsx

@@ -18,6 +18,8 @@ import {
   instructionContextTypeName,
   instructionTaskTypeName,
   instructionTypeName,
+  outputFieldTypeName,
+  outputTypeTypeName,
   promptTypeName,
   userInputTypeName,
 } from '../types'
@@ -37,11 +39,13 @@ import {PromptInput} from '../assistDocument/components/instruction/PromptInput'
 import {instructionGuideUrl} from '../constants'
 import {InstructionsArrayField} from '../assistDocument/components/InstructionsArrayField'
 import {getFieldRefsWithDocument} from '../assistInspector/helpers'
+import {InstructionOutputField} from '../assistDocument/components/instruction/InstructionOutputField'
+import {InstructionOutputInput} from '../assistDocument/components/instruction/InstructionOutputInput'
 
 export const fieldReference = defineType({
   type: 'object',
   name: fieldReferenceTypeName,
-  title: 'Document field',
+  title: 'Field',
   icon: ThListIcon,
 
   fields: [
@@ -329,6 +333,41 @@ export const instruction = defineType({
         return context.currentUser?.id ?? ''
       },
     }),
+    defineField({
+      type: 'array',
+      name: 'output',
+      title: 'Output filter',
+      components: {
+        input: InstructionOutputInput,
+        field: InstructionOutputField,
+      },
+      of: [
+        defineArrayMember({
+          type: 'object' as const,
+          name: outputFieldTypeName,
+          title: 'Output field',
+          fields: [
+            {
+              type: 'string',
+              name: 'path',
+              title: 'Path',
+            },
+          ],
+        }),
+        defineArrayMember({
+          type: 'object' as const,
+          name: outputTypeTypeName,
+          title: 'Output type',
+          fields: [
+            {
+              type: 'string',
+              name: 'type',
+              title: 'Type',
+            },
+          ],
+        }),
+      ],
+    }),
   ],
 })
 

package/src/schemas/serialize/serializeSchema.test.ts

@@ -32,7 +32,7 @@ describe('serializeSchema', () => {
           name: 'article',
           fields: [{type: 'string', name: 'title'}],
           options: {
-            aiWritingAssistance: {
+            aiAssist: {
               exclude: true,
             },
           },
@@ -123,7 +123,7 @@ describe('serializeSchema', () => {
   })
 
   test('should not serialize excluded fields or types or types with every member excluded', () => {
-    const options: AssistOptions = {aiWritingAssistance: {exclude: true}}
+    const options: AssistOptions = {aiAssist: {exclude: true}}
 
     const schema = Schema.compile({
       name: 'test',
@@ -138,14 +138,14 @@ describe('serializeSchema', () => {
               name: 'excludedObject',
               // all fields excluded should exclude field
               fields: [{type: 'string', name: 'title', options}],
-              options: {aiWritingAssistance: {exclude: true}},
+              options: {aiAssist: {exclude: true}},
             }),
             defineField({
               type: 'array',
               name: 'excludedArray',
               // all items excluded should exclude field
               of: [{type: 'object', name: 'remove', options}, {type: 'excluded'}],
-              options: {aiWritingAssistance: {exclude: true}},
+              options: {aiAssist: {exclude: true}},
             }),
             //image without extra fields should be excluded
             defineField({type: 'image', name: 'image'}),
@@ -169,7 +169,7 @@ describe('serializeSchema', () => {
           type: 'object',
           name: 'excluded',
           fields: [{type: 'string', name: 'title', options}],
-          options: {aiWritingAssistance: {exclude: true}},
+          options: {aiAssist: {exclude: true}},
         }),
         ...mockStudioTypes,
       ],
@@ -484,7 +484,7 @@ describe('serializeSchema', () => {
     ])
   })
 
-  test('should exclude truthy hidden and readonly', () => {
+  test('should annotate truthy readonly', () => {
     const schema = Schema.compile({
       name: 'test',
       types: [
@@ -492,7 +492,7 @@ describe('serializeSchema', () => {
           type: 'document',
           name: 'article',
           fields: [
-            {type: 'string', name: 'title', hidden: () => true},
+            {type: 'string', name: 'title', readOnly: () => true},
             {type: 'some', name: 'some'},
           ],
         },
@@ -507,6 +507,237 @@ describe('serializeSchema', () => {
 
     const serializedTypes = serializeSchema(schema, {leanFormat: true})
 
-    expect(serializedTypes).toEqual([])
+    expect(serializedTypes).toEqual([
+      {
+        name: 'article',
+        title: 'Article',
+        type: 'document',
+        fields: [
+          {name: 'title', readOnly: 'function', title: 'Title', type: 'string'},
+          {name: 'some', readOnly: true, title: 'Some', type: 'some'},
+        ],
+      },
+      {
+        name: 'some',
+        readOnly: true,
+        title: 'Some',
+        type: 'object',
+        fields: [{name: 'title', title: 'Title', type: 'string'}],
+      },
+    ])
+  })
+
+  test('should annotate truthy hidden', () => {
+    const schema = Schema.compile({
+      name: 'test',
+      types: [
+        {
+          type: 'document',
+          name: 'article',
+          fields: [
+            {type: 'string', name: 'title', hidden: true},
+            {type: 'some', name: 'some'},
+          ],
+        },
+        defineType({
+          type: 'object',
+          name: 'some',
+          hidden: () => true,
+          fields: [{type: 'string', name: 'title'}],
+        }),
+      ],
+    })
+
+    const serializedTypes = serializeSchema(schema, {leanFormat: true})
+
+    expect(serializedTypes).toEqual([
+      {
+        name: 'article',
+        title: 'Article',
+        type: 'document',
+        fields: [
+          {hidden: true, name: 'title', title: 'Title', type: 'string'},
+          {hidden: 'function', name: 'some', title: 'Some', type: 'some'},
+        ],
+      },
+      {
+        hidden: 'function',
+        name: 'some',
+        title: 'Some',
+        type: 'object',
+        fields: [{name: 'title', title: 'Title', type: 'string'}],
+      },
+    ])
+  })
+
+  test('should serialize annotations', () => {
+    const schema = Schema.compile({
+      name: 'test',
+      types: [
+        defineType({
+          type: 'object',
+          name: 'annotation',
+          fields: [defineField({type: 'string', name: 'fact', title: 'Fact'})],
+        }),
+        defineType({
+          name: 'blockAlias',
+          type: 'block',
+          marks: {annotations: [{type: 'annotation'}]},
+        }),
+        defineType({
+          type: 'document',
+          name: 'article',
+          fields: [
+            {
+              type: 'array',
+              name: 'inlinePte',
+              of: [
+                defineArrayMember({
+                  type: 'block',
+                  marks: {
+                    annotations: [
+                      defineArrayMember({
+                        type: 'object',
+                        name: 'inline-annotation',
+                        fields: [defineField({type: 'string', name: 'fact', title: 'Fact'})],
+                      }),
+                    ],
+                  },
+                }),
+              ],
+            },
+            {type: 'array', name: 'pte', of: [{type: 'blockAlias'}]},
+          ],
+        }),
+      ],
+    })
+
+    const serializedTypes = serializeSchema(schema, {leanFormat: true})
+
+    expect(serializedTypes).toEqual([
+      {
+        name: 'annotation',
+        title: 'Annotation',
+        type: 'object',
+        fields: [{name: 'fact', title: 'Fact', type: 'string'}],
+      },
+      {
+        name: 'article',
+        title: 'Article',
+        type: 'document',
+        fields: [
+          {
+            name: 'inlinePte',
+            title: 'Inline Pte',
+            type: 'array',
+            of: [
+              {
+                name: 'block',
+                title: 'Block',
+                type: 'block',
+                inlineOf: [],
+                annotations: [
+                  {
+                    name: 'inline-annotation',
+                    title: 'Inline Annotation',
+                    type: 'object',
+                    fields: [{name: 'fact', title: 'Fact', type: 'string'}],
+                  },
+                ],
+              },
+            ],
+          },
+          {
+            name: 'pte',
+            of: [{name: 'blockAlias', title: 'Block', type: 'blockAlias'}],
+            title: 'Pte',
+            type: 'array',
+          },
+        ],
+      },
+      {
+        name: 'blockAlias',
+        title: 'Block',
+        type: 'block',
+        annotations: [{name: 'annotation', title: 'Annotation', type: 'annotation'}],
+        inlineOf: [],
+      },
+    ])
+  })
+
+  test('should serialize inline block types', () => {
+    const schema = Schema.compile({
+      name: 'test',
+      types: [
+        defineType({
+          type: 'object',
+          name: 'inline-block',
+          fields: [
+            defineField({type: 'string', name: 'fact', title: 'Fact'}),
+            defineField({type: 'blockAlias', name: 'recurse', title: 'Recursive'}),
+          ],
+        }),
+        defineType({
+          name: 'blockAlias',
+          type: 'block',
+          of: [{type: 'inline-block'}],
+        }),
+        defineType({
+          type: 'document',
+          name: 'article',
+          fields: [{type: 'array', name: 'pte', of: [{type: 'blockAlias'}]}],
+        }),
+      ],
+    })
+
+    const serializedTypes = serializeSchema(schema, {leanFormat: true})
+
+    expect(serializedTypes).toEqual([
+      {
+        name: 'article',
+        title: 'Article',
+        type: 'document',
+        fields: [
+          {
+            name: 'pte',
+            of: [
+              {
+                name: 'blockAlias',
+                title: 'Block',
+                type: 'blockAlias',
+              },
+            ],
+            title: 'Pte',
+            type: 'array',
+          },
+        ],
+      },
+      {
+        name: 'blockAlias',
+        title: 'Block',
+        type: 'block',
+        annotations: [],
+        inlineOf: [
+          {
+            name: 'inline-block',
+            title: 'Inline Block',
+            type: 'inline-block',
+          },
+        ],
+      },
+      {
+        name: 'inline-block',
+        title: 'Inline Block',
+        type: 'object',
+        fields: [
+          {name: 'fact', title: 'Fact', type: 'string'},
+          {
+            name: 'recurse',
+            title: 'Recursive',
+            type: 'blockAlias',
+          },
+        ],
+      },
+    ])
   })
 })

package/src/schemas/serialize/serializeSchema.ts

@@ -1,21 +1,24 @@
 import {
   ArraySchemaType,
   ImageOptions,
+  isArraySchemaType,
   ObjectSchemaType,
+  ReferenceOptions,
   ReferenceSchemaType,
   Schema,
   SchemaType,
   typed,
 } from 'sanity'
 import {
+  assistSchemaIdPrefix,
   assistSerializedFieldTypeName,
   assistSerializedTypeName,
   SerializedSchemaMember,
   SerializedSchemaType,
-  assistSchemaIdPrefix,
 } from '../../types'
 import {hiddenTypes} from './schemaUtils'
 import {isAssistSupported} from '../../helpers/assistSupported'
+import {isType} from '../../helpers/typeUtils'
 
 interface Options {
   leanFormat?: boolean
@@ -31,7 +34,6 @@ export function serializeSchema(schema: Schema, options?: Options): SerializedSc
     .filter((t): t is SchemaType => !!t)
     // because a field can override exclude at the type level, we have to also serialize excluded types
     // so don't do this: .filter((t) => isAssistSupported(t))
-    .filter((t) => !t.hidden && !t.readOnly)
     .map((t) => getSchemaStub(t, schema, options))
     .filter((t) => {
       if ('to' in t && t.to && !t.to.length) {
@@ -78,13 +80,12 @@ function getBaseFields(
   typeName: string,
   options: Options | undefined
 ) {
-  const imagePromptField = (type.options as ImageOptions)?.imagePromptField
+  const schemaOptions: SerializedSchemaType['options'] = removeUndef({
+    imagePromptField: (type.options as ImageOptions)?.aiAssist?.imageInstructionField,
+    embeddingsIndex: (type.options as ReferenceOptions)?.aiAssist?.embeddingsIndex,
+  })
   return removeUndef({
-    options: imagePromptField
-      ? {
-          imagePromptField: imagePromptField,
-        }
-      : undefined,
+    options: Object.keys(schemaOptions).length ? schemaOptions : undefined,
     values: Array.isArray(type?.options?.list)
       ? type?.options?.list.map((v: string | {value: string; title: string}) =>
           typeof v === 'string' ? v : v.value ?? `${v.title}`
@@ -99,6 +100,22 @@ function getBaseFields(
       'fields' in type && inlineTypes.includes(typeName)
         ? serializeFields(schema, type, options)
         : undefined,
+    annotations:
+      typeName === 'block' && 'fields' in type
+        ? serializeAnnotations(type, schema, options)
+        : undefined,
+    inlineOf:
+      typeName === 'block' && 'fields' in type
+        ? serializeInlineOf(type, schema, options)
+        : undefined,
+    hidden:
+      typeof type.hidden === 'function' ? ('function' as const) : type.hidden ? true : undefined,
+    readOnly:
+      typeof type.readOnly === 'function'
+        ? ('function' as const)
+        : type.readOnly
+        ? true
+        : undefined,
   })
 }
 
@@ -107,10 +124,27 @@ function serializeFields(
   schemaType: ObjectSchemaType,
   options: Options | undefined
 ) {
-  return schemaType.fields
+  const fields = schemaType.fieldsets
+    ? schemaType.fieldsets.flatMap((fs) =>
+        fs.single
+          ? fs.field
+          : fs.fields.map((f) => ({
+              ...f,
+              type: {
+                ...f.type,
+                // if fieldset is (conditionally) hidden, the field must be considered the same way
+                // ie, if the field does not show up in conditionalMembers, it is hidden
+                // regardless of weather or not it is the field function or the fieldset function that hides it
+                hidden:
+                  typeof fs.hidden === 'function' ? fs.hidden : fs.hidden ? true : f.type.hidden,
+              },
+            }))
+      )
+    : schemaType.fields
+
+  return fields
     .filter((f) => !['sanity.imageHotspot', 'sanity.imageCrop'].includes(f.type?.name ?? ''))
     .filter((f) => isAssistSupported(f.type))
-    .filter((f) => !f.type.hidden && !f.type.readOnly)
     .map((field) => serializeMember(schema, field.type, field.name, options))
 }
 
@@ -131,6 +165,39 @@ function serializeMember(
   })
 }
 
+function serializeInlineOf(
+  blockSchemaType: ObjectSchemaType,
+  schema: Schema,
+  options: Options | undefined
+): SerializedSchemaMember[] | undefined {
+  const childrenField = blockSchemaType.fields.find((f) => f.name === 'children')
+  const childrenType = childrenField?.type
+  if (!childrenType || !isArraySchemaType(childrenType)) {
+    return undefined
+  }
+  return arrayOf(
+    {
+      ...childrenType,
+      of: childrenType.of.filter((t) => !isType(t, 'span')),
+    },
+    schema,
+    options
+  )
+}
+
+function serializeAnnotations(
+  blockSchemaType: ObjectSchemaType,
+  schema: Schema,
+  options: Options | undefined
+): SerializedSchemaMember[] | undefined {
+  const markDefs = blockSchemaType.fields.find((f) => f.name === 'markDefs')
+  const marksType = markDefs?.type
+  if (!marksType || !isArraySchemaType(marksType)) {
+    return undefined
+  }
+  return arrayOf(marksType, schema, options)
+}
+
 function arrayOf(
   arrayType: ArraySchemaType,
   schema: Schema,

package/src/schemas/typeDefExtensions.ts

@@ -1,8 +1,14 @@
 /* eslint-disable no-unused-vars */
 export interface AssistOptions {
-  aiWritingAssistance?: {
+  aiAssist?: {
     /** Set to true to disable assistance for this field or type */
     exclude?: boolean
+
+    /**
+     * Set to true to add translation field-action to the field.
+     * Only has an effect in document types configured for document or field level translations.
+     */
+    translateAction?: boolean
   }
 }
 
@@ -16,13 +22,91 @@ declare module 'sanity' {
   interface DocumentOptions extends AssistOptions {}
   interface FileOptions extends AssistOptions {}
   interface GeopointOptions extends AssistOptions {}
-  interface ImageOptions extends AssistOptions {
-    imagePromptField?: string
-    captionField?: string
+  interface ImageOptions {
+    aiAssist?: AssistOptions['aiAssist'] & {
+      /**
+       * When set, an image will be created whenever the `imageInstructionField` is written to by
+       * an AI Assist instruction.
+       *
+       * The value output by AI Assist will be use as an image prompt for an generative image AI.
+       *
+       * This means that instructions directly for the field or instructions that visit the field when running,
+       * will result in the image being changed.
+       *
+       * `imageInstructionField` must be a child-path relative to the image field, ie:
+       * * field
+       * * path.to.field
+       *
+       * ### Example
+       * ```ts
+       * defineType({
+       *   type: 'image',
+       *   name: 'articleImage',
+       *   fields: [
+       *     defineField({
+       *       type: 'text',
+       *       name: 'imagePrompt',
+       *       title: 'Image prompt',
+       *       rows: 2,
+       *     }),
+       *   ],
+       *   options: {
+       *      aiAssist: {
+       *        imageInstructionField: 'imagePrompt',
+       *     }
+       *   },
+       * })
+       * ```
+       */
+      imageInstructionField?: string
+
+      /**
+       * When set, an image description will be automatically created for the image.
+       *
+       * `imageDescriptionField` must be a child-path relative to the image field, ie:
+       * * field
+       * * path.to.field
+       *
+       * Whenever the image asset for the field is changed in the Studio,
+       * an image description is generated and set into the `imageDescriptionField`.
+       *
+       * ### Example
+       * ```ts
+       * defineType({
+       *   type: 'image',
+       *   name: 'articleImage',
+       *   fields: [
+       *     defineField({
+       *       type: 'string',
+       *       name: 'altText',
+       *       title: 'Alt text',
+       *     }),
+       *   ],
+       *   options: {
+       *      aiAssist: {
+       *        imageDescriptionField: 'altText',
+       *     }
+       *   },
+       * })
+       * ```
+       */
+      imageDescriptionField?: string
+    }
   }
   interface NumberOptions extends AssistOptions {}
   interface ObjectOptions extends AssistOptions {}
-  interface ReferenceBaseOptions extends AssistOptions {}
+  interface ReferenceBaseOptions {
+    aiAssist?: {
+      /** Set to true to disable assistance for this field or type */
+      exclude?: boolean
+
+      /**
+       * When set, the reference field will allow instructions to be added to it.
+       * Should be the name of the embeddings-index where assist will look for contextually relevant documents
+       * */
+      embeddingsIndex?: string
+    }
+  }
   interface SlugOptions extends AssistOptions {}
   interface StringOptions extends AssistOptions {}
   interface TextOptions extends AssistOptions {}