@sanity/assist 1.2.6 → 1.2.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/assist",
-  "version": "1.2.6",
+  "version": "1.2.8",
   "description": "",
   "keywords": [
     "sanity",

package/src/fieldActions/assistFieldActions.tsx

@@ -23,6 +23,7 @@ import {PrivateIcon} from './PrivateIcon'
 import {generateCaptionsActions} from './generateCaptionActions'
 import {useDocumentPane} from 'sanity/desk'
 import {useSelectedField, useTypePath} from '../assistInspector/helpers'
+import {isSchemaAssistEnabled} from '../helpers/assistSupported'
 
 function node(node: DocumentFieldActionItem | DocumentFieldActionGroup) {
   return node
@@ -69,7 +70,10 @@ export const assistFieldActions: DocumentFieldAction = {
     })
 
     const isSelectable = !!useSelectedField(documentSchemaType, typePath)
-    const assistSupported = useAssistSupported(props.path, schemaType) && isSelectable
+    const assistSupported =
+      useAssistSupported(props.path, schemaType) &&
+      isSelectable &&
+      isSchemaAssistEnabled(documentSchemaType)
 
     const fieldAssist = useMemo(
       () =>

package/src/plugin.tsx

@@ -50,7 +50,10 @@ export const assist = definePlugin<AssistPluginConfig | void>((config) => {
       },
       unstable_languageFilter: (prev, {documentId, schema, schemaType}) => {
         const docSchema = schema.get(schemaType) as ObjectSchemaType
-        return [...prev, createAssistDocumentPresence(documentId, docSchema)]
+        if (isSchemaAssistEnabled(docSchema)) {
+          return [...prev, createAssistDocumentPresence(documentId, docSchema)]
+        }
+        return prev
       },
     },
 

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

@@ -23,6 +23,28 @@ const mockStudioTypes = [
 ]
 
 describe('serializeSchema', () => {
+  test('should not serialize excluded document schema', () => {
+    const schema = Schema.compile({
+      name: 'test',
+      types: [
+        defineType({
+          type: 'document',
+          name: 'article',
+          fields: [{type: 'string', name: 'title'}],
+          options: {
+            aiWritingAssistance: {
+              exclude: true,
+            },
+          },
+        }),
+      ],
+    })
+
+    const serializedTypes = serializeSchema(schema, {leanFormat: true})
+
+    expect(serializedTypes).toEqual([])
+  })
+
   test('should serialize simple schema', () => {
     const schema = Schema.compile({
       name: 'test',
@@ -422,6 +444,33 @@ describe('serializeSchema', () => {
     ])
   })
 
+  test('should not try to serialize list values if list values are not an array', () => {
+    const schema = Schema.compile({
+      name: 'test',
+      types: [
+        defineType({
+          type: 'array',
+          name: 'list',
+          of: [{type: 'string'}],
+          options: {
+            list: new Promise(() => {}) as any, // Type usually only accepts array, but some plugins might use other types
+          },
+        }),
+      ],
+    })
+
+    const serializedTypes = serializeSchema(schema, {leanFormat: true})
+
+    expect(serializedTypes).toEqual([
+      {
+        name: 'list',
+        type: 'array',
+        of: [{type: 'string', name: 'string', title: 'String'}],
+        values: undefined,
+      },
+    ])
+  })
+
   test('should exclude truthy hidden and readonly', () => {
     const schema = Schema.compile({
       name: 'test',

package/src/schemas/serialize/serializeSchema.ts

@@ -29,6 +29,7 @@ export function serializeSchema(schema: Schema, options?: Options): SerializedSc
     .filter((t) => !(hiddenTypes.includes(t) || t.startsWith('sanity.')))
     .map((t) => schema.get(t))
     .filter((t): t is SchemaType => !!t)
+    .filter((t) => isAssistSupported(t))
     .filter((t) => !t.hidden && !t.readOnly)
     .map((t) => getSchemaStub(t, schema, options))
     .filter((t) => {
@@ -83,7 +84,7 @@ function getBaseFields(
           imagePromptField: imagePromptField,
         }
       : undefined,
-    values: type?.options?.list
+    values: Array.isArray(type?.options?.list)
       ? type?.options?.list.map((v: string | {value: string; title: string}) =>
           typeof v === 'string' ? v : v.value ?? `${v.title}`
         )