sanity-plugin-internationalized-array 3.2.2 → 4.0.1

package/src/schema/array.ts

@@ -1,148 +0,0 @@
-/* eslint-disable no-nested-ternary */
-import {defineField, type FieldDefinition, type Rule} from 'sanity'
-
-import {getFunctionCache, peek, setFunctionCache} from '../cache'
-import {createFieldName} from '../components/createFieldName'
-import {getSelectedValue} from '../components/getSelectedValue'
-import InternationalizedArray from '../components/InternationalizedArray'
-import type {Language, LanguageCallback, Value} from '../types'
-import {getLanguagesFieldOption} from '../utils/getLanguagesFieldOption'
-
-type ArrayFactoryConfig = {
-  apiVersion: string
-  select?: Record<string, string>
-  languages: Language[] | LanguageCallback
-  defaultLanguages?: string[]
-  type: string | FieldDefinition
-}
-
-export type ArrayFieldOptions = Pick<
-  ArrayFactoryConfig,
-  'apiVersion' | 'select' | 'languages'
->
-
-export default (config: ArrayFactoryConfig): FieldDefinition<'array'> => {
-  const {apiVersion, select, languages, type} = config
-  const typeName = typeof type === `string` ? type : type.name
-  const arrayName = createFieldName(typeName)
-  const objectName = createFieldName(typeName, true)
-
-  return defineField({
-    name: arrayName,
-    title: 'Internationalized array',
-    type: 'array',
-    components: {
-      input: InternationalizedArray,
-    },
-    options: {
-      // @ts-expect-error - these options are required for validation rules – not the custom input component
-      apiVersion,
-      select,
-      languages,
-    },
-    of: [
-      defineField({
-        ...(typeof type === 'string' ? {} : type),
-        name: objectName,
-        type: objectName,
-      }),
-    ],
-    // @ts-expect-error - fix typings
-    validation: (rule: Rule) =>
-      rule.custom<Value[]>(async (value, context) => {
-        if (!value || value.length === 0) {
-          return true
-        }
-
-        // Early return for simple cases to avoid expensive operations
-        if (value.length === 1 && !value[0]?._key) {
-          return true
-        }
-
-        const selectedValue = getSelectedValue(select, context.document)
-        const client = context.getClient({apiVersion})
-
-        let contextLanguages: Language[] = []
-        const languagesFieldOption = getLanguagesFieldOption(context?.type)
-
-        if (Array.isArray(languagesFieldOption)) {
-          contextLanguages = languagesFieldOption
-        } else if (Array.isArray(peek(selectedValue))) {
-          contextLanguages = peek(selectedValue) || []
-        } else if (typeof languagesFieldOption === 'function') {
-          // Try to get from function cache first (if it's the same function as the component)
-          const cachedLanguages = getFunctionCache(
-            languagesFieldOption,
-            selectedValue
-          )
-
-          if (Array.isArray(cachedLanguages)) {
-            contextLanguages = cachedLanguages
-          } else {
-            // Try suspend cache as fallback
-            const suspendCachedLanguages = peek(selectedValue)
-            if (Array.isArray(suspendCachedLanguages)) {
-              contextLanguages = suspendCachedLanguages
-            } else {
-              // Only make the async call if we don't have cached data
-              contextLanguages = await languagesFieldOption(
-                client,
-                selectedValue
-              )
-              // Cache the result for future validation calls
-              setFunctionCache(
-                languagesFieldOption,
-                selectedValue,
-                contextLanguages
-              )
-            }
-          }
-        }
-
-        if (value && value.length > contextLanguages.length) {
-          return `Cannot be more than ${
-            contextLanguages.length === 1
-              ? `1 item`
-              : `${contextLanguages.length} items`
-          }`
-        }
-
-        // Create a Set for faster language ID lookups
-        const languageIds = new Set(contextLanguages.map((lang) => lang.id))
-
-        // Check for invalid language keys
-        const nonLanguageKeys = value.filter(
-          (item) => item?._key && !languageIds.has(item._key)
-        )
-        if (nonLanguageKeys.length) {
-          return {
-            message: `Array item keys must be valid languages registered to the field type`,
-            paths: nonLanguageKeys.map((item) => [{_key: item._key}]),
-          }
-        }
-
-        // Check for duplicate language keys (more efficient)
-        const seenKeys = new Set<string>()
-        const duplicateValues: Value[] = []
-
-        for (const item of value) {
-          if (item?._key) {
-            if (seenKeys.has(item._key)) {
-              duplicateValues.push(item)
-            } else {
-              seenKeys.add(item._key)
-            }
-          }
-        }
-
-        if (duplicateValues.length) {
-          return {
-            message: 'There can only be one field per language',
-            paths: duplicateValues.map((item) => [{_key: item._key}]),
-          }
-        }
-
-        return true
-      }),
-  })
-}

package/src/schema/object.ts

@@ -1,36 +0,0 @@
-import {defineField, FieldDefinition} from 'sanity'
-
-import {createFieldName} from '../components/createFieldName'
-import InternationalizedInput from '../components/InternationalizedInput'
-
-type ObjectFactoryConfig = {
-  type: string | FieldDefinition
-}
-
-export default (config: ObjectFactoryConfig): FieldDefinition<'object'> => {
-  const {type} = config
-  const typeName = typeof type === `string` ? type : type.name
-  const objectName = createFieldName(typeName, true)
-
-  return defineField({
-    name: objectName,
-    title: `Internationalized array ${type}`,
-    type: 'object',
-    components: {
-      // @ts-expect-error - fix typings
-      item: InternationalizedInput,
-    },
-    fields: [
-      defineField({
-        ...(typeof type === 'string' ? {type} : type),
-        name: 'value',
-      }),
-    ],
-    preview: {
-      select: {
-        title: 'value',
-        subtitle: '_key',
-      },
-    },
-  })
-}

package/src/types.ts

@@ -1,135 +0,0 @@
-import type {
-  FieldDefinition,
-  Rule,
-  RuleTypeConstraint,
-  SanityClient,
-} from 'sanity'
-
-export type Language = {
-  id: Intl.UnicodeBCP47LocaleIdentifier
-  title: string
-}
-
-export type AllowedType = 'string' | 'number' | 'boolean' | 'text' | 'reference'
-
-export type ArrayConfig = {
-  name: string
-  type: AllowedType
-  languages: Language[]
-  title?: string
-  group?: string
-  hidden?: boolean | (() => boolean)
-  readOnly?: boolean | (() => boolean)
-  validation?: Rule | Rule[]
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  field?: {[key: string]: any; options: {[key: string]: any}}
-}
-
-export type Value = {
-  _key: string
-  value?: unknown
-}
-
-export type LanguageCallback = (
-  client: SanityClient,
-  selectedValue: Record<string, unknown>
-) => Promise<Language[]>
-
-export type LanguageDisplay = 'titleOnly' | 'codeOnly' | 'titleAndCode'
-
-export type PluginConfig = {
-  /**
-   * https://www.sanity.io/docs/api-versioning
-   * @defaultValue '2025-10-15'
-   */
-  apiVersion?: string
-  /**
-   * Specify fields that should be available in the language callback:
-   * ```tsx
-   * {
-   *   select: {
-   *     markets: 'markets'
-   *   },
-   *   languages: (client, {markets}) =>
-   *     query.fetch(groq`*[_type == "language" && market in $markets]{id,title}`, {markets})
-   * }
-   * ```
-   */
-  select?: Record<string, string>
-  /**
-   * You can give it an array of language definitions:
-   * ```tsx
-   * {
-   *   languages: [
-   *     {id: 'en', title: 'English'},
-   *     {id: 'fr', title: 'French'}
-   *   ]
-   * }
-   * ```
-   * You can load them async by passing a function that returns a promise:
-   * ```tsx
-   * {
-   *   languages: async () => {
-   *     const response = await fetch('https://example.com/languages')
-   *     return response.json()
-   *   }
-   * }
-   * ```
-   * You can query your dataset for languages::
-   * ```tsx
-   * {
-   *   languages: (client) =>
-   *     query.fetch(groq`*[_type == "language"]{id,title}`)
-   * }
-   * ```
-   */
-  languages: Language[] | LanguageCallback
-  /**
-   * You can specify a list of language IDs that should be pre-filled when creating a new document
-   * ```tsx
-   * {
-   *  defaultLanguages: ['en']
-   * }
-   * ```
-   */
-  defaultLanguages?: string[]
-  /**
-   * Can be a string matching core field types, as well as custom ones:
-   * ```tsx
-   * {
-   *   fieldTypes: [
-   *     "date", "datetime", "file", "image", "number", "string", "text", "url"
-   *   ]
-   * }
-   * ```
-   * You can also define a type directly:
-   * ```tsx
-   * {
-   *   fieldTypes: [
-   *     defineField({
-   *       name: 'featuredProduct',
-   *       type: 'reference',
-   *       to: [{type: 'product'}]
-   *       hidden: (({document}) => !document?.title)
-   *     })
-   *   ]
-   * }
-   * ```
-   */
-  fieldTypes: (string | RuleTypeConstraint | FieldDefinition)[]
-  /**
-   * Locations where the "+ EN" add language buttons are visible
-   * @defaultValue ['field']
-   * */
-  buttonLocations?: ('field' | 'unstable__fieldAction' | 'document')[]
-  /**
-   * Show or hide the "Add missing languages" button
-   * @defaultValue true
-   * */
-  buttonAddAll?: boolean
-  /**
-   * How to display the languages on buttons and fields
-   * @defaultValue 'code'
-   * */
-  languageDisplay?: LanguageDisplay
-}

package/src/utils/checkAllLanguagesArePresent.ts

@@ -1,14 +0,0 @@
-import {Language, Value} from '../types'
-
-export function checkAllLanguagesArePresent(
-  languages: Language[],
-  value: Value[] | undefined
-): boolean {
-  const filteredLanguageIds = languages.map((l) => l.id)
-  const languagesInUseIds = value ? value.map((v) => v._key) : []
-
-  return (
-    languagesInUseIds.length === filteredLanguageIds.length &&
-    languagesInUseIds.every((l) => filteredLanguageIds.includes(l))
-  )
-}

package/src/utils/createAddAllTitle.ts

@@ -1,16 +0,0 @@
-import {Language, Value} from '../types'
-
-export function createAddAllTitle(
-  value: Value[] | undefined,
-  languages: Language[]
-): string {
-  if (value?.length) {
-    return `Add missing ${
-      languages.length - value.length === 1 ? `language` : `languages`
-    }`
-  }
-
-  return languages.length === 1
-    ? `Add ${languages[0].title} Field`
-    : `Add all languages`
-}

package/src/utils/createAddLanguagePatches.ts

@@ -1,84 +0,0 @@
-import {FormInsertPatch, insert, Path, SchemaType} from 'sanity'
-
-import {Language, Value} from '../types'
-import {createValueSchemaTypeName} from './createValueSchemaTypeName'
-
-type AddConfig = {
-  // New keys to add to the field
-  addLanguageKeys: string[]
-  // Schema of the current field
-  schemaType: SchemaType
-  // All languages registered in the plugin
-  languages: Language[]
-  // Languages that are currently visible
-  filteredLanguages: Language[]
-  // Current value of the internationalizedArray field
-  value?: Value[]
-  // Path to this item
-  path?: Path
-}
-
-export function createAddLanguagePatches(config: AddConfig): FormInsertPatch[] {
-  const {
-    addLanguageKeys,
-    schemaType,
-    languages,
-    filteredLanguages,
-    value,
-    path = [],
-  } = config
-
-  const itemBase = {_type: createValueSchemaTypeName(schemaType)}
-
-  // Create new items
-  const getNewItems = () => {
-    if (Array.isArray(addLanguageKeys) && addLanguageKeys.length > 0) {
-      return addLanguageKeys.map((id) => ({
-        ...itemBase,
-        _key: id,
-      }))
-    }
-
-    return filteredLanguages
-      .filter((language) =>
-        value?.length ? !value.find((v) => v._key === language.id) : true
-      )
-      .map((language) => ({
-        ...itemBase,
-        _key: language.id,
-      }))
-  }
-  const newItems = getNewItems()
-
-  // Insert new items in the correct order
-  const languagesInUse = value?.length ? value.map((v) => v) : []
-
-  const insertions = newItems.map((item) => {
-    // What's the original index of this language?
-    const languageIndex = languages.findIndex((l) => item._key === l.id)
-
-    // What languages are there beyond that index?
-    const remainingLanguages = languages.slice(languageIndex + 1)
-
-    // So what is the index in the current value array of the next language in the language array?
-    const nextLanguageIndex = languagesInUse.findIndex((l) =>
-      // eslint-disable-next-line max-nested-callbacks
-      remainingLanguages.find((r) => r.id === l._key)
-    )
-
-    // Keep local state up to date incase multiple insertions are being made
-    if (nextLanguageIndex < 0) {
-      languagesInUse.push(item)
-    } else {
-      languagesInUse.splice(nextLanguageIndex, 0, item)
-    }
-
-    return nextLanguageIndex < 0
-      ? // No next language (-1), add to end of array
-        insert([item], 'after', [...path, nextLanguageIndex])
-      : // Next language found, insert before that
-        insert([item], 'before', [...path, nextLanguageIndex])
-  })
-
-  return insertions
-}

package/src/utils/createValueSchemaTypeName.ts

@@ -1,5 +0,0 @@
-import {SchemaType} from 'sanity'
-
-export function createValueSchemaTypeName(schemaType: SchemaType): string {
-  return `${schemaType.name}Value`
-}

package/src/utils/flattenSchemaType.ts

@@ -1,63 +0,0 @@
-import {
-  isDocumentSchemaType,
-  type ObjectField,
-  type Path,
-  type 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' &&
-      field.type.of.length &&
-      field.type.of.some((item) => 'fields' in item)
-    ) {
-      const innerFields = field.type.of.flatMap((innerField) =>
-        extractInnerFields(
-          // @ts-expect-error - Fix TS assertion for array fields
-          innerField.fields,
-          [...path, field.name],
-          maxDepth
-        )
-      )
-
-      return [...acc, thisFieldWithPath, ...innerFields]
-    }
-
-    return [...acc, thisFieldWithPath]
-  }, [])
-}

package/src/utils/getDocumentsToTranslate.ts

@@ -1,66 +0,0 @@
-import {SanityDocument} from 'sanity'
-
-export interface DocumentsToTranslate {
-  path: (string | number)[]
-  pathString: string
-  _key: string
-  _type: string
-  [key: string]: unknown
-}
-
-export const getDocumentsToTranslate = (
-  value: SanityDocument | unknown,
-  rootPath: (string | number)[] = []
-): DocumentsToTranslate[] => {
-  if (Array.isArray(value)) {
-    const arrayRootPath = [...rootPath]
-
-    // if item contains internationalized return array
-    const internationalizedValues = value.filter((item) => {
-      if (Array.isArray(item)) return false
-
-      if (typeof item === 'object') {
-        const type = item?._type as string | undefined
-        return (
-          type?.startsWith('internationalizedArray') && type?.endsWith('Value')
-        )
-      }
-      return false
-    })
-
-    if (internationalizedValues.length > 0) {
-      return internationalizedValues.map((internationalizedValue) => {
-        return {
-          ...internationalizedValue,
-          path: arrayRootPath,
-          pathString: arrayRootPath.join('.'),
-        }
-      })
-    }
-
-    if (value.length > 0) {
-      return value
-        .map((item, index) =>
-          getDocumentsToTranslate(item, [...arrayRootPath, index])
-        )
-        .flat()
-    }
-
-    return []
-  }
-  if (typeof value === 'object' && value) {
-    const startsWithUnderscoreRegex = /^_/
-    const itemKeys = Object.keys(value).filter(
-      (key) => !key.match(startsWithUnderscoreRegex)
-    ) as (keyof typeof value)[]
-
-    return itemKeys
-      .map((item) => {
-        const selectedValue = value[item] as unknown
-        const path = [...rootPath, item]
-        return getDocumentsToTranslate(selectedValue, path)
-      })
-      .flat()
-  }
-  return []
-}

package/src/utils/getLanguageDisplay.ts

@@ -1,13 +0,0 @@
-import {LanguageDisplay} from '../types'
-
-export function getLanguageDisplay(
-  languageDisplay: LanguageDisplay,
-  title: string,
-  code: string
-): string {
-  if (languageDisplay === 'codeOnly') return code.toUpperCase()
-  if (languageDisplay === 'titleOnly') return title
-  if (languageDisplay === 'titleAndCode')
-    return `${title} (${code.toUpperCase()})`
-  return title
-}

package/src/utils/getLanguagesFieldOption.ts

@@ -1,16 +0,0 @@
-import {SchemaType} from 'sanity'
-
-import {ArrayFieldOptions} from '../schema/array'
-
-export function getLanguagesFieldOption(
-  schemaType: SchemaType | undefined
-): ArrayFieldOptions['languages'] | undefined {
-  if (!schemaType) {
-    return undefined
-  }
-  const languagesOption = (schemaType.options as ArrayFieldOptions)?.languages
-  if (languagesOption) {
-    return languagesOption
-  }
-  return getLanguagesFieldOption(schemaType.type)
-}

package/v2-incompatible.js

@@ -1,11 +0,0 @@
-const {showIncompatiblePluginDialog} = require('@sanity/incompatible-plugin')
-const {name, version, sanityExchangeUrl} = require('./package.json')
-
-export default showIncompatiblePluginDialog({
-  name: name,
-  versions: {
-    v3: version,
-    v2: undefined,
-  },
-  sanityExchangeUrl,
-})