@sanity/document-internationalization 1.0.0 → 1.0.1

package/src/utils/getBaseLanguage.ts

@@ -0,0 +1,6 @@
+import {ILanguageObject} from '../types'
+
+export const getBaseLanguage = (langs: ILanguageObject[], base?: string) => {
+  if (base) return langs.find((l) => l.id === base) || null
+  return langs.length > 0 ? langs[0] : null
+}

package/src/utils/getFlag.ts

@@ -0,0 +1,38 @@
+import {getEmojiFlag} from '@cprecioso/country-flag-emoji'
+import {SupportedEmojiFlagCodes} from '../constants'
+
+// Get flag from a valid country code
+export const getFlag = (code = ``): string => {
+  if (!code) {
+    return ``
+  }
+
+  const flagCode = getFlagCode(code)
+
+  if (!SupportedEmojiFlagCodes.includes(flagCode.toUpperCase())) {
+    return ``
+  }
+
+  const emoji = getEmojiFlag(flagCode)
+
+  return emoji
+}
+
+// Convert some language codes to country codes
+export const getFlagCode = (code = ``): string => {
+  if (!code) {
+    return ``
+  }
+
+  switch (code.toLocaleLowerCase()) {
+    // Return :flag-gb: for English
+    case `en`:
+      return `gb`
+    // Return :flag-al: (Albania) for `sq` language code
+    case `sq`:
+      return `al`
+
+    default:
+      return code
+  }
+}

package/src/utils/getLanguageFromDocument.ts

@@ -0,0 +1,9 @@
+import type {SanityDocument} from '@sanity/client'
+import type {ApplyConfigResult} from './applyConfig'
+
+export function getLanguageFromDocument(
+  doc: SanityDocument,
+  config: ApplyConfigResult
+): string | null {
+  return doc?.[config.fieldNames.lang] || config.base || null
+}

package/src/utils/getLanguageFromId.ts

@@ -0,0 +1,13 @@
+import {I18nPrefix, I18nDelimiter} from '../constants'
+
+export const getLanguageFromId = (id: string): string | undefined => {
+  // subpath
+  const rx = new RegExp(`${I18nPrefix}\\.[^.]+\\.([^.]+)`)
+  const match = id.match(rx)
+  if (match && match.length === 2) return match[1]
+
+  // delimiter
+  const split = id.split(I18nDelimiter)
+  if (split.length > 1) return split[1]
+  return undefined
+}

package/src/utils/getLanguagesFromOption.ts

@@ -0,0 +1,40 @@
+import get from 'just-safe-get'
+import type {SanityClient, SanityDocument} from '@sanity/client'
+import {ILanguageObject, ILanguageQuery, TLanguagesOption} from '../types'
+import type {ApplyConfigResult} from '../utils'
+import {normalizeLanguageList} from './normalizeLanguageList'
+
+export const getLanguagesFromOption = async <D extends SanityDocument>(
+  client: SanityClient,
+  config: ApplyConfigResult,
+  langs: TLanguagesOption,
+  document?: D | null
+): Promise<ILanguageObject[]> => {
+  const languages = normalizeLanguageList(
+    await (async () => {
+      if (Array.isArray(langs)) return langs
+      const r = await client.fetch<ILanguageQuery['value'][]>(langs.query)
+      const value = langs.value
+
+      if (typeof value === 'string') return r.map((l) => get(l, value))
+      return r.map((l) => {
+        // @deprecated
+        if ('name' in value) {
+          return {
+            name: get(l, value.name),
+            title: get(l, value.title),
+          }
+        }
+
+        return {
+          id: get(l, value.id),
+          title: get(l, value.title),
+        }
+      })
+    })()
+  )
+  if (config.languagesLoader) {
+    return config.languagesLoader(languages, document ?? undefined)
+  }
+  return languages
+}

package/src/utils/getTranslationsForId.ts

@@ -0,0 +1,39 @@
+import {SanityClient} from '@sanity/client'
+import type {ApplyConfigResult} from '../utils'
+import {I18nDelimiter, IdStructure} from '../constants'
+import {Ti18nDocument} from '../types'
+import {buildDocId} from './buildDocId'
+
+export const getTranslationsFor = async (
+  client: SanityClient,
+  config: ApplyConfigResult,
+  baseDocumentId: string,
+  includeDrafts = false
+): Promise<Ti18nDocument[]> => {
+  if (config.idStructure === IdStructure.DELIMITER) {
+    const segments = baseDocumentId.split('-')
+    segments[segments.length - 1] = `${segments[segments.length - 1]}${I18nDelimiter}*`
+    const documents = await client.fetch<Ti18nDocument[]>(
+      includeDrafts
+        ? '*[_id match $segments]'
+        : `*[_id match $segments && !(_id in path('drafts.**'))]`,
+      {segments}
+    )
+
+    return documents
+      ? documents.filter(
+          (d) =>
+            d._id.startsWith(baseDocumentId) ||
+            (includeDrafts && d._id.startsWith(`drafts.${baseDocumentId}`))
+        )
+      : []
+  }
+  const documents = await client.fetch<Ti18nDocument[]>(
+    includeDrafts ? '*[_id in path($path) || _id in path($draftPath)]' : '*[_id in path($path)]',
+    {
+      path: buildDocId(config, baseDocumentId, '*'),
+      draftPath: `drafts.${buildDocId(config, baseDocumentId, '*')}`,
+    }
+  )
+  return documents ?? []
+}

package/src/utils/index.ts

@@ -0,0 +1,14 @@
+export * from './buildDocId'
+export * from './normalizeLanguageList'
+export * from './getBaseLanguage'
+export * from './useSanityClient'
+export * from './getLanguagesFromOption'
+export * from './getLanguageFromId'
+export * from './getBaseIdFromId'
+export * from './getTranslationsForId'
+export * from './makeObjectKey'
+export * from './createSanityReference'
+export * from './updateIntlFieldsForDocument'
+export * from './serializePath'
+export * from './applyConfig'
+export * from './getLanguageFromDocument'

package/src/utils/makeObjectKey.ts

@@ -0,0 +1,3 @@
+export function makeObjectKey(input: string) {
+  return input.replace(/[^a-zA-Z0-9_]/g, '_')
+}

package/src/utils/normalizeLanguageList.ts

@@ -0,0 +1,26 @@
+import {ILanguageObject} from '../types'
+import {LanguageCultures} from '../constants'
+
+type LanguageConfigObject =
+  | ILanguageObject
+  | (Omit<ILanguageObject, 'id'> & {
+      name: string
+    })
+
+export const normalizeLanguageList = (languages: (string | LanguageConfigObject)[]) =>
+  languages.map<ILanguageObject>((l) => {
+    if (typeof l === 'string') {
+      const langCult = LanguageCultures.find((x) => x.value === l)
+      if (langCult) return {title: langCult.title, id: l}
+      return {title: l, id: l}
+    }
+
+    if ('name' in l) {
+      console.warn(
+        `The "name" field in your language configuration is deprecated, please replace it with "id".`
+      )
+      return {title: l.title, id: l.name}
+    }
+
+    return {title: l.title, id: l.id}
+  })

package/src/utils/serializePath.ts

@@ -0,0 +1,11 @@
+import {Path, isKeyedObject} from 'sanity'
+
+export function serializePath(path: Path): string {
+  return path.reduce<string>((target, part, i) => {
+    const isIndex = typeof part === 'number'
+    const isKey = isKeyedObject(part)
+    const separator = i === 0 ? '' : '.'
+    const add = isIndex || isKey ? '[]' : `${separator}${part}`
+    return `${target}${add}`
+  }, '')
+}

package/src/utils/updateIntlFieldsForDocument.ts

@@ -0,0 +1,79 @@
+import compact from 'lodash/compact'
+import {SanityClient, SanityDocument} from '@sanity/client'
+import {ITranslationRef} from '../types'
+import {ReferenceBehavior} from '../constants'
+import {ApplyConfigResult} from '../utils'
+import {getLanguagesFromOption} from './getLanguagesFromOption'
+import {getBaseLanguage} from './getBaseLanguage'
+import {getTranslationsFor} from './getTranslationsForId'
+import {getBaseIdFromId} from './getBaseIdFromId'
+import {createSanityReference} from './createSanityReference'
+import {getLanguageFromDocument} from './getLanguageFromDocument'
+
+// @TODO make this into a hook so the hook
+// can look up the existance of a base document on its own
+export async function updateIntlFieldsForDocument(
+  client: SanityClient,
+  config: ApplyConfigResult,
+  document: SanityDocument,
+  baseDocument?: SanityDocument
+): Promise<void> {
+  const {_type: type, _id: id} = document
+  const baseDocumentId = getBaseIdFromId(id)
+  const isTranslation = id !== baseDocumentId
+  const fieldName = config.fieldNames.lang
+  const refsFieldName = config.fieldNames.references
+  const baseRefFieldName = config.fieldNames.baseReference
+  const langs = await getLanguagesFromOption(client, config, config.languages, document)
+  const languageId =
+    getLanguageFromDocument(document, config) || getBaseLanguage(langs, config.base)?.id
+
+  // Update I18n field for current document
+  const currentDocumentTransaction = client.transaction()
+  currentDocumentTransaction.createIfNotExists({_id: id, _type: type})
+  currentDocumentTransaction.patch(id, {
+    set: {
+      [fieldName]: languageId,
+      ...(isTranslation && config.referenceBehavior !== ReferenceBehavior.DISABLED
+        ? {
+            [baseRefFieldName]: createSanityReference(
+              baseDocumentId,
+              config.referenceBehavior === ReferenceBehavior.WEAK
+            ),
+          }
+        : {}),
+    },
+  })
+  await currentDocumentTransaction.commit()
+
+  // update base document reference if required
+  if (baseDocument) {
+    const translatedDocuments = await getTranslationsFor(client, config, baseDocumentId)
+    if (translatedDocuments.length > 0) {
+      const baseDocumentTransaction = client.transaction()
+      let translatedRefs: ITranslationRef[] = []
+      if (config.referenceBehavior !== ReferenceBehavior.DISABLED) {
+        translatedRefs = compact(
+          translatedDocuments.map((doc) => {
+            const lang = getLanguageFromDocument(doc, config)
+            if (!lang) return null
+            return {
+              _key: lang,
+              ...createSanityReference(
+                doc._id,
+                config.referenceBehavior === ReferenceBehavior.WEAK
+              ),
+            }
+          }, {})
+        )
+      }
+      // baseDocumentTransaction.createIfNotExists({_id: baseDocumentId, _type: type})
+      baseDocumentTransaction.patch(baseDocumentId, {
+        set: {
+          [refsFieldName]: translatedRefs,
+        },
+      })
+      await baseDocumentTransaction.commit()
+    }
+  }
+}

package/src/utils/useSanityClient.ts

@@ -0,0 +1,6 @@
+import {SanityClient} from '@sanity/client'
+import {useClient} from 'sanity'
+
+export function useSanityClient(): SanityClient {
+  return useClient({apiVersion: '2021-10-01'})
+}

package/src/validators/index.ts

@@ -0,0 +1 @@
+export * from './isSlugUnique'

package/src/validators/isSlugUnique.ts

@@ -0,0 +1,56 @@
+import type {SlugIsUniqueValidator} from 'sanity'
+import type {SanityClient} from '@sanity/client'
+import {I18nDelimiter} from '../constants'
+import {getBaseIdFromId, serializePath} from '../utils'
+
+/*
+ * most of this is taken from the deafultUnique function in @sanity/validation
+ */
+export function createIsSlugUnique(client: SanityClient): SlugIsUniqueValidator {
+  return (slug, context) => {
+    const {document, path, type} = context
+    const schemaOptions = type?.options as {disableArrayWarning?: boolean} | undefined
+
+    if (!document) {
+      throw new Error(`\`document\` was not provided in validation context.`)
+    }
+    if (!path) {
+      throw new Error(`\`path\` was not provided in validation context.`)
+    }
+
+    const disableArrayWarning = schemaOptions?.disableArrayWarning || false
+    const baseId = getBaseIdFromId(document._id)
+    const docType = document._type
+    const atPath = serializePath(path.concat('current'))
+
+    if (!disableArrayWarning && atPath.includes('[]')) {
+      const serializedPath = serializePath(path)
+      console.warn(
+        [
+          `Slug field at path ${serializedPath} is within an array and cannot be automatically checked for uniqueness`,
+          `If you need to check for uniqueness, provide your own "isUnique" method`,
+          `To disable this message, set \`disableArrayWarning: true\` on the slug \`options\` field`,
+        ].join('\n')
+      )
+    }
+
+    const constraints = [
+      '_type == $docType',
+      '!(_id in path("drafts.**"))', // exclude drafts
+      '_id != $baseId', // exclude own base document
+      '!(_id in path("i18n." + $baseId + ".*"))', // exclude any subpath translations
+      `!(_id match $baseId  + "${I18nDelimiter}*")`, // exclude any delimiter based translations
+      `${atPath} == $slug`,
+    ].join(' && ')
+
+    return client.fetch<boolean>(
+      `!defined(*[${constraints}][0]._id)`,
+      {
+        docType,
+        baseId,
+        slug,
+      },
+      {tag: 'validation.slug-is-unique'}
+    )
+  }
+}

package/src/withDocumentI18nPlugin.ts

@@ -0,0 +1,24 @@
+import compact from 'lodash/compact'
+import type {PluginOptions} from 'sanity'
+import {deskTool} from 'sanity/desk'
+import type {Ti18nConfig} from './types'
+import {documentI18n} from './documentI18n'
+import {getDocumentList} from './structure'
+
+export function withDocumentI18nPlugin(
+  plugins: PluginOptions[] | ((config: Ti18nConfig) => PluginOptions[]),
+  config: Ti18nConfig & {
+    includeDeskTool?: boolean
+  }
+): PluginOptions[] {
+  const i18nplugin = documentI18n(config)
+  return compact([
+    ...(Array.isArray(plugins) ? plugins : plugins(config)),
+    config.includeDeskTool ?? true
+      ? deskTool({
+          structure: (S, {schema}) => getDocumentList({S, schema, config}),
+        })
+      : null,
+    i18nplugin,
+  ])
+}

package/v2-incompatible.js

@@ -5,7 +5,7 @@ export default showIncompatiblePluginDialog({
   name: name,
   versions: {
     v3: version,
-    v2: undefined,
+    v2: '^0.3.2',
   },
   sanityExchangeUrl,
 })