@sanity/assist 1.0.8 → 1.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/assist",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "",
   "keywords": [
     "sanity",
@@ -53,6 +53,7 @@
     "@sanity/icons": "^2.4.0",
     "@sanity/incompatible-plugin": "^1.0.4",
     "@sanity/ui": "^1.6.0",
+    "date-fns": "^2.30.0",
     "react-fast-compare": "^3.2.1",
     "rxjs": "^7.8.0",
     "rxjs-exhaustmap-with-trailing": "^2.1.1"
@@ -68,6 +69,7 @@
     "@types/styled-components": "^5.1.26",
     "@typescript-eslint/eslint-plugin": "^5.56.0",
     "@typescript-eslint/parser": "^5.56.0",
+    "date-fns": "^2.30.0",
     "eslint": "^8.36.0",
     "eslint-config-prettier": "^8.8.0",
     "eslint-config-sanity": "^6.0.0",
@@ -87,7 +89,9 @@
   },
   "peerDependencies": {
     "react": "^18",
-    "sanity": "^3.13.0"
+    "react-is": "^18.2.0",
+    "sanity": "^3.13.0",
+    "styled-components": "^5.2"
   },
   "engines": {
     "node": ">=14"

package/src/assistInspector/helpers.ts

@@ -82,7 +82,7 @@ export function getFieldRefs(
       const fields =
         field.type.jsonType === 'object' ? getFieldRefs(field.type, fieldRef, depth + 1) : []
 
-      if (!isAssistSupported(field.type)) {
+      if (!isAssistSupported(field.type, true)) {
         return fields
       }
       return [fieldRef, ...fields]

package/src/components/FadeInContent.tsx

@@ -0,0 +1,33 @@
+import {ReactElement, ReactNode} from 'react'
+import styled, {keyframes} from 'styled-components'
+
+const fadeIn = keyframes`
+  0% {
+    opacity: 0;
+    transform: scale(0.75);
+  }
+  40% {
+    opacity: 0;
+    transform: scale(0.75);
+  }
+  100% {
+    opacity: 1;
+    transform: scale(1);
+  }
+`
+
+const FadeInDiv = styled.div`
+  animation-name: ${fadeIn};
+  animation-timing-function: ease-in-out;
+`
+
+export function FadeInContent({
+  children,
+  durationMs = 250,
+}: {
+  children?: ReactNode
+  ms?: number
+  durationMs?: number
+}): ReactElement {
+  return <FadeInDiv style={{animationDuration: `${durationMs}ms`}}>{children}</FadeInDiv>
+}

package/src/fieldActions/assistFieldActions.tsx

@@ -28,7 +28,9 @@ function node(node: DocumentFieldActionItem | DocumentFieldActionGroup) {
 export const assistFieldActions: DocumentFieldAction = {
   name: 'sanity-assist-actions',
   useAction(props) {
-    const assistSupported = useAssistSupported(props.path, props.schemaType)
+    const {schemaType} = props
+    const assistSupported = useAssistSupported(props.path, schemaType)
+
     const isDocumentLevel = props.path.length === 0
 
     const {
@@ -47,7 +49,7 @@ export const assistFieldActions: DocumentFieldAction = {
       // conditional hook _should_ be safe here since the logical path will be stable
       isDocumentLevel
         ? // eslint-disable-next-line react-hooks/rules-of-hooks
-          useAssistDocumentContextValue(props.documentId, props.schemaType as ObjectSchemaType)
+          useAssistDocumentContextValue(props.documentId, schemaType as ObjectSchemaType)
         : // eslint-disable-next-line react-hooks/rules-of-hooks
           useAssistDocumentContext()
 

package/src/helpers/assistSupported.ts

@@ -6,30 +6,40 @@ export function isSchemaAssistEnabled(type: SchemaType) {
   return !(type.options as AssistOptions | undefined)?.aiWritingAssistance?.exclude
 }
 
-export function isAssistSupported(type: SchemaType) {
+export function isAssistSupported(type: SchemaType, allowReadonlyHidden = false) {
   if (!isSchemaAssistEnabled(type)) {
     return false
   }
 
-  if (isUnsupportedType(type)) {
+  if (isDisabled(type, allowReadonlyHidden)) {
     return false
   }
 
   if (type.jsonType === 'array') {
-    const unsupportedArray = type.of.every((t) => isUnsupportedType(t))
+    const unsupportedArray = type.of.every((t) => isDisabled(t, allowReadonlyHidden))
     return !unsupportedArray
   }
 
   if (type.jsonType === 'object') {
-    const unsupportedObject = type.fields.every((field) => isUnsupportedType(field.type))
+    const unsupportedObject = type.fields.every((field) =>
+      isDisabled(field.type, allowReadonlyHidden)
+    )
     return !unsupportedObject
   }
   return true
 }
 
-function isUnsupportedType(type: SchemaType) {
+function isDisabled(type: SchemaType, allowReadonlyHidden: boolean) {
+  const readonlyHidden = !!type.readOnly || !!type.hidden
   return (
     !isSchemaAssistEnabled(type) ||
+    isUnsupportedType(type) ||
+    (!allowReadonlyHidden && readonlyHidden)
+  )
+}
+
+function isUnsupportedType(type: SchemaType) {
+  return (
     type.jsonType === 'number' ||
     type.name === 'sanity.imageCrop' ||
     type.name === 'sanity.imageHotspot' ||

package/src/presence/AiFieldPresence.tsx

@@ -1,7 +1,7 @@
 // eslint-disable-next-line react/no-unused-prop-types
 import {FormNodePresence} from 'sanity'
 import {Card, Flex, Text, Tooltip} from '@sanity/ui'
-import {Delay} from '../components/Delay'
+import {FadeInContent} from '../components/FadeInContent'
 import {AssistAvatar} from './AssistAvatar'
 
 export function AiFieldPresence(props: {presence: FormNodePresence}) {
@@ -17,11 +17,9 @@ export function AiFieldPresence(props: {presence: FormNodePresence}) {
           </Card>
         }
       >
-        <div>
-          <Delay durationMs={200} ms={250}>
-            <AssistAvatar state="active" />
-          </Delay>
-        </div>
+        <FadeInContent durationMs={300}>
+          <AssistAvatar state="active" />
+        </FadeInContent>
       </Tooltip>
     </Card>
   )

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

@@ -391,4 +391,30 @@ describe('serializeSchema', () => {
       {name: 'list', title: 'String', type: 'string', values: ['a', 'b']},
     ])
   })
+
+  test('should exclude truthy hidden and readonly', () => {
+    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',
+          readOnly: true,
+          fields: [{type: 'string', name: 'title'}],
+        }),
+      ],
+    })
+
+    const serializedTypes = serializeSchema(schema, {leanFormat: true})
+
+    expect(serializedTypes).toEqual([])
+  })
 })

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) => !t.hidden && !t.readOnly)
     .map((t) => getSchemaStub(t, schema, options))
     .filter((t) => {
       if ('to' in t && t.to && !t.to.length) {
@@ -106,6 +107,7 @@ function serializeFields(
   return schemaType.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))
 }
 

package/src/components/Delay.tsx

@@ -1,25 +0,0 @@
-import {motion} from 'framer-motion'
-import {ReactElement, ReactNode} from 'react'
-
-export function Delay({
-  children,
-  ms = 1000,
-  durationMs = 250,
-}: {
-  children?: ReactNode
-  ms?: number
-  durationMs?: number
-}): ReactElement {
-  return (
-    <motion.div
-      initial={{opacity: 0, scale: 0.75}}
-      animate={{opacity: 1, scale: 1}}
-      transition={{
-        delay: ms / 1000,
-        duration: durationMs / 1000,
-      }}
-    >
-      {children}
-    </motion.div>
-  )
-}