sanity-plugin-internationalized-array 1.9.0 → 1.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sanity-plugin-internationalized-array",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "description": "Store localized fields in an array to save on attributes",
   "keywords": [
     "sanity",

package/src/components/InternationalizedArray.tsx

@@ -9,6 +9,7 @@ import {
   set,
   setIfMissing,
   useFormValue,
+  MemberItemError
 } from 'sanity'
 
 import {MAX_COLUMNS} from '../constants'
@@ -216,17 +217,14 @@ export default function InternationalizedArray(
             if (member.kind === 'item') {
               return (
                 <ArrayOfObjectsItem
+                  {...props}
                   key={member.key}
                   member={member}
-                  renderItem={props.renderItem}
-                  renderField={props.renderField}
-                  renderInput={props.renderInput}
-                  renderPreview={props.renderPreview}
                 />
               )
             }
 
-            return null
+            return <MemberItemError key={member.key} member={member} />
           })}
         </>
       ) : null}

package/src/components/InternationalizedArrayContext.tsx

@@ -58,7 +58,7 @@ export function InternationalizedArrayProvider(
           }
           return internationalizedArray.languages
         },
-        [version, namespace],
+        [version, namespace, selectedValue],
         {equal}
       )
 

package/src/plugin.tsx

@@ -7,6 +7,7 @@ import {internationalizedArrayFieldAction} from './fieldActions'
 import array from './schema/array'
 import object from './schema/object'
 import {PluginConfig} from './types'
+import {flattenSchemaType} from './utils/flattenSchemaType'
 
 export const internationalizedArray = definePlugin<PluginConfig>((config) => {
   const pluginConfig = {...CONFIG_DEFAULT, ...config}
@@ -50,11 +51,10 @@ export const internationalizedArray = definePlugin<PluginConfig>((config) => {
             return props.renderDefault(props)
           }
 
-          const rootFieldTypeNames = props.schemaType.fields.map(
+          const flatFieldTypeNames = flattenSchemaType(props.schemaType).map(
             (field) => field.type.name
           )
-
-          const hasInternationalizedArray = rootFieldTypeNames.some((name) =>
+          const hasInternationalizedArray = flatFieldTypeNames.some((name) =>
             name.startsWith('internationalizedArray')
           )
 

package/src/types.ts

@@ -118,10 +118,10 @@ export type PluginConfig = {
    * Locations where the "+ EN" add language buttons are visible
    * @defaultValue ['field']
    * */
-  buttonLocations: ('field' | 'unstable__fieldAction' | 'document')[]
+  buttonLocations?: ('field' | 'unstable__fieldAction' | 'document')[]
   /**
    * Show or hide the "Add missing languages" button
    * @defaultValue true
    * */
-  buttonAddAll: boolean
+  buttonAddAll?: boolean
 }

package/src/utils/flattenSchemaType.ts

@@ -0,0 +1,59 @@
+import {
+  isArraySchemaType,
+  isDocumentSchemaType,
+  ObjectField,
+  Path,
+  SchemaType,
+} from 'sanity'
+
+type ObjectFieldWithPath = ObjectField<SchemaType> & {path: Path}
+
+/**
+ * Flattens a document's schema type into a flat array of fields and includes their path
+ */
+export function flattenSchemaType(
+  schemaType: SchemaType
+): ObjectFieldWithPath[] {
+  if (!isDocumentSchemaType(schemaType)) {
+    console.error(`Schema type is not a document`)
+    return []
+  }
+
+  return extractInnerFields(schemaType.fields, [], 3)
+}
+
+function extractInnerFields(
+  fields: ObjectField<SchemaType>[],
+  path: Path,
+  maxDepth: number
+): ObjectFieldWithPath[] {
+  if (path.length >= maxDepth) {
+    return []
+  }
+
+  return fields.reduce<ObjectFieldWithPath[]>((acc, field) => {
+    const thisFieldWithPath = {path: [...path, field.name], ...field}
+
+    if (field.type.jsonType === 'object') {
+      const innerFields = extractInnerFields(
+        field.type.fields,
+        [...path, field.name],
+        maxDepth
+      )
+
+      return [...acc, thisFieldWithPath, ...innerFields]
+    } else if (field.type.jsonType === 'array' && isArraySchemaType(field)) {
+      const innerFields = extractInnerFields(
+        // TODO: Fix TS assertion for array fields
+        // @ts-expect-error
+        field.type.of,
+        [...path, field.name],
+        maxDepth
+      )
+
+      return [...acc, thisFieldWithPath, ...innerFields]
+    }
+
+    return [...acc, thisFieldWithPath]
+  }, [])
+}