@sanity/document-internationalization 4.1.1 → 5.0.1

package/src/actions/DuplicateWithTranslationsAction.tsx

@@ -1,251 +0,0 @@
-import {CopyIcon} from '@sanity/icons'
-import {useToast} from '@sanity/ui'
-import {uuid} from '@sanity/uuid'
-import {useCallback, useMemo, useState} from 'react'
-import {filter, firstValueFrom} from 'rxjs'
-import {
-  DEFAULT_STUDIO_CLIENT_OPTIONS,
-  type DocumentActionComponent,
-  type Id,
-  InsufficientPermissionsMessage,
-  type PatchOperations,
-  useClient,
-  useCurrentUser,
-  useDocumentOperation,
-  useDocumentPairPermissions,
-  useDocumentStore,
-  useTranslation,
-} from 'sanity'
-import {useRouter} from 'sanity/router'
-import {structureLocaleNamespace} from 'sanity/structure'
-
-import {METADATA_SCHEMA_NAME, TRANSLATIONS_ARRAY_NAME} from '../constants'
-import {useTranslationMetadata} from '../hooks/useLanguageMetadata'
-import {documenti18nLocaleNamespace} from '../i18n'
-
-const DISABLED_REASON_KEY = {
-  METADATA_NOT_FOUND: 'action.duplicate.disabled.missing-metadata',
-  MULTIPLE_METADATA: 'action.duplicate.disabled.multiple-metadata',
-  NOTHING_TO_DUPLICATE: 'action.duplicate.disabled.nothing-to-duplicate',
-  NOT_READY: 'action.duplicate.disabled.not-ready',
-}
-
-export const DuplicateWithTranslationsAction: DocumentActionComponent = ({
-  id,
-  type,
-  onComplete,
-}) => {
-  const documentStore = useDocumentStore()
-  const {duplicate} = useDocumentOperation(id, type)
-  const {navigateIntent} = useRouter()
-  const [isDuplicating, setDuplicating] = useState(false)
-  const [permissions, isPermissionsLoading] = useDocumentPairPermissions({
-    id,
-    type,
-    permission: 'duplicate',
-  })
-  const {data, loading: isMetadataDocumentLoading} = useTranslationMetadata(id)
-  const hasOneMetadataDocument = useMemo(() => {
-    return Array.isArray(data) && data.length <= 1
-  }, [data])
-  const metadataDocument = Array.isArray(data) && data.length ? data[0] : null
-  const client = useClient(DEFAULT_STUDIO_CLIENT_OPTIONS)
-  const toast = useToast()
-  const {t: s} = useTranslation(structureLocaleNamespace)
-  const {t: d} = useTranslation(documenti18nLocaleNamespace)
-  const currentUser = useCurrentUser()
-
-  const handle = useCallback(async () => {
-    setDuplicating(true)
-
-    try {
-      if (!metadataDocument) {
-        throw new Error('Metadata document not found')
-      }
-
-      // 1. Duplicate the document and its localized versions
-      const translations = new Map<string, Id>()
-      await Promise.all(
-        metadataDocument[TRANSLATIONS_ARRAY_NAME].map(async (translation) => {
-          const dupeId = uuid()
-          const locale = translation._key
-          const docId = translation.value?._ref
-
-          if (!docId) {
-            throw new Error('Translation document not found')
-          }
-
-          const {duplicate: duplicateTranslation} = await firstValueFrom(
-            documentStore.pair
-              .editOperations(docId, type)
-              .pipe(filter((op) => op.duplicate.disabled !== 'NOT_READY'))
-          )
-
-          if (duplicateTranslation.disabled) {
-            throw new Error('Cannot duplicate document')
-          }
-
-          const duplicateTranslationSuccess = firstValueFrom(
-            documentStore.pair
-              .operationEvents(docId, type)
-              .pipe(filter((e) => e.op === 'duplicate' && e.type === 'success'))
-          )
-          duplicateTranslation.execute(dupeId)
-          await duplicateTranslationSuccess
-
-          translations.set(locale, dupeId)
-        })
-      )
-
-      // 2. Duplicate the metadata document
-      const {duplicate: duplicateMetadata} = await firstValueFrom(
-        documentStore.pair
-          .editOperations(metadataDocument._id, METADATA_SCHEMA_NAME)
-          .pipe(filter((op) => op.duplicate.disabled !== 'NOT_READY'))
-      )
-
-      if (duplicateMetadata.disabled) {
-        throw new Error('Cannot duplicate document')
-      }
-
-      const duplicateMetadataSuccess = firstValueFrom(
-        documentStore.pair
-          .operationEvents(metadataDocument._id, METADATA_SCHEMA_NAME)
-          .pipe(filter((e) => e.op === 'duplicate' && e.type === 'success'))
-      )
-      const dupeId = uuid()
-      duplicateMetadata.execute(dupeId)
-      await duplicateMetadataSuccess
-
-      // 3. Patch the duplicated metadata document to update the references
-      // TODO: use document store
-      // const {patch: patchMetadata} = await firstValueFrom(
-      //   documentStore.pair
-      //     .editOperations(dupeId, METADATA_SCHEMA_NAME)
-      //     .pipe(filter((op) => op.patch.disabled !== 'NOT_READY'))
-      // )
-
-      // if (patchMetadata.disabled) {
-      //   throw new Error('Cannot patch document')
-      // }
-
-      // await firstValueFrom(
-      //   documentStore.pair
-      //     .consistencyStatus(dupeId, METADATA_SCHEMA_NAME)
-      //     .pipe(filter((isConsistant) => isConsistant))
-      // )
-
-      // const patchMetadataSuccess = firstValueFrom(
-      //   documentStore.pair
-      //     .operationEvents(dupeId, METADATA_SCHEMA_NAME)
-      //     .pipe(filter((e) => e.op === 'patch' && e.type === 'success'))
-      // )
-
-      const patch: PatchOperations = {
-        set: Object.fromEntries(
-          Array.from(translations.entries()).map(([locale, documentId]) => [
-            `${TRANSLATIONS_ARRAY_NAME}[_key == "${locale}"].value._ref`,
-            documentId,
-          ])
-        ),
-      }
-
-      // patchMetadata.execute([patch])
-      // await patchMetadataSuccess
-      await client.transaction().patch(dupeId, patch).commit()
-
-      // 4. Navigate to the duplicated document
-      navigateIntent('edit', {
-        id: Array.from(translations.values()).at(0),
-        type,
-      })
-
-      onComplete()
-    } catch (error) {
-      console.error(error)
-      toast.push({
-        status: 'error',
-        title: 'Error duplicating document',
-        description:
-          error instanceof Error
-            ? error.message
-            : 'Failed to duplicate document',
-      })
-    } finally {
-      setDuplicating(false)
-    }
-  }, [
-    client,
-    documentStore.pair,
-    metadataDocument,
-    navigateIntent,
-    onComplete,
-    toast,
-    type,
-  ])
-
-  return useMemo(() => {
-    if (!isPermissionsLoading && !permissions?.granted) {
-      return {
-        icon: CopyIcon,
-        disabled: true,
-        label: d('action.duplicate.label'),
-        title: (
-          <InsufficientPermissionsMessage
-            context="duplicate-document"
-            currentUser={currentUser}
-          />
-        ),
-      }
-    }
-
-    if (!isMetadataDocumentLoading && !metadataDocument) {
-      return {
-        icon: CopyIcon,
-        disabled: true,
-        label: d('action.duplicate.label'),
-        title: d(DISABLED_REASON_KEY.METADATA_NOT_FOUND),
-      }
-    }
-
-    if (!hasOneMetadataDocument) {
-      return {
-        icon: CopyIcon,
-        disabled: true,
-        label: d('action.duplicate.label'),
-        title: d(DISABLED_REASON_KEY.MULTIPLE_METADATA),
-      }
-    }
-
-    return {
-      icon: CopyIcon,
-      disabled:
-        isDuplicating ||
-        Boolean(duplicate.disabled) ||
-        isPermissionsLoading ||
-        isMetadataDocumentLoading,
-      label: isDuplicating
-        ? s('action.duplicate.running.label')
-        : d('action.duplicate.label'),
-      title: duplicate.disabled
-        ? s(DISABLED_REASON_KEY[duplicate.disabled])
-        : '',
-      onHandle: handle,
-    }
-  }, [
-    currentUser,
-    duplicate.disabled,
-    handle,
-    hasOneMetadataDocument,
-    isDuplicating,
-    isMetadataDocumentLoading,
-    isPermissionsLoading,
-    metadataDocument,
-    permissions?.granted,
-    s,
-    d,
-  ])
-}
-
-DuplicateWithTranslationsAction.action = 'duplicate'
-DuplicateWithTranslationsAction.displayName = 'DuplicateWithTranslationsAction'

package/src/badges/index.tsx

@@ -1,27 +0,0 @@
-import type {DocumentBadgeDescription, DocumentBadgeProps} from 'sanity'
-
-import {useDocumentInternationalizationContext} from '../components/DocumentInternationalizationContext'
-
-export function LanguageBadge(
-  props: DocumentBadgeProps
-): DocumentBadgeDescription | null {
-  const source = props?.draft || props?.published
-  const {languageField, supportedLanguages} =
-    useDocumentInternationalizationContext()
-  const languageId = source?.[languageField]
-
-  if (!languageId) {
-    return null
-  }
-
-  const language = Array.isArray(supportedLanguages)
-    ? supportedLanguages.find((l) => l.id === languageId)
-    : null
-
-  // Currently we only show the language id if the supportedLanguages are async
-  return {
-    label: language?.id ?? String(languageId),
-    title: language?.title ?? undefined,
-    color: `primary`,
-  }
-}

package/src/components/BulkPublish/DocumentCheck.tsx

@@ -1,90 +0,0 @@
-import {Card, Spinner} from '@sanity/ui'
-import {useEffect, useMemo} from 'react'
-import {Preview, useEditState, useSchema, useValidationStatus} from 'sanity'
-
-type DocumentCheckProps = {
-  id: string
-  onCheckComplete: (id: string) => void
-  addInvalidId: (id: string) => void
-  removeInvalidId: (id: string) => void
-  addDraftId: (id: string) => void
-  removeDraftId: (id: string) => void
-}
-
-// Check if the document has a draft
-// Check if that draft is valid
-// Report back to parent that it can be added to bulk publish
-export default function DocumentCheck(props: DocumentCheckProps) {
-  const {
-    id,
-    onCheckComplete,
-    addInvalidId,
-    removeInvalidId,
-    addDraftId,
-    removeDraftId,
-  } = props
-  const editState = useEditState(id, ``)
-  const {isValidating, validation} = useValidationStatus(id, ``)
-  const schema = useSchema()
-
-  const validationHasErrors = useMemo(() => {
-    return (
-      !isValidating &&
-      validation.length > 0 &&
-      validation.some((item) => item.level === 'error')
-    )
-  }, [isValidating, validation])
-
-  useEffect(() => {
-    if (validationHasErrors) {
-      addInvalidId(id)
-    } else {
-      removeInvalidId(id)
-    }
-
-    if (editState.draft) {
-      addDraftId(id)
-    } else {
-      removeDraftId(id)
-    }
-
-    if (!isValidating) {
-      onCheckComplete(id)
-    }
-  }, [
-    addDraftId,
-    addInvalidId,
-    editState.draft,
-    id,
-    isValidating,
-    onCheckComplete,
-    removeDraftId,
-    removeInvalidId,
-    validationHasErrors,
-  ])
-
-  // We only care about drafts
-  if (!editState.draft) {
-    return null
-  }
-
-  const schemaType = schema.get(editState.draft._type)
-
-  return (
-    <Card
-      border
-      padding={2}
-      tone={validationHasErrors ? `critical` : `positive`}
-    >
-      {editState.draft && schemaType ? (
-        <Preview
-          layout="default"
-          value={editState.draft}
-          schemaType={schemaType}
-        />
-      ) : (
-        <Spinner />
-      )}
-    </Card>
-  )
-}

package/src/components/BulkPublish/Info.tsx

@@ -1,28 +0,0 @@
-import {InfoOutlineIcon} from '@sanity/icons'
-import {Box, Stack, Text} from '@sanity/ui'
-
-import InfoIcon from './InfoIcon'
-
-export default function Info() {
-  return (
-    <InfoIcon icon={InfoOutlineIcon} tone="primary">
-      <Stack padding={3} space={4} style={{maxWidth: 250}}>
-        <Box>
-          <Text size={1}>Bulk publishing uses the Scheduling API.</Text>
-        </Box>
-        <Box>
-          <Text size={1}>
-            Customized Document Actions in the Studio will not execute. Webhooks
-            will execute.
-          </Text>
-        </Box>
-        <Box>
-          <Text size={1}>
-            Validation is checked before rendering the button below, but the
-            Scheduling API will not check for – or enforce – validation.
-          </Text>
-        </Box>
-      </Stack>
-    </InfoIcon>
-  )
-}

package/src/components/BulkPublish/InfoIcon.tsx

@@ -1,34 +0,0 @@
-import {Box, type ButtonTone, Text, Tooltip} from '@sanity/ui'
-import type {ComponentType, PropsWithChildren} from 'react'
-import {TextWithTone} from 'sanity'
-
-type InfoIconProps = PropsWithChildren & {
-  icon: ComponentType
-  tone: ButtonTone
-  text?: string
-}
-
-export default function InfoIcon(props: InfoIconProps) {
-  const {text, icon, tone, children} = props
-  const Icon = icon
-
-  return (
-    <Tooltip
-      animate
-      portal
-      content={
-        children ? (
-          <>{children}</>
-        ) : (
-          <Box padding={2}>
-            <Text size={1}>{text}</Text>
-          </Box>
-        )
-      }
-    >
-      <TextWithTone tone={tone} size={1}>
-        <Icon />
-      </TextWithTone>
-    </Tooltip>
-  )
-}

package/src/components/BulkPublish/index.tsx

@@ -1,181 +0,0 @@
-import {Button, Card, Dialog, Inline, Stack, Text, useToast} from '@sanity/ui'
-import {useCallback, useState} from 'react'
-import {TextWithTone, useClient, useWorkspace} from 'sanity'
-
-import {API_VERSION} from '../../constants'
-import type {TranslationReference} from '../../types'
-import DocumentCheck from './DocumentCheck'
-import Info from './Info'
-
-export type BulkPublishProps = {
-  translations: TranslationReference[]
-}
-
-// A root-level component with UI for hitting the Publishing API
-export default function BulkPublish(props: BulkPublishProps) {
-  const {translations} = props
-  const client = useClient({apiVersion: API_VERSION})
-  const {projectId, dataset} = useWorkspace()
-  const toast = useToast()
-  const [invalidIds, setInvalidIds] = useState<string[] | null>(null)
-  const [checkedIds, setCheckedIds] = useState<string[]>([])
-
-  const onCheckComplete = useCallback((id: string) => {
-    setCheckedIds((ids) => Array.from(new Set([...ids, id])))
-  }, [])
-
-  // Handle dialog
-  const [open, setOpen] = useState(false)
-  const onOpen = useCallback(() => setOpen(true), [])
-  const onClose = useCallback(() => setOpen(false), [])
-
-  const addInvalidId = useCallback((id: string) => {
-    setInvalidIds((ids) => (ids ? Array.from(new Set([...ids, id])) : [id]))
-  }, [])
-
-  const removeInvalidId = useCallback((id: string) => {
-    setInvalidIds((ids) => (ids ? ids.filter((i) => i !== id) : []))
-  }, [])
-
-  const [draftIds, setDraftIds] = useState<string[]>([])
-
-  const addDraftId = useCallback((id: string) => {
-    setDraftIds((ids) => Array.from(new Set([...ids, id])))
-  }, [])
-
-  const removeDraftId = useCallback((id: string) => {
-    setDraftIds((ids) => ids.filter((i) => i !== id))
-  }, [])
-
-  const handleBulkPublish = useCallback(() => {
-    const body = translations.map((translation) => ({
-      documentId: translation.value._ref,
-    }))
-    client
-      .request({
-        uri: `/publish/${projectId}/${dataset}`,
-        method: 'POST',
-        body,
-      })
-      .then(() => {
-        toast.push({
-          status: 'success',
-          title: 'Success',
-          description: 'Bulk publish complete',
-        })
-      })
-      .catch((err) => {
-        console.error(err)
-        toast.push({
-          status: 'error',
-          title: 'Error',
-          description: 'Bulk publish failed',
-        })
-      })
-  }, [translations, client, projectId, dataset, toast])
-
-  const disabled =
-    // Not all documents have been checked
-    checkedIds.length !== translations.length ||
-    // Some document(s) are invalid
-    Boolean(invalidIds && invalidIds?.length > 0) ||
-    // No documents are drafts
-    !draftIds.length
-
-  return translations?.length > 0 ? (
-    <Card padding={4} border radius={2}>
-      <Stack space={3}>
-        <Inline space={3}>
-          <Text weight="bold" size={1}>
-            Bulk publishing
-          </Text>
-          <Info />
-        </Inline>
-
-        <Stack>
-          <Button
-            onClick={onOpen}
-            text="Prepare bulk publishing"
-            mode="ghost"
-          />
-        </Stack>
-
-        {open && (
-          <Dialog
-            animate
-            header="Bulk publishing"
-            id="bulk-publish-dialog"
-            onClose={onClose}
-            zOffset={1000}
-            width={3}
-          >
-            <Stack space={4} padding={4}>
-              {draftIds.length > 0 ? (
-                <Stack space={2}>
-                  <Text size={1}>
-                    There{' '}
-                    {draftIds.length === 1
-                      ? `is 1 draft document`
-                      : `are ${draftIds.length} draft documents`}
-                    .
-                  </Text>
-                  {invalidIds && invalidIds.length > 0 ? (
-                    <TextWithTone tone="critical" size={1}>
-                      {invalidIds && invalidIds.length === 1
-                        ? `1 draft document has`
-                        : `${
-                            invalidIds && invalidIds.length
-                          } draft documents have`}{' '}
-                      validation issues that must addressed first
-                    </TextWithTone>
-                  ) : (
-                    <TextWithTone tone="positive" size={1}>
-                      All drafts are valid and can be bulk published
-                    </TextWithTone>
-                  )}
-                </Stack>
-              ) : null}
-
-              <Stack space={1}>
-                {translations
-                  .filter((translation) => translation?.value?._ref)
-                  .map((translation) => (
-                    <DocumentCheck
-                      key={translation._key}
-                      id={translation.value._ref}
-                      onCheckComplete={onCheckComplete}
-                      addInvalidId={addInvalidId}
-                      removeInvalidId={removeInvalidId}
-                      addDraftId={addDraftId}
-                      removeDraftId={removeDraftId}
-                    />
-                  ))}
-              </Stack>
-              {draftIds.length > 0 ? (
-                <Button
-                  mode="ghost"
-                  tone={
-                    invalidIds && invalidIds?.length > 0
-                      ? 'caution'
-                      : 'positive'
-                  }
-                  text={
-                    draftIds.length === 1
-                      ? `Publish draft document`
-                      : `Bulk publish ${draftIds.length} draft documents`
-                  }
-                  onClick={handleBulkPublish}
-                  disabled={disabled}
-                />
-              ) : (
-                <Text muted size={1}>
-                  No draft documents to publish
-                </Text>
-              )}
-            </Stack>
-          </Dialog>
-        )}
-      </Stack>
-    </Card>
-  ) : null
-}

package/src/components/ConstrainedBox.tsx

@@ -1,6 +0,0 @@
-import {Box} from '@sanity/ui'
-import {styled} from 'styled-components'
-
-export default styled(Box)`
-  max-width: 280px;
-`

package/src/components/DeleteTranslationDialog/DocumentPreview.tsx

@@ -1,19 +0,0 @@
-import {Preview, useSchema} from 'sanity'
-import {Feedback} from 'sanity-plugin-utils'
-
-type DocumentPreviewProps = {
-  value: unknown
-  type: string
-}
-
-// Wrapper of Preview just so that the schema type is satisfied by schema.get()
-export default function DocumentPreview(props: DocumentPreviewProps) {
-  const schema = useSchema()
-
-  const schemaType = schema.get(props.type)
-  if (!schemaType) {
-    return <Feedback tone="critical" title="Schema type not found" />
-  }
-
-  return <Preview value={props.value} schemaType={schemaType} />
-}