sanity-plugin-internationalized-array 1.0.0 → 1.1.1

package/src/internationalizedArray.ts

@@ -1,111 +0,0 @@
-import {
-  CustomValidatorResult,
-  defineField,
-  FieldDefinition,
-  Rule,
-  SchemaType,
-  ValidationError,
-} from 'sanity'
-
-import InternationalizedArrayInput from './components/InternationalizedArrayInput'
-import {AllowedType, ArrayConfig, Language, Value} from './types'
-
-const CONFIG_DEFAULT = {name: `title`, type: `string` as AllowedType, languages: []}
-
-export function internationalizedArray(config: ArrayConfig = CONFIG_DEFAULT): FieldDefinition {
-  const {name, type, languages} = config
-
-  const configValidation = Array.isArray(config?.validation)
-    ? config.validation
-    : [config?.validation]
-
-  return defineField({
-    name,
-    title: config?.title ?? undefined,
-    group: config?.group ?? undefined,
-    hidden: config?.hidden ?? undefined,
-    readOnly: config?.readOnly ?? undefined,
-    type: 'array',
-    components: {input: InternationalizedArrayInput},
-    options: {languages},
-    of: [
-      {
-        type: 'object',
-        fields: [
-          {
-            name: 'value',
-            type,
-          },
-        ],
-        preview: {
-          select: {title: 'value', key: '_key'},
-          prepare(select) {
-            const {title, key} = select as Record<string, string>
-
-            return {
-              title,
-              subtitle: key.toUpperCase(),
-            }
-          },
-        },
-      },
-    ],
-    // @ts-ignore
-    validation: (rule: Rule) => {
-      const rules = [] as Rule[]
-
-      rules.push(
-        rule.custom<Value[]>((value, context) => {
-          const {languages: contextLanguages}: {languages: Language[]} =
-            context?.type?.options ?? {}
-          const nonLanguageKeys = value?.length
-            ? value.filter(
-                (item) => !contextLanguages.find((language) => item._key === language.id)
-              )
-            : []
-          if (nonLanguageKeys.length) {
-            return {
-              message: `Array item keys must be valid languages registered to the field type`,
-              paths: nonLanguageKeys.map((item) => [{_key: item._key}]),
-            }
-          }
-
-          // Ensure there's no duplicate `language` fields
-          type KeyedValues = {
-            [key: string]: Value[]
-          }
-
-          const valuesByLanguage = value?.length
-            ? value
-                .filter((item) => Boolean(item?._key))
-                .reduce((acc, cur) => {
-                  if (acc[cur._key]) {
-                    return {...acc, [cur._key]: [...acc[cur._key], cur]}
-                  }
-                  return {
-                    ...acc,
-                    [cur._key]: [cur],
-                  }
-                }, {} as KeyedValues)
-            : {}
-          const duplicateValues = Object.values(valuesByLanguage)
-            .filter((item) => item?.length > 1)
-            .flat()
-          if (duplicateValues.length) {
-            return {
-              message: 'There can only be one field per language',
-              paths: duplicateValues.map((item) => [{_key: item._key}]),
-            }
-          }
-          return true
-        })
-      )
-
-      if (languages?.length) {
-        rules.push(rule.max(languages.length))
-      }
-
-      return [...rules, ...configValidation].filter(Boolean)
-    },
-  })
-}