@plutocms/pluto 0.13.0 → 0.14.1

package/app/composables/internal/i18n-core.ts

@@ -0,0 +1,310 @@
+// Pure engine of the Pluto i18n system. It does not use Nuxt auto-imports, so
+// plain Vitest can import it. The Nuxt-aware wrappers are in
+// `app/composables/pluto-i18n.ts`. Import from 'vue' explicitly, as
+// `registry-factory.ts` does.
+import { shallowReactive } from 'vue'
+
+/** A message tree as stored in a locale JSON file. */
+export interface MessageTree {
+  [key: string]: string | MessageTree
+}
+
+/** A message tree flattened to dotted keys. */
+export type FlatMessages = Record<string, string>
+
+export type MessageParams = Record<string, unknown>
+
+/**
+ * A translation key: a lowercase namespace, then one or more dotted parts.
+ * Example: `pluto.common.save`. A plain English label does not match, so
+ * `tx()` can tell a key from a literal.
+ */
+const MESSAGE_KEY = /^[a-z][a-z0-9-]*(?:\.[\w-]+)+$/
+
+export function isMessageKey(value: unknown): value is string {
+  return typeof value === 'string' && MESSAGE_KEY.test(value)
+}
+
+/** Flattens a nested message tree to dotted keys. Keeps string leaves only. */
+export function flattenMessages(tree: MessageTree, prefix = ''): FlatMessages {
+  const flat: FlatMessages = {}
+  for (const [name, value] of Object.entries(tree)) {
+    const key = prefix ? `${prefix}.${name}` : name
+    if (typeof value === 'string') {
+      flat[key] = value
+    } else if (value && typeof value === 'object') {
+      Object.assign(flat, flattenMessages(value, key))
+    }
+  }
+  return flat
+}
+
+/** Replaces each `{name}` with `params.name`. An unknown name stays as it is. */
+export function interpolate(message: string, params?: MessageParams): string {
+  if (!params) {
+    return message
+  }
+  return message.replace(/\{(\w+)\}/g, (match, name: string) => {
+    const value = params[name]
+    return value === undefined || value === null ? match : String(value)
+  })
+}
+
+const PLURAL_SEPARATOR = ' | '
+
+/** Returns the number of plural forms in a message. */
+export function countPluralForms(message: string): number {
+  return message.split(PLURAL_SEPARATOR).length
+}
+
+const pluralRules = new Map<string, Intl.PluralRules>()
+
+function getPluralRules(locale: string): Intl.PluralRules {
+  let rules = pluralRules.get(locale)
+  if (!rules) {
+    rules = new Intl.PluralRules(locale)
+    pluralRules.set(locale, rules)
+  }
+  return rules
+}
+
+/**
+ * Picks one form of a plural message.
+ *
+ * - One form: returned as it is.
+ * - Two forms (`one | other`): `Intl.PluralRules` of the locale decides.
+ * - Three forms (`zero | one | other`): 0 gives the first form, even in a
+ *   locale where 0 is `one` (pt-BR). Then `Intl.PluralRules` decides.
+ */
+export function selectPlural(message: string, count: number, locale: string): string {
+  const forms = message.split(PLURAL_SEPARATOR)
+  if (forms.length === 1) {
+    return message
+  }
+  const category = getPluralRules(locale).select(count)
+  if (forms.length === 2) {
+    return category === 'one' ? forms[0]! : forms[1]!
+  }
+  if (count === 0) {
+    return forms[0]!
+  }
+  return category === 'one' ? forms[1]! : forms[2]!
+}
+
+export interface TranslatorOptions {
+  /** The active locale code. Called on each translation, so it can be reactive. */
+  locale: () => string
+  /** The locale to use when a key is missing. Default `en`. */
+  fallbackLocale?: string
+  /** Returns the flat messages of a locale, or undefined if not loaded. */
+  messages: (locale: string) => FlatMessages | undefined
+  /** Called once for each missing key. Default: `console.warn` in dev, none otherwise. */
+  warn?: (message: string) => void
+}
+
+export interface Translator {
+  /** Translates a key. A second number argument is the plural count. */
+  t: (key: string, params?: MessageParams | number) => string
+  /** True if the key exists in the active locale or in the fallback. */
+  te: (key: string) => boolean
+  /** Translates a key-or-literal value. A literal returns unchanged. */
+  tx: (value: string, params?: MessageParams | number) => string
+}
+
+/**
+ * Builds a translator. Fallback order: the active locale, the fallback
+ * locale, then the key itself.
+ */
+export function createTranslator(options: TranslatorOptions): Translator {
+  const fallbackLocale = options.fallbackLocale ?? 'en'
+  const warned = new Set<string>()
+  const warn = options.warn ?? ((message: string) => {
+    if (import.meta.dev) {
+      console.warn(message)
+    }
+  })
+
+  function lookup(key: string): {
+ message: string
+locale: string
+} | undefined {
+    const locale = options.locale()
+    const active = options.messages(locale)?.[key]
+    if (active !== undefined) {
+      return { message: active, locale }
+    }
+    const fallback = options.messages(fallbackLocale)?.[key]
+    if (fallback !== undefined) {
+      return { message: fallback, locale: fallbackLocale }
+    }
+    return undefined
+  }
+
+  function t(key: string, params?: MessageParams | number): string {
+    const found = lookup(key)
+    if (!found) {
+      if (!warned.has(key)) {
+        warned.add(key)
+        warn(`[pluto-i18n] Missing translation key "${key}".`)
+      }
+      return key
+    }
+    const values: MessageParams = typeof params === 'number' ? { count: params } : (params ?? {})
+    let message = found.message
+    if (message.includes(PLURAL_SEPARATOR)) {
+      const count = Number(values.count)
+      message = selectPlural(message, Number.isNaN(count) ? 1 : count, found.locale)
+    }
+    return interpolate(message, values)
+  }
+
+  function te(key: string): boolean {
+    return lookup(key) !== undefined
+  }
+
+  function tx(value: string, params?: MessageParams | number): string {
+    return isMessageKey(value) && te(value) ? t(value, params) : value
+  }
+
+  return { t, te, tx }
+}
+
+/** Deep-merges message trees. A later tree overrides an earlier one. */
+export function mergeMessageTrees(...trees: MessageTree[]): MessageTree {
+  const result: MessageTree = {}
+  for (const tree of trees) {
+    for (const [key, value] of Object.entries(tree)) {
+      const current = result[key]
+      if (typeof value === 'object' && value !== null) {
+        result[key] = mergeMessageTrees(typeof current === 'object' && current !== null ? current : {}, value)
+      } else {
+        result[key] = value
+      }
+    }
+  }
+  return result
+}
+
+export interface LocaleCache<T> {
+  /** Reactive read. Returns undefined until the locale is loaded. */
+  get: (locale: string) => T | undefined
+  /** Loads a locale once. Many calls share one promise. */
+  load: (locale: string) => Promise<void>
+}
+
+/**
+ * A cache of per-locale data (messages, or a Nuxt UI locale object), filled
+ * by async loaders. `get` is reactive, so a translation updates when its
+ * locale finishes loading.
+ */
+export function createLocaleCache<T, R = T>(
+  loaders: Record<string, () => Promise<R>>,
+  transform: (value: R) => T
+): LocaleCache<T> {
+  const store = shallowReactive(new Map<string, T>())
+  const pending = new Map<string, Promise<void>>()
+
+  function load(locale: string): Promise<void> {
+    if (store.has(locale)) {
+      return Promise.resolve()
+    }
+    const loader = loaders[locale]
+    if (!loader) {
+      return Promise.resolve()
+    }
+    let promise = pending.get(locale)
+    if (!promise) {
+      promise = loader()
+        .then((value) => {
+          store.set(locale, transform(value))
+        })
+        .finally(() => {
+          pending.delete(locale)
+        })
+      pending.set(locale, promise)
+    }
+    return promise
+  }
+
+  return { get: (locale) => store.get(locale), load }
+}
+
+const numberFormats = new Map<string, Intl.NumberFormat>()
+const dateFormats = new Map<string, Intl.DateTimeFormat>()
+
+/** Formats a number. The `Intl` formatter is cached per locale and options. */
+export function formatNumber(locale: string, value: number, options?: Intl.NumberFormatOptions): string {
+  const key = `${locale}|${JSON.stringify(options ?? {})}`
+  let format = numberFormats.get(key)
+  if (!format) {
+    format = new Intl.NumberFormat(locale, options)
+    numberFormats.set(key, format)
+  }
+  return format.format(value)
+}
+
+/** Formats a date. The `Intl` formatter is cached per locale and options. */
+export function formatDate(locale: string, value: Date | number | string, options?: Intl.DateTimeFormatOptions): string {
+  const key = `${locale}|${JSON.stringify(options ?? {})}`
+  let format = dateFormats.get(key)
+  if (!format) {
+    format = new Intl.DateTimeFormat(locale, options)
+    dateFormats.set(key, format)
+  }
+  return format.format(value instanceof Date ? value : new Date(value))
+}
+
+/**
+ * Returns the name of a language in its own language, first letter in
+ * capitals. Example: `pt-BR` gives "Português (Brasil)".
+ */
+export function getLanguageName(code: string): string {
+  let name = code
+  try {
+    name = new Intl.DisplayNames([code], { type: 'language' }).of(code) ?? code
+  } catch {
+    // An invalid code keeps the code as the name.
+  }
+  return name.charAt(0).toLocaleUpperCase(code) + name.slice(1)
+}
+
+/**
+ * Parses an `Accept-Language` header into language tags, best first. A tag
+ * with `q=0` is dropped.
+ */
+export function parseAcceptLanguage(header: string | undefined): string[] {
+  if (!header) {
+    return []
+  }
+  return header
+    .split(',')
+    .map((part, index) => {
+      const [tag = '', ...params] = part.trim().split(';')
+      const q = params.map((param) => /^\s*q=([\d.]+)\s*$/.exec(param)?.[1]).find(Boolean)
+      return { tag: tag.trim(), q: q === undefined ? 1 : Number(q), index }
+    })
+    .filter((entry) => entry.tag && entry.tag !== '*' && entry.q > 0)
+    .sort((a, b) => b.q - a.q || a.index - b.index)
+    .map((entry) => entry.tag)
+}
+
+/**
+ * Matches the requested language tags to the supported locale codes. For each
+ * tag, in order: an exact match (ignoring case), then the first supported
+ * code with the same base language. Returns null if nothing matches.
+ */
+export function matchLocale(requested: string[], supported: string[]): string | null {
+  const lower = new Map(supported.map((code) => [code.toLowerCase(), code]))
+  for (const tag of requested) {
+    const exact = lower.get(tag.toLowerCase())
+    if (exact) {
+      return exact
+    }
+    const base = tag.toLowerCase().split('-')[0]!
+    const byBase = supported.find((code) => code.toLowerCase().split('-')[0] === base)
+    if (byBase) {
+      return byBase
+    }
+  }
+  return null
+}

package/app/composables/internal/i18n-runtime.ts

@@ -0,0 +1,87 @@
+// The Nuxt-aware part of the i18n engine: the shared caches, the language
+// detection, and the first-locale resolve. It sits under `internal/` so it
+// stays out of auto-import. The pure part is in `i18n-core.ts`.
+import type { Locale, Messages } from '@nuxt/ui'
+import type { FlatMessages, MessageTree } from './i18n-core'
+import { markRaw } from 'vue'
+import { defaultLocale, messageLoaders, uiLocaleLoaders } from '#build/pluto-i18n.mjs'
+import { useCookie, useRequestHeaders, useRuntimeConfig } from '#imports'
+import { createLocaleCache, flattenMessages, matchLocale, parseAcceptLanguage } from './i18n-core'
+
+/** Cookie names. The admin and the site keep a separate locale. */
+export const ADMIN_LOCALE_COOKIE = 'pluto-admin-locale'
+export const SITE_LOCALE_COOKIE = 'pluto-site-locale'
+
+const COOKIE_OPTIONS = { maxAge: 60 * 60 * 24 * 365, path: '/', sameSite: 'lax' } as const
+
+/**
+ * One message cache for both scopes. Messages never change per request, so
+ * a module-level cache is safe on the server too.
+ */
+export const messageCache = createLocaleCache<FlatMessages, MessageTree>(
+  messageLoaders as Record<string, () => Promise<MessageTree>>,
+  flattenMessages
+)
+
+/** The Nuxt UI locale objects, for `UApp :locale`. */
+export const uiLocaleCache = createLocaleCache<Locale<Messages>>(
+  uiLocaleLoaders as Record<string, () => Promise<Locale<Messages>>>,
+  (locale) => markRaw(locale)
+)
+
+/** Loads the messages and the Nuxt UI locale of a locale, and of `en` for the fallback. */
+export async function loadPlutoLocale(code: string): Promise<void> {
+  await Promise.all([
+    messageCache.load(code),
+    messageCache.load('en'),
+    uiLocaleCache.load(code),
+    uiLocaleCache.load('en'),
+  ])
+}
+
+export function getConfig() {
+  return useRuntimeConfig().public.plutoI18n
+}
+
+export function useLocaleCookie(name: string) {
+  return useCookie<string | null>(name, { ...COOKIE_OPTIONS, default: () => null })
+}
+
+/**
+ * The visitor's language tags, best first. On the server, from the
+ * `Accept-Language` header. On the client, from `navigator.languages`. The
+ * server never reads `navigator`.
+ */
+export function getBrowserLanguages(): string[] {
+  if (import.meta.server) {
+    return parseAcceptLanguage(useRequestHeaders(['accept-language'])['accept-language'])
+  }
+  return typeof navigator === 'undefined' ? [] : [...navigator.languages]
+}
+
+/** The admin locale from the browser language alone: no cookie, no stored choice. */
+export function detectAdminLocale(): string {
+  const config = getConfig()
+  return matchLocale(getBrowserLanguages(), config.adminLocales) ?? config.defaultLocale
+}
+
+/** A stored admin choice, or null. Only a supported code counts. */
+export function readAdminPreference(): string | null {
+  const value = useLocaleCookie(ADMIN_LOCALE_COOKIE).value
+  return value && getConfig().adminLocales.includes(value) ? value : null
+}
+
+/** Admin order: cookie, browser language, default locale. */
+export function resolveAdminLocale(): string {
+  return readAdminPreference() ?? detectAdminLocale()
+}
+
+/** Site order: cookie, the `siteLocale` option, default locale. */
+export function resolveSiteLocale(): string {
+  const config = getConfig()
+  const cookie = useLocaleCookie(SITE_LOCALE_COOKIE).value
+  if (cookie && config.siteLocales.includes(cookie)) {
+    return cookie
+  }
+  return config.siteLocale || config.defaultLocale || defaultLocale
+}

package/app/composables/pluto-admin-nav.ts

@@ -1,3 +1,5 @@
+import { contentTextFor } from './internal/content-text'
+
 // The old `NavigationMenuItem`/`NavigationMenuChildItem` shape (from
 // `@plutocms/utils`) always carries a plain `href`, never Nuxt's typed `to`.
 // This narrows just the field the bridge below reads.
@@ -22,6 +24,11 @@ interface LegacyHrefLink {
  *    when `type.capabilities.read` is unset, the entry is always visible;
  *    when it is set, `can(...)` decides.
  *
+ * Labels are key-or-literal. They resolve with `tx()` after the legacy dedupe
+ * above, which compares the raw labels. A content type's labels come from
+ * `usePlutoContentText`, so the convention keys apply. The `computed` reads
+ * the active locale, so a locale switch updates the labels.
+ *
  * `entry.enabled` is read and enforced uniformly across all three sources
  * here. Source 1 already filters on it a second time, inside
  * `createOwnedRegistry` itself (see
@@ -35,6 +42,8 @@ export function usePlutoAdminNav() {
   const legacy = useSidebarAdminActions()
   const { items: contentTypes } = usePlutoContentTypes()
   const { can } = usePlutoPermissions()
+  const i18n = usePlutoI18n()
+  const { t, tx } = i18n
 
   const items = computed<PlutoNavItem[]>(() => {
     const registered = registry.nav.list.value
@@ -55,27 +64,35 @@ export function usePlutoAdminNav() {
         })),
       }))
 
+    // Resolve the labels now, after the dedupe above has compared the raw ones.
+    const resolveLabels = (item: PlutoNavItem): PlutoNavItem => ({
+      ...item,
+      label: tx(item.label),
+      children: item.children?.map((child) => ({ ...child, label: tx(child.label) })),
+    })
+
     const contentNav: PlutoNavItem[] = contentTypes.value
       .filter((entry) => entry.type.autoRoutes !== false)
       .map((entry) => {
         const type = entry.type
+        const text = contentTextFor(type, i18n)
         const basePath = type.basePath ?? `/admin/content/${type.name}`
 
         return {
           id: `content:${type.name}`,
           order: type.navOrder ?? 100,
-          label: type.labelPlural,
+          label: text.labelPlural,
           icon: type.icon,
           to: basePath,
           enabled: () => !type.capabilities?.read || can(type.capabilities.read),
           children: [
-            { label: `All ${type.labelPlural}`, to: basePath },
-            { label: `Create new ${type.label}`, to: `${basePath}/new` },
+            { label: t('pluto.content.all', { labelPlural: text.labelPlural }), to: basePath },
+            { label: t('pluto.content.createNew', { label: text.label }), to: `${basePath}/new` },
           ],
         }
       })
 
-    return [...registered, ...bridged, ...contentNav]
+    return [...registered.map(resolveLabels), ...bridged.map(resolveLabels), ...contentNav]
       .filter((item) => item.enabled?.() ?? true)
       .sort((a, b) => (a.order ?? 100) - (b.order ?? 100))
   })

package/app/composables/pluto-admin-pages.ts

@@ -1,3 +1,5 @@
+import { contentTextFor } from './internal/content-text'
+
 /**
  * Metadata for admin pages, registered on top of routes Nuxt already
  * creates from files, plus two synthesized entries per auto-routed content
@@ -5,32 +7,40 @@
  * page-metadata equivalent of the nav entry `usePlutoAdminNav` synthesizes
  * for the same content type. No layer registers page metadata today, so
  * the registry bucket itself has no legacy bridge.
+ *
+ * Titles are key-or-literal. They resolve with `tx()` inside the `computed`,
+ * so a locale switch updates them.
  */
 export function usePlutoAdminPages() {
   const registry = usePlutoRegistry()
   const route = useRoute()
   const { items: contentTypes } = usePlutoContentTypes()
+  const i18n = usePlutoI18n()
+  const { t, tx } = i18n
 
   const items = computed<PlutoAdminPage[]>(() => {
     const contentPages: PlutoAdminPage[] = contentTypes.value
       .filter((entry) => entry.type.autoRoutes !== false)
       .flatMap((entry) => {
         const type = entry.type
+        const text = contentTextFor(type, i18n)
         const basePath = type.basePath ?? `/admin/content/${type.name}`
         const navId = `content:${type.name}`
 
         return [
-          { id: `${navId}:list`, path: basePath, title: type.labelPlural },
+          { id: `${navId}:list`, path: basePath, title: text.labelPlural },
           {
             id: `${navId}:new`,
             path: `${basePath}/new`,
-            title: `Create new ${type.label}`,
+            title: t('pluto.content.createNew', { label: text.label }),
             parent: navId,
           },
         ]
       })
 
-    return [...registry.pages.list.value, ...contentPages]
+    const registered = registry.pages.list.value.map((page) => ({ ...page, title: tx(page.title) }))
+
+    return [...registered, ...contentPages]
   })
 
   const current = computed(() => items.value.find((page) => page.path === route.path))

package/app/composables/pluto-command-palette.ts

@@ -1,4 +1,5 @@
 import type { CommandPaletteGroup, CommandPaletteItem } from '@nuxt/ui'
+import { contentTextFor } from './internal/content-text'
 
 /**
  * Builds the admin command palette groups (`UDashboardSearch` in the
@@ -19,7 +20,12 @@ export function usePlutoCommandPalette() {
   const { items: navItems } = usePlutoAdminNav()
   const { items: contentTypes } = usePlutoContentTypes()
   const { can } = usePlutoPermissions()
+  const i18n = usePlutoI18n()
+  const { t, tx } = i18n
 
+  // Everything the palette shows resolves inside the `computed`, so a locale
+  // switch updates it. Nav labels arrive resolved from `usePlutoAdminNav`.
+  // `tx()` leaves a resolved label as it is.
   return computed<CommandPaletteGroup<CommandPaletteItem>[]>(() => {
     const seen = new Set<string>()
 
@@ -38,22 +44,23 @@ export function usePlutoCommandPalette() {
         return []
       }
       const basePath = type.basePath ?? `/admin/content/${type.name}`
-      return command(`New ${type.label}`, type.newPath ?? `${basePath}/new`, {
+      const text = contentTextFor(type, i18n)
+      return command(text.newLabel, type.newPath ?? `${basePath}/new`, {
         icon: 'lucide:plus',
-        suffix: type.labelPlural,
+        suffix: text.labelPlural,
       })
     })
 
     const goTo = navItems.value.flatMap((item) => [
-      ...(item.to ? command(item.label, item.to, { icon: item.icon }) : []),
+      ...(item.to ? command(tx(item.label), item.to, { icon: item.icon }) : []),
       ...(item.children ?? []).flatMap((child) =>
-        child.to ? command(child.label, child.to, { icon: item.icon, suffix: item.label }) : []
+        child.to ? command(tx(child.label), child.to, { icon: item.icon, suffix: tx(item.label) }) : []
       ),
     ])
 
     return [
-      { id: 'pluto-create', label: 'Create', items: create },
-      { id: 'pluto-go-to', label: 'Go to', items: goTo },
+      { id: 'pluto-create', label: t('pluto.common.create'), items: create },
+      { id: 'pluto-go-to', label: t('pluto.palette.goTo'), items: goTo },
     ].filter((group) => group.items.length > 0)
   })
 }

package/app/composables/pluto-content-actions.ts

@@ -3,15 +3,19 @@
  * placement. Matches an entry whose `contentType` is `typeName` or `'*'`,
  * the same matching rule `usePlutoContentFieldWidget` uses for field type.
  * `placement` defaults to 'toolbar', matching `PlutoContentAction.placement`.
+ * The label is key-or-literal. It resolves with `tx()` inside the `computed`.
  */
 export function usePlutoContentActions(typeName: string, placement: 'toolbar' | 'aside' = 'toolbar') {
   const registry = usePlutoRegistry()
+  const { tx } = usePlutoI18n()
 
   return computed(() =>
-    registry.contentActions.list.value.filter(
-      (action) =>
-        (action.contentType === typeName || action.contentType === '*') &&
-        (action.placement ?? 'toolbar') === placement
-    )
+    registry.contentActions.list.value
+      .filter(
+        (action) =>
+          (action.contentType === typeName || action.contentType === '*') &&
+          (action.placement ?? 'toolbar') === placement
+      )
+      .map((action) => ({ ...action, label: tx(action.label) }))
   )
 }

package/app/composables/pluto-content-text.ts

@@ -0,0 +1,28 @@
+import { createContentText } from './internal/content-text'
+
+/**
+ * The translated text of one content type. Each value is the convention key
+ * (`content.<name>.label`, `.labelPlural`, `.new`, `.fields.<field>.label`
+ * and more) when the key exists, else the English literal of the type. A type
+ * with no keys keeps its English text.
+ *
+ * Read the values inside a template or a `computed`, so a locale switch
+ * updates them. Server code and code that reads `type.label` directly keep
+ * the English text.
+ */
+export function usePlutoContentText(type: MaybeRefOrGetter<PlutoContentType | undefined>) {
+  const { t, te, locale } = usePlutoI18n()
+  return createContentText(() => toValue(type), { t, te, locale })
+}
+
+/**
+ * Returns a function that gives the translated text of a content type by its
+ * `name`. Use it where one component shows many types, such as the dashboard
+ * tiles. See `usePlutoContentText`.
+ */
+export function usePlutoContentTexts() {
+  const { t, te, locale } = usePlutoI18n()
+  const { byName } = usePlutoContentTypes()
+
+  return (name: string) => createContentText(() => byName(name), { t, te, locale })
+}

package/app/composables/pluto-dashboard.ts

@@ -1,5 +1,18 @@
-/** Widgets shown on the admin dashboard (`/admin/home`). */
+/**
+ * Widgets shown on the admin dashboard (`/admin/home`). A widget title is
+ * key-or-literal. It resolves with `tx()` inside the `computed`, so a locale
+ * switch updates it.
+ */
 export function usePlutoDashboardWidgets() {
   const registry = usePlutoRegistry()
-  return { items: registry.dashboardWidgets.list }
+  const { tx } = usePlutoI18n()
+
+  const items = computed<PlutoDashboardWidget[]>(() =>
+    registry.dashboardWidgets.list.value.map((widget) => ({
+      ...widget,
+      title: widget.title === undefined ? undefined : tx(widget.title),
+    }))
+  )
+
+  return { items }
 }

package/app/composables/pluto-error.ts

@@ -0,0 +1,13 @@
+import { DEFAULT_ERROR_KEY, resolveErrorText } from './internal/error-text'
+
+/**
+ * Returns a function that turns an error into text for the admin. It prefers
+ * the translation key that a server `createPlutoError` sent (`data.i18n`),
+ * then the server `statusMessage` or `message`, then the fallback key. The
+ * default fallback is `pluto.errors.unknown`.
+ */
+export function usePlutoErrorText() {
+  const { t, te } = usePlutoI18n()
+
+  return (error: unknown, fallbackKey: string = DEFAULT_ERROR_KEY): string => resolveErrorText(error, fallbackKey, { t, te })
+}

package/app/composables/pluto-extension.ts

@@ -20,6 +20,10 @@ export function definePlutoExtension(definition: PlutoExtension): void {
     definition.id,
     definition.settingsDriver ? [definition.settingsDriver] : []
   )
+  registry.localeDrivers.set(
+    definition.id,
+    definition.localeDriver ? [definition.localeDriver] : []
+  )
   registry.dashboardWidgets.set(definition.id, definition.dashboardWidgets ?? [])
   registry.capabilities.set(definition.id, definition.capabilities ?? [])
   registry.permissionsDrivers.set(