@sanity/document-internationalization 4.1.1 → 5.0.1

package/src/components/LanguageOption.tsx

@@ -1,259 +0,0 @@
-import {AddIcon, CheckmarkIcon, SplitVerticalIcon} from '@sanity/icons'
-import {
-  Badge,
-  Box,
-  Button,
-  Flex,
-  Spinner,
-  Text,
-  Tooltip,
-  useToast,
-} from '@sanity/ui'
-import {uuid} from '@sanity/uuid'
-import {useCallback, useEffect, useState} from 'react'
-import {type ObjectSchemaType, type SanityDocument, useClient} from 'sanity'
-
-import {METADATA_SCHEMA_NAME} from '../constants'
-import {useOpenInNewPane} from '../hooks/useOpenInNewPane'
-import type {
-  Language,
-  Metadata,
-  MetadataDocument,
-  TranslationReference,
-} from '../types'
-import {createReference} from '../utils/createReference'
-import {removeExcludedPaths} from '../utils/excludePaths'
-import {useDocumentInternationalizationContext} from './DocumentInternationalizationContext'
-
-type LanguageOptionProps = {
-  language: Language
-  schemaType: ObjectSchemaType
-  documentId: string
-  disabled: boolean
-  current: boolean
-  source: SanityDocument | null
-  metadataId: string | null
-  metadata?: Metadata | null
-  sourceLanguageId?: string
-}
-
-export default function LanguageOption(props: LanguageOptionProps) {
-  const {
-    language,
-    schemaType,
-    documentId,
-    current,
-    source,
-    sourceLanguageId,
-    metadata,
-    metadataId,
-  } = props
-  /* When the user has clicked the Create button, the button should be disabled
-   * to prevent double-clicks from firing onCreate twice. This creates duplicate
-   * translation metadata entries, which editors will not be able to delete */
-  const [userHasClicked, setUserHasClicked] = useState(false)
-  const disabled =
-    props.disabled ||
-    userHasClicked ||
-    current ||
-    !source ||
-    !sourceLanguageId ||
-    !metadataId
-  const translation: TranslationReference | undefined = metadata?.translations
-    .length
-    ? metadata.translations.find((t) => t._key === language.id)
-    : undefined
-  const {apiVersion, languageField, weakReferences, callback} =
-    useDocumentInternationalizationContext()
-  const client = useClient({apiVersion})
-  const toast = useToast()
-
-  const open = useOpenInNewPane(translation?.value?._ref, schemaType.name)
-  const handleOpen = useCallback(() => open(), [open])
-
-  /* Once a translation has been created, reset the userHasClicked state to false
-   * so they can click on it to navigate to the translation. If a translation already
-   * existed when this component was mounted, this will have no effect. */
-  const hasTranslation = Boolean(translation)
-  useEffect(() => {
-    setUserHasClicked(false)
-  }, [hasTranslation])
-
-  const handleCreate = useCallback(async () => {
-    if (!source) {
-      throw new Error(`Cannot create translation without source document`)
-    }
-
-    if (!sourceLanguageId) {
-      throw new Error(`Cannot create translation without source language ID`)
-    }
-
-    if (!metadataId) {
-      throw new Error(`Cannot create translation without a metadata ID`)
-    }
-    /* Disable the create button while this request is pending */
-    setUserHasClicked(true)
-
-    const transaction = client.transaction()
-
-    // 1. Duplicate source document
-    const newTranslationDocumentId = uuid()
-    let newTranslationDocument = {
-      ...source,
-      _id: `drafts.${newTranslationDocumentId}`,
-      // 2. Update language of the translation
-      [languageField]: language.id,
-    }
-
-    // Remove fields / paths we don't want to duplicate
-    newTranslationDocument = removeExcludedPaths(
-      newTranslationDocument,
-      schemaType
-    ) as SanityDocument
-
-    transaction.create(newTranslationDocument)
-
-    // 3. Maybe create the metadata document
-    const sourceReference = createReference(
-      sourceLanguageId,
-      documentId,
-      schemaType.name,
-      !weakReferences
-    )
-    const newTranslationReference = createReference(
-      language.id,
-      newTranslationDocumentId,
-      schemaType.name,
-      !weakReferences
-    )
-    const newMetadataDocument: MetadataDocument = {
-      _id: metadataId,
-      _type: METADATA_SCHEMA_NAME,
-      schemaTypes: [schemaType.name],
-      translations: [sourceReference],
-    }
-
-    transaction.createIfNotExists(newMetadataDocument)
-
-    // 4. Patch translation to metadata document
-    // Note: If the document was only just created in the operation above
-    // This patch operation will have no effect
-    const metadataPatch = client
-      .patch(metadataId)
-      .setIfMissing({translations: [sourceReference]})
-      .insert(`after`, `translations[-1]`, [newTranslationReference])
-
-    transaction.patch(metadataPatch)
-
-    // 5. Commit!
-    transaction
-      .commit()
-      .then(() => {
-        const metadataExisted = Boolean(metadata?._createdAt)
-
-        callback?.({
-          client,
-          sourceLanguageId,
-          sourceDocument: source,
-          newDocument: newTranslationDocument,
-          destinationLanguageId: language.id,
-          metaDocumentId: metadataId,
-        }).catch((err) => {
-          toast.push({
-            status: 'error',
-            title: `Callback`,
-            description: `Error while running callback - ${err}.`,
-          })
-        })
-
-        return toast.push({
-          status: 'success',
-          title: `Created "${language.title}" translation`,
-          description: metadataExisted
-            ? `Updated Translations Metadata`
-            : `Created Translations Metadata`,
-        })
-      })
-      .catch((err) => {
-        console.error(err)
-
-        /* Re-enable the create button if there was an error */
-        setUserHasClicked(false)
-
-        return toast.push({
-          status: 'error',
-          title: `Error creating translation`,
-          description: err.message,
-        })
-      })
-  }, [
-    client,
-    documentId,
-    language.id,
-    language.title,
-    languageField,
-    metadata?._createdAt,
-    metadataId,
-    schemaType,
-    source,
-    sourceLanguageId,
-    toast,
-    weakReferences,
-    callback,
-  ])
-
-  let message
-
-  if (current) {
-    message = `Current document`
-  } else if (translation) {
-    message = `Open ${language.title} translation`
-  } else if (!translation) {
-    message = `Create new ${language.title} translation`
-  }
-
-  return (
-    <Tooltip
-      animate
-      content={
-        <Box padding={2}>
-          <Text muted size={1}>
-            {message}
-          </Text>
-        </Box>
-      }
-      fallbackPlacements={['right', 'left']}
-      placement="top"
-      portal
-    >
-      <Button
-        onClick={translation ? handleOpen : handleCreate}
-        mode={current && disabled ? `default` : `bleed`}
-        disabled={disabled}
-      >
-        <Flex gap={3} align="center">
-          {disabled && !current ? (
-            <Spinner />
-          ) : (
-            <Text size={2}>
-              {/* eslint-disable-next-line no-nested-ternary */}
-              {translation ? (
-                <SplitVerticalIcon />
-              ) : current ? (
-                <CheckmarkIcon />
-              ) : (
-                <AddIcon />
-              )}
-            </Text>
-          )}
-          <Box flex={1}>
-            <Text>{language.title}</Text>
-          </Box>
-          <Badge tone={disabled || current ? `default` : `primary`}>
-            {language.id}
-          </Badge>
-        </Flex>
-      </Button>
-    </Tooltip>
-  )
-}

package/src/components/LanguagePatch.tsx

@@ -1,67 +0,0 @@
-import {EditIcon} from '@sanity/icons'
-import {Badge, Box, Button, Flex, Text, useToast} from '@sanity/ui'
-import {useCallback} from 'react'
-import {type SanityDocument, useClient} from 'sanity'
-
-import type {Language} from '../types'
-import {useDocumentInternationalizationContext} from './DocumentInternationalizationContext'
-
-type LanguagePatchProps = {
-  language: Language
-  source: SanityDocument | null
-  disabled: boolean
-}
-
-export default function LanguagePatch(props: LanguagePatchProps) {
-  const {language, source} = props
-  const {apiVersion, languageField} = useDocumentInternationalizationContext()
-  const disabled = props.disabled || !source
-  const client = useClient({apiVersion})
-  const toast = useToast()
-
-  const handleClick = useCallback(() => {
-    if (!source) {
-      throw new Error(`Cannot patch missing document`)
-    }
-
-    const currentId = source._id
-
-    client
-      .patch(currentId)
-      .set({[languageField]: language.id})
-      .commit()
-      .then(() => {
-        toast.push({
-          title: `Set document language to ${language.title}`,
-          status: `success`,
-        })
-      })
-      .catch((err) => {
-        console.error(err)
-
-        return toast.push({
-          title: `Failed to set document language to ${language.title}`,
-          status: `error`,
-        })
-      })
-  }, [source, client, languageField, language, toast])
-
-  return (
-    <Button
-      mode="bleed"
-      onClick={handleClick}
-      disabled={disabled}
-      justify="flex-start"
-    >
-      <Flex gap={3} align="center">
-        <Text size={2}>
-          <EditIcon />
-        </Text>
-        <Box flex={1}>
-          <Text>{language.title}</Text>
-        </Box>
-        <Badge>{language.id}</Badge>
-      </Flex>
-    </Button>
-  )
-}

package/src/components/OptimisticallyStrengthen/ReferencePatcher.tsx

@@ -1,50 +0,0 @@
-import {useEffect} from 'react'
-import {PatchEvent, unset, useClient, useEditState} from 'sanity'
-import {useDocumentPane} from 'sanity/structure'
-
-import {API_VERSION} from '../../constants'
-import type {TranslationReference} from '../../types'
-
-type ReferencePatcherProps = {
-  translation: TranslationReference
-  documentType: string
-  metadataId: string
-}
-
-// For every reference, check if it is published, and if so, strengthen the reference
-export default function ReferencePatcher(props: ReferencePatcherProps) {
-  const {translation, documentType, metadataId} = props
-  const editState = useEditState(translation.value._ref, documentType)
-  const client = useClient({apiVersion: API_VERSION})
-  const {onChange} = useDocumentPane()
-
-  useEffect(() => {
-    if (
-      // We have a reference
-      translation.value._ref &&
-      // It's still weak and not-yet-strengthened
-      translation.value._weak &&
-      // We also want to keep this check because maybe the user *configured* weak refs
-      translation.value._strengthenOnPublish &&
-      // The referenced document has just been published
-      !editState.draft &&
-      editState.published &&
-      editState.ready
-    ) {
-      const referencePathBase = [
-        'translations',
-        {_key: translation._key},
-        'value',
-      ]
-
-      onChange(
-        new PatchEvent([
-          unset([...referencePathBase, '_weak']),
-          unset([...referencePathBase, '_strengthenOnPublish']),
-        ])
-      )
-    }
-  }, [translation, editState, metadataId, client, onChange])
-
-  return null
-}

package/src/components/OptimisticallyStrengthen/index.tsx

@@ -1,34 +0,0 @@
-import type {TranslationReference} from '../../types'
-import ReferencePatcher from './ReferencePatcher'
-
-type OptimisticallyStrengthenProps = {
-  translations: TranslationReference[]
-  metadataId: string
-}
-
-// There's no good reason to leave published references as weak
-// So this component will run on every render and strengthen them
-export default function OptimisticallyStrengthen(
-  props: OptimisticallyStrengthenProps
-) {
-  const {translations = [], metadataId} = props
-
-  if (!translations.length) {
-    return null
-  }
-
-  return (
-    <>
-      {translations.map((translation) =>
-        translation.value._strengthenOnPublish?.type ? (
-          <ReferencePatcher
-            key={translation._key}
-            translation={translation}
-            documentType={translation.value._strengthenOnPublish.type}
-            metadataId={metadataId}
-          />
-        ) : null
-      )}
-    </>
-  )
-}

package/src/components/Warning.tsx

@@ -1,18 +0,0 @@
-import {Card, Flex, Text} from '@sanity/ui'
-import type {PropsWithChildren} from 'react'
-
-import ConstrainedBox from './ConstrainedBox'
-
-export default function Warning({children}: PropsWithChildren) {
-  return (
-    <Card tone="caution" padding={3}>
-      <Flex justify="center">
-        <ConstrainedBox>
-          <Text size={1} align="center">
-            {children}
-          </Text>
-        </ConstrainedBox>
-      </Flex>
-    </Card>
-  )
-}

package/src/constants.ts

@@ -1,16 +0,0 @@
-import type {PluginConfigContext} from './types'
-
-export const METADATA_SCHEMA_NAME = `translation.metadata`
-export const TRANSLATIONS_ARRAY_NAME = `translations`
-export const API_VERSION = `2025-02-19`
-export const DEFAULT_CONFIG: PluginConfigContext = {
-  supportedLanguages: [],
-  schemaTypes: [],
-  languageField: `language`,
-  weakReferences: false,
-  bulkPublish: false,
-  metadataFields: [],
-  apiVersion: API_VERSION,
-  allowCreateMetaDoc: false,
-  callback: null,
-}

package/src/hooks/useLanguageMetadata.tsx

@@ -1,26 +0,0 @@
-import {useListeningQuery} from 'sanity-plugin-utils'
-
-import {METADATA_SCHEMA_NAME} from '../constants'
-import type {Metadata} from '../types'
-
-// Using references() seemed less reliable for updating the listener
-// results than querying raw values in the array
-// AFAIK: references is _faster_ when querying with GROQ
-// const query = `*[_type == $translationSchema && references($id)]`
-const query = `*[_type == $translationSchema && $id in translations[].value._ref]{
-  _id,
-  _createdAt,
-  translations
-}`
-
-export function useTranslationMetadata(id: string): {
-  data: Metadata[] | null
-  loading: boolean
-  error: boolean | unknown | ProgressEvent
-} {
-  const {data, loading, error} = useListeningQuery<Metadata[]>(query, {
-    params: {id, translationSchema: METADATA_SCHEMA_NAME},
-  })
-
-  return {data: data as Metadata[] | null, loading, error}
-}

package/src/hooks/useOpenInNewPane.tsx

@@ -1,33 +0,0 @@
-import {useCallback, useContext} from 'react'
-import {RouterContext} from 'sanity/router'
-import {usePaneRouter} from 'sanity/structure'
-
-export function useOpenInNewPane(id?: string | null, type?: string) {
-  const routerContext = useContext(RouterContext)
-  const {routerPanesState, groupIndex} = usePaneRouter()
-
-  const openInNewPane = useCallback(() => {
-    if (!routerContext || !id || !type) {
-      return
-    }
-
-    // No panes open, function might be called outside Structure
-    if (!routerPanesState.length) {
-      routerContext.navigateIntent('edit', {id, type})
-      return
-    }
-
-    const panes = [...routerPanesState]
-    panes.splice(groupIndex + 1, 0, [
-      {
-        id: id,
-        params: {type},
-      },
-    ])
-
-    const href = routerContext.resolvePathFromState({panes})
-    routerContext.navigateUrl({path: href})
-  }, [id, type, routerContext, routerPanesState, groupIndex])
-
-  return openInNewPane
-}

package/src/i18n/index.ts

@@ -1,21 +0,0 @@
-import {defineLocaleResourceBundle} from 'sanity'
-
-/**
- * The locale namespace for the document internationalization plugin.
- *
- * @public
- */
-export const documenti18nLocaleNamespace =
-  'document-internationalization' as const
-
-/**
- * The default locale bundle for the document internationalization plugin, which is US English.
- *
- * @internal
- */
-export const documentInternationalizationUsEnglishLocaleBundle =
-  defineLocaleResourceBundle({
-    locale: 'en-US',
-    namespace: documenti18nLocaleNamespace,
-    resources: () => import('./resources'),
-  })

package/src/i18n/resources.ts

@@ -1,7 +0,0 @@
-export default {
-  'action.duplicate.label': 'Duplicate with translations',
-  'action.duplicate.disabled.missing-metadata':
-    'The document cannot be duplicated because the metadata document is missing',
-  'action.duplicate.disabled.multiple-metadata':
-    'The document cannot be duplicated because there are multiple metadata documents',
-}

package/src/index.ts

@@ -1,6 +0,0 @@
-export {DeleteTranslationAction} from './actions/DeleteTranslationAction'
-export {DuplicateWithTranslationsAction} from './actions/DuplicateWithTranslationsAction'
-export {useDocumentInternationalizationContext} from './components/DocumentInternationalizationContext'
-export {DocumentInternationalizationMenu} from './components/DocumentInternationalizationMenu'
-export {documentInternationalization} from './plugin'
-export * from './types'