@sanity/document-internationalization 4.1.1 → 5.0.1

package/src/plugin.tsx

@@ -1,239 +0,0 @@
-import {Stack} from '@sanity/ui'
-import {defineField, definePlugin, isSanityDocument} from 'sanity'
-import {internationalizedArray} from 'sanity-plugin-internationalized-array'
-
-import {DeleteMetadataAction} from './actions/DeleteMetadataAction'
-import {LanguageBadge} from './badges'
-import BulkPublish from './components/BulkPublish'
-import {DocumentInternationalizationProvider} from './components/DocumentInternationalizationContext'
-import {DocumentInternationalizationMenu} from './components/DocumentInternationalizationMenu'
-import OptimisticallyStrengthen from './components/OptimisticallyStrengthen'
-import {API_VERSION, DEFAULT_CONFIG, METADATA_SCHEMA_NAME} from './constants'
-import {documentInternationalizationUsEnglishLocaleBundle} from './i18n'
-import metadata from './schema/translation/metadata'
-import type {PluginConfig, TranslationReference} from './types'
-
-export const documentInternationalization = definePlugin<PluginConfig>(
-  (config) => {
-    const pluginConfig = {...DEFAULT_CONFIG, ...config}
-    const {
-      supportedLanguages,
-      schemaTypes,
-      languageField,
-      bulkPublish,
-      metadataFields,
-    } = pluginConfig
-
-    if (schemaTypes.length === 0) {
-      throw new Error(
-        'You must specify at least one schema type on which to enable document internationalization. Update the `schemaTypes` option in the documentInternationalization() configuration.'
-      )
-    }
-
-    return {
-      name: '@sanity/document-internationalization',
-
-      studio: {
-        components: {
-          layout: (props) =>
-            DocumentInternationalizationProvider({...props, pluginConfig}),
-        },
-      },
-
-      i18n: {
-        bundles: [documentInternationalizationUsEnglishLocaleBundle],
-      },
-
-      // Adds:
-      // - A bulk-publishing UI component to the form
-      // - Will only work for projects on a compatible plan
-      form: {
-        components: {
-          input: (props) => {
-            if (
-              props.id === 'root' &&
-              props.schemaType.name === METADATA_SCHEMA_NAME &&
-              isSanityDocument(props?.value)
-            ) {
-              const metadataId = props?.value?._id
-              const translations =
-                (props?.value?.translations as TranslationReference[]) ?? []
-              const weakAndTypedTranslations = translations.filter(
-                ({value}) => value?._weak && value._strengthenOnPublish
-              )
-
-              return (
-                <Stack space={5}>
-                  {bulkPublish ? (
-                    <BulkPublish translations={translations} />
-                  ) : null}
-                  {weakAndTypedTranslations.length > 0 ? (
-                    <OptimisticallyStrengthen
-                      metadataId={metadataId}
-                      translations={weakAndTypedTranslations}
-                    />
-                  ) : null}
-                  {props.renderDefault(props)}
-                </Stack>
-              )
-            }
-
-            return props.renderDefault(props)
-          },
-        },
-      },
-
-      // Adds:
-      // - The `Translations` dropdown to the editing form
-      // - `Badges` to documents with a language value
-      // - The `DeleteMetadataAction` action to the metadata document type
-      document: {
-        unstable_languageFilter: (prev, ctx) => {
-          const {schemaType, documentId} = ctx
-
-          return schemaTypes.includes(schemaType) && documentId
-            ? [
-                ...prev,
-                (props) =>
-                  DocumentInternationalizationMenu({...props, documentId}),
-              ]
-            : prev
-        },
-        badges: (prev, {schemaType}) => {
-          if (!schemaTypes.includes(schemaType)) {
-            return prev
-          }
-
-          return [(props) => LanguageBadge(props), ...prev]
-        },
-        actions: (prev, {schemaType}) => {
-          if (schemaType === METADATA_SCHEMA_NAME) {
-            return [...prev, DeleteMetadataAction]
-          }
-
-          return prev
-        },
-      },
-
-      // Adds:
-      // - The `Translations metadata` document type to the schema
-      schema: {
-        // Create the metadata document type
-        types: [metadata(schemaTypes, metadataFields)],
-
-        // For every schema type this plugin is enabled on
-        // Create an initial value template to set the language
-        templates: (prev, {schema}) => {
-          // Templates are not setup for async languages
-          if (!Array.isArray(supportedLanguages)) {
-            return prev
-          }
-
-          const parameterizedTemplates = schemaTypes.map((schemaType) => ({
-            id: `${schemaType}-parameterized`,
-            title: `${
-              schema?.get(schemaType)?.title ?? schemaType
-            }: with Language`,
-            schemaType,
-            parameters: [
-              {name: `languageId`, title: `Language ID`, type: `string`},
-            ],
-            value: ({languageId}: {languageId: string}) => ({
-              [languageField]: languageId,
-            }),
-          }))
-
-          const staticTemplates = schemaTypes.flatMap((schemaType) => {
-            return supportedLanguages.map((language) => ({
-              id: `${schemaType}-${language.id}`,
-              title: `${language.title} ${
-                schema?.get(schemaType)?.title ?? schemaType
-              }`,
-              schemaType,
-              value: {
-                [languageField]: language.id,
-              },
-            }))
-          })
-
-          return [...prev, ...parameterizedTemplates, ...staticTemplates]
-        },
-      },
-
-      // Uses:
-      // - `sanity-plugin-internationalized-array` to maintain the translations array
-      plugins: [
-        // Translation metadata stores its references using this plugin
-        // It cuts down on attribute usage and gives UI conveniences to add new translations
-        internationalizedArray({
-          apiVersion: pluginConfig.apiVersion,
-          languages: supportedLanguages,
-          fieldTypes: [
-            defineField(
-              {
-                name: 'reference',
-                type: 'reference',
-                to: schemaTypes.map((type) => ({type})),
-                weak: pluginConfig.weakReferences,
-                // Reference filters don't actually enforce validation!
-                validation: (Rule) =>
-                  // @ts-expect-error - fix typings
-                  Rule.custom(async (item: TranslationReference, context) => {
-                    if (!item?.value?._ref || !item?._key) {
-                      return true
-                    }
-
-                    const client = context.getClient({apiVersion: API_VERSION})
-                    const valueLanguage = await client.fetch(
-                      `*[_id in [$ref, $draftRef]][0].${languageField}`,
-                      {
-                        ref: item.value._ref,
-                        draftRef: `drafts.${item.value._ref}`,
-                      }
-                    )
-
-                    if (valueLanguage && valueLanguage === item._key) {
-                      return true
-                    }
-
-                    return `Referenced document does not have the correct language value`
-                  }),
-                options: {
-                  // @ts-expect-error - Update type once it knows the values of this filter
-                  filter: ({parent, document}) => {
-                    if (!parent) return null
-
-                    // I'm not sure in what instance there's an array of parents
-                    // But the Type suggests it's possible
-                    const parentArray = Array.isArray(parent)
-                      ? parent
-                      : [parent]
-                    const language = parentArray.find((p) => p._key)
-
-                    if (!language?._key) return null
-
-                    if (document.schemaTypes) {
-                      return {
-                        filter: `_type in $schemaTypes && ${languageField} == $language`,
-                        params: {
-                          schemaTypes: document.schemaTypes,
-                          language: language._key,
-                        },
-                      }
-                    }
-
-                    return {
-                      filter: `${languageField} == $language`,
-                      params: {language: language._key},
-                    }
-                  },
-                },
-              },
-              {strict: false}
-            ),
-          ],
-        }),
-      ],
-    }
-  }
-)

package/src/schema/translation/metadata.ts

@@ -1,68 +0,0 @@
-import {TranslateIcon} from '@sanity/icons'
-import {
-  defineField,
-  defineType,
-  type DocumentDefinition,
-  type FieldDefinition,
-} from 'sanity'
-
-import {METADATA_SCHEMA_NAME, TRANSLATIONS_ARRAY_NAME} from '../../constants'
-
-export default (
-  schemaTypes: string[],
-  metadataFields: FieldDefinition[]
-): DocumentDefinition =>
-  defineType({
-    type: 'document',
-    name: METADATA_SCHEMA_NAME,
-    title: 'Translation metadata',
-    icon: TranslateIcon,
-    liveEdit: true,
-    fields: [
-      defineField({
-        name: TRANSLATIONS_ARRAY_NAME,
-        type: 'internationalizedArrayReference',
-      }),
-      defineField({
-        name: 'schemaTypes',
-        description:
-          'Optional: Used to filter the reference fields above so all translations share the same types.',
-        type: 'array',
-        of: [{type: 'string'}],
-        options: {list: schemaTypes},
-        readOnly: ({value}) => Boolean(value),
-      }),
-      ...metadataFields,
-    ],
-    preview: {
-      select: {
-        translations: TRANSLATIONS_ARRAY_NAME,
-        documentSchemaTypes: 'schemaTypes',
-      },
-      prepare(selection) {
-        const {translations = [], documentSchemaTypes = []} = selection
-        const title =
-          translations.length === 1
-            ? `1 Translation`
-            : `${translations.length} Translations`
-        const languageKeys = translations.length
-          ? translations
-              .map((t: {_key: string}) => t._key.toUpperCase())
-              .join(', ')
-          : ``
-        const subtitle = [
-          languageKeys ? `(${languageKeys})` : null,
-          documentSchemaTypes?.length
-            ? documentSchemaTypes.map((s: string) => s).join(`, `)
-            : ``,
-        ]
-          .filter(Boolean)
-          .join(` `)
-
-        return {
-          title,
-          subtitle,
-        }
-      },
-    },
-  })

package/src/types.ts

@@ -1,97 +0,0 @@
-/* eslint-disable no-unused-vars */
-
-import type {
-  FieldDefinition,
-  KeyedObject,
-  ObjectSchemaType,
-  Reference,
-  SanityClient,
-  SanityDocument,
-  SanityDocumentLike,
-} from 'sanity'
-
-export type Language = {
-  id: Intl.UnicodeBCP47LocaleIdentifier
-  title: string
-}
-
-export type SupportedLanguages =
-  | Language[]
-  | ((client: SanityClient) => Promise<Language[]>)
-
-export type PluginCallbackArgs = {
-  sourceDocument: SanityDocument
-  newDocument: SanityDocument
-  sourceLanguageId: string
-  destinationLanguageId: string
-  metaDocumentId: string
-  client: SanityClient
-}
-
-export type PluginConfig = {
-  supportedLanguages: SupportedLanguages
-  schemaTypes: string[]
-  languageField?: string
-  weakReferences?: boolean
-  bulkPublish?: boolean
-  metadataFields?: FieldDefinition[]
-  apiVersion?: string
-  allowCreateMetaDoc?: boolean
-  callback?: ((args: PluginCallbackArgs) => Promise<void>) | null
-}
-
-// Context version of config
-// should have processed the
-// supportedLanguages function
-export type PluginConfigContext = Required<PluginConfig> & {
-  supportedLanguages: Language[]
-}
-
-export type TranslationReference = KeyedObject & {
-  _type: 'internationalizedArrayReferenceValue'
-  value: Reference
-}
-
-export type Metadata = {
-  _id: string
-  _createdAt: string
-  translations: TranslationReference[]
-}
-
-export type MetadataDocument = SanityDocumentLike & {
-  schemaTypes: string[]
-  translations: TranslationReference[]
-}
-
-export type DocumentInternationalizationMenuProps = {
-  schemaType: ObjectSchemaType
-  documentId: string
-}
-
-// Extend Sanity schema definitions
-export interface DocumentInternationalizationSchemaOpts {
-  documentInternationalization?: {
-    /** Set to true to disable duplication of this field or type */
-    exclude?: boolean
-  }
-}
-
-declare module 'sanity' {
-  interface ArrayOptions extends DocumentInternationalizationSchemaOpts {}
-  interface BlockOptions extends DocumentInternationalizationSchemaOpts {}
-  interface BooleanOptions extends DocumentInternationalizationSchemaOpts {}
-  interface CrossDatasetReferenceOptions extends DocumentInternationalizationSchemaOpts {}
-  interface DateOptions extends DocumentInternationalizationSchemaOpts {}
-  interface DatetimeOptions extends DocumentInternationalizationSchemaOpts {}
-  interface FileOptions extends DocumentInternationalizationSchemaOpts {}
-  interface GeopointOptions extends DocumentInternationalizationSchemaOpts {}
-  interface ImageOptions extends DocumentInternationalizationSchemaOpts {}
-  interface NumberOptions extends DocumentInternationalizationSchemaOpts {}
-  interface ObjectOptions extends DocumentInternationalizationSchemaOpts {}
-  interface ReferenceBaseOptions extends DocumentInternationalizationSchemaOpts {}
-  interface SlugOptions extends DocumentInternationalizationSchemaOpts {}
-  interface StringOptions extends DocumentInternationalizationSchemaOpts {}
-  interface TextOptions extends DocumentInternationalizationSchemaOpts {}
-  interface UrlOptions extends DocumentInternationalizationSchemaOpts {}
-  interface EmailOptions extends DocumentInternationalizationSchemaOpts {}
-}

package/src/utils/createReference.ts

@@ -1,20 +0,0 @@
-import type {TranslationReference} from '../types'
-
-export function createReference(
-  key: string,
-  ref: string,
-  type: string,
-  strengthenOnPublish: boolean = true
-): TranslationReference {
-  return {
-    _key: key,
-    _type: 'internationalizedArrayReferenceValue',
-    value: {
-      _type: 'reference',
-      _ref: ref,
-      _weak: true,
-      // If the user has configured weakReferences, we won't want to strengthen them
-      ...(strengthenOnPublish ? {_strengthenOnPublish: {type}} : {}),
-    },
-  }
-}

package/src/utils/excludePaths.ts

@@ -1,123 +0,0 @@
-import {extractWithPath, Mutation} from '@sanity/mutator'
-import {
-  isDocumentSchemaType,
-  type ObjectSchemaType,
-  type Path,
-  pathToString,
-  type SanityDocument,
-  type SchemaType,
-} from 'sanity'
-
-export interface DocumentMember {
-  schemaType: SchemaType
-  path: Path
-  name: string
-  value: unknown
-}
-
-export function removeExcludedPaths(
-  doc: SanityDocument | null,
-  schemaType: ObjectSchemaType
-): SanityDocument | null {
-  // If the supplied doc is null or the schemaType
-  // isn't a document, return as is.
-  if (!isDocumentSchemaType(schemaType) || !doc) {
-    return doc
-  }
-
-  // The extractPaths function gets all the fields in the doc with
-  // a value, along with their schemaTypes and paths. We'll end up
-  // with an array of paths in string form which we want to exclude
-  const pathsToExclude: string[] = extractPaths(doc, schemaType, [])
-    // We filter for any fields which should be excluded from the document
-    // duplicate action, based on the schemaType option being set.
-    .filter(
-      (field) =>
-        field.schemaType?.options?.documentInternationalization?.exclude ===
-        true
-    )
-    // then we return the stringified version of the path
-    .map((field) => {
-      return pathToString(field.path)
-    })
-
-  // Now we can use the Mutation class from @sanity/mutator to patch the document
-  // to remove all the paths that are for one of the excluded fields. This is just
-  // done locally, and the documents themselves are not patched in the Content Lake.
-  const mut = new Mutation({
-    mutations: [
-      {
-        patch: {
-          id: doc._id,
-          unset: pathsToExclude,
-        },
-      },
-    ],
-  })
-
-  return mut.apply(doc) as SanityDocument
-}
-
-function extractPaths(
-  doc: SanityDocument,
-  schemaType: ObjectSchemaType,
-  path: Path
-): DocumentMember[] {
-  return schemaType.fields.reduce<DocumentMember[]>((acc, field) => {
-    const fieldPath = [...path, field.name]
-    const fieldSchema = field.type
-    const {value} = extractWithPath(pathToString(fieldPath), doc)[0] ?? {}
-    if (!value) {
-      return acc
-    }
-
-    const thisFieldWithPath: DocumentMember = {
-      path: fieldPath,
-      name: field.name,
-      schemaType: fieldSchema,
-      value,
-    }
-
-    if (fieldSchema.jsonType === 'object') {
-      const innerFields = extractPaths(doc, fieldSchema, fieldPath)
-
-      return [...acc, thisFieldWithPath, ...innerFields]
-    } else if (
-      fieldSchema.jsonType === 'array' &&
-      fieldSchema.of.length &&
-      fieldSchema.of.some((item) => 'fields' in item)
-    ) {
-      const {value: arrayValue} =
-        extractWithPath(pathToString(fieldPath), doc)[0] ?? {}
-
-      let arrayPaths: DocumentMember[] = []
-      if ((arrayValue as any)?.length) {
-        for (const item of arrayValue as any[]) {
-          const itemPath = [...fieldPath, {_key: item._key}]
-          let itemSchema = fieldSchema.of.find((t) => t.name === item._type)
-          if (!item._type) {
-            itemSchema = fieldSchema.of[0]
-          }
-          if (item._key && itemSchema) {
-            const innerFields = extractPaths(
-              doc,
-              itemSchema as ObjectSchemaType,
-              itemPath
-            )
-            const arrayMember = {
-              path: itemPath,
-              name: item._key,
-              schemaType: itemSchema,
-              value: item,
-            }
-            arrayPaths = [...arrayPaths, arrayMember, ...innerFields]
-          }
-        }
-      }
-
-      return [...acc, thisFieldWithPath, ...arrayPaths]
-    }
-
-    return [...acc, thisFieldWithPath]
-  }, [])
-}

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,
-})