@object-ui/i18n 16.1.0 → 17.2.0

package/dist/useObjectLabel.js

@@ -57,6 +57,11 @@ export function useObjectLabel() {
          * Returns top-level keys (outside built-in Object UI keys) that contain
          * an `objects`, `fields`, or `apps` sub-key — e.g. "crm" when resources
          * include crm.objects.* or crm.apps.*.
+         *
+         * `globalActions` is included so an app bundle whose only translated scope
+         * is global actions (no object/field entries) is still discovered — its
+         * `globalActions.<action>.*` overlays would otherwise be unreachable
+         * (objectui#3372).
          */
         const getAppNamespaces = () => {
             if (!i18n || typeof i18n.getResourceBundle !== 'function')
@@ -67,7 +72,8 @@ export function useObjectLabel() {
                 return [];
             return Object.keys(bundle).filter((key) => !BUILTIN_KEYS.has(key) && bundle[key] && typeof bundle[key] === 'object'
                 && (bundle[key].objects || bundle[key].fields || bundle[key].apps
-                    || bundle[key].dashboards || bundle[key].pages || bundle[key].reports));
+                    || bundle[key].dashboards || bundle[key].pages || bundle[key].reports
+                    || bundle[key].globalActions));
         };
         /**
          * Strip an ObjectStack namespace prefix (e.g. `crm__lead` → `lead`) so that
@@ -111,6 +117,30 @@ export function useObjectLabel() {
                 ? [`objects.${objectName}.${tail}`, `objects.${base}.${tail}`]
                 : [`objects.${objectName}.${tail}`];
         };
+        /**
+         * Build suffix candidates for an action-scoped key, mirroring the canonical
+         * `@objectstack/spec` resolver (`lookupActionField` in `system/i18n-resolver`).
+         *
+         * When the action is object-scoped, the object key
+         * (`objects.<obj>._actions.<action>.<tail>`) wins, but the global key
+         * (`globalActions.<action>.<tail>`) is appended as a fallback so a
+         * **globalAction surfaced on an object's action bar** still picks up its
+         * `globalActions.<action>.*` overlay when no object-scoped translation
+         * exists (objectui#3372). Without this fallback, a globalAction rendered on
+         * a record-detail action bar — where the caller passes `objectDef.name` for
+         * every action — misses `objects.<obj>._actions.<action>.label` and leaks the
+         * English metadata literal.
+         *
+         * Object-less actions (`objectName` omitted) resolve straight to the global
+         * namespace, as before. Object precedence is preserved: the global key is
+         * only consulted after every object-scoped candidate misses.
+         */
+        const actionSuffixes = (objectName, actionName, tail) => {
+            const globalSuffix = `globalActions.${actionName}.${tail}`;
+            return objectName
+                ? [...objectSuffixes(objectName, `_actions.${actionName}.${tail}`), globalSuffix]
+                : [globalSuffix];
+        };
         const fieldSuffixes = (objectName, fieldName) => {
             const base = stripNamespace(objectName);
             return base !== objectName
@@ -155,6 +185,23 @@ export function useObjectLabel() {
                 ? [`reports.${reportName}.${tail}`, `reports.${base}.${tail}`]
                 : [`reports.${reportName}.${tail}`];
         };
+        /**
+         * Build suffix candidates for a list-view scoped key.
+         *
+         * The runtime uses qualified view ids (`<objectName>.<viewName>`) in URLs
+         * and metadata records, while translation bundles are keyed by the authored
+         * view name under `_views`. Resolve the unqualified name first so every
+         * surface can pass its canonical id without leaking the metadata fallback.
+         */
+        const viewSuffixes = (objectName, viewName, tail) => {
+            const objectNames = [objectName, stripNamespace(objectName)];
+            const matchedPrefix = objectNames
+                .map((name) => `${name}.`)
+                .find((prefix) => viewName.startsWith(prefix));
+            const shortViewName = matchedPrefix ? viewName.slice(matchedPrefix.length) : viewName;
+            const viewNames = shortViewName === viewName ? [viewName] : [shortViewName, viewName];
+            return viewNames.flatMap((name) => objectSuffixes(objectName, `_views.${name}.${tail}`));
+        };
         return {
             /**
              * Resolve translated object label, falling back to objectDef.label.
@@ -264,14 +311,14 @@ export function useObjectLabel() {
              * Resolve translated list-view label.
              * Convention (per @objectstack/spec): `{ns}.objects.{objectName}._views.{viewName}.label`.
              */
-            viewLabel: (objectName, viewName, fallback) => resolve(objectSuffixes(objectName, `_views.${viewName}.label`), fallback),
+            viewLabel: (objectName, viewName, fallback) => resolve(viewSuffixes(objectName, viewName, 'label'), fallback),
             /**
              * Resolve translated list-view description.
              * Convention: `{ns}.objects.{objectName}._views.{viewName}.description`.
              */
             viewDescription: (objectName, viewName, fallback) => {
                 const fb = fallback ?? '';
-                const resolved = resolve(objectSuffixes(objectName, `_views.${viewName}.description`), fb);
+                const resolved = resolve(viewSuffixes(objectName, viewName, 'description'), fb);
                 return resolved || undefined;
             },
             /**
@@ -284,10 +331,10 @@ export function useObjectLabel() {
                 if (!fallback)
                     return undefined;
                 const title = fallback.title
-                    ? resolve(objectSuffixes(objectName, `_views.${viewName}.emptyState.title`), fallback.title)
+                    ? resolve(viewSuffixes(objectName, viewName, 'emptyState.title'), fallback.title)
                     : fallback.title;
                 const message = fallback.message
-                    ? resolve(objectSuffixes(objectName, `_views.${viewName}.emptyState.message`), fallback.message)
+                    ? resolve(viewSuffixes(objectName, viewName, 'emptyState.message'), fallback.message)
                     : fallback.message;
                 return { ...fallback, title, message };
             },
@@ -298,38 +345,32 @@ export function useObjectLabel() {
             sectionLabel: (objectName, sectionName, fallback) => resolve(objectSuffixes(objectName, `_sections.${sectionName}.label`), fallback),
             /**
              * Resolve translated action label.
-             * Convention: `{ns}.objects.{objectName}._actions.{actionName}.label`.
-             * Falls back to `{ns}.globalActions.{actionName}.label` when objectName is omitted.
+             * Convention: `{ns}.objects.{objectName}._actions.{actionName}.label`,
+             * falling back to `{ns}.globalActions.{actionName}.label` — both when
+             * objectName is omitted AND when the object-scoped key misses (so a
+             * globalAction surfaced on a record-detail action bar still resolves;
+             * objectui#3372).
              */
-            actionLabel: (objectName, actionName, fallback) => {
-                if (objectName) {
-                    return resolve(objectSuffixes(objectName, `_actions.${actionName}.label`), fallback);
-                }
-                return resolve(`globalActions.${actionName}.label`, fallback);
-            },
+            actionLabel: (objectName, actionName, fallback) => resolve(actionSuffixes(objectName, actionName, 'label'), fallback),
             /**
              * Resolve translated action confirmation prompt.
-             * Convention: `{ns}.objects.{objectName}._actions.{actionName}.confirmText`.
+             * Convention: `{ns}.objects.{objectName}._actions.{actionName}.confirmText`,
+             * falling back to `{ns}.globalActions.{actionName}.confirmText`.
              * Returns undefined when no translation and no fallback exist.
              */
             actionConfirm: (objectName, actionName, fallback) => {
                 const fb = fallback ?? '';
-                const suffixes = objectName
-                    ? objectSuffixes(objectName, `_actions.${actionName}.confirmText`)
-                    : `globalActions.${actionName}.confirmText`;
-                const resolved = resolve(suffixes, fb);
+                const resolved = resolve(actionSuffixes(objectName, actionName, 'confirmText'), fb);
                 return resolved || undefined;
             },
             /**
              * Resolve translated action success message.
-             * Convention: `{ns}.objects.{objectName}._actions.{actionName}.successMessage`.
+             * Convention: `{ns}.objects.{objectName}._actions.{actionName}.successMessage`,
+             * falling back to `{ns}.globalActions.{actionName}.successMessage`.
              */
             actionSuccess: (objectName, actionName, fallback) => {
                 const fb = fallback ?? '';
-                const suffixes = objectName
-                    ? objectSuffixes(objectName, `_actions.${actionName}.successMessage`)
-                    : `globalActions.${actionName}.successMessage`;
-                const resolved = resolve(suffixes, fb);
+                const resolved = resolve(actionSuffixes(objectName, actionName, 'successMessage'), fb);
                 return resolved || undefined;
             },
             /**
@@ -343,18 +384,16 @@ export function useObjectLabel() {
                 const fb = fallback ?? '';
                 if (!actionName)
                     return fb || undefined;
-                const suffixes = objectName
-                    ? objectSuffixes(objectName, `_actions.${actionName}.description`)
-                    : `globalActions.${actionName}.description`;
-                const resolved = resolve(suffixes, fb);
+                const resolved = resolve(actionSuffixes(objectName, actionName, 'description'), fb);
                 return resolved || undefined;
             },
             /**
              * Resolve a translated copy of an action's post-success RESULT DIALOG
              * (`title` / `description` / `acknowledge` + per-field labels).
              * Convention: `{ns}.objects.{objectName}._actions.{actionName}.resultDialog.*`,
-             * falling back to `{ns}.globalActions.{actionName}.resultDialog.*` when
-             * objectName is omitted, then to the metadata's literal strings.
+             * falling back to `{ns}.globalActions.{actionName}.resultDialog.*` (when
+             * objectName is omitted OR the object-scoped key misses), then to the
+             * metadata's literal strings.
              *
              * The `fields` translation node is keyed by the LITERAL result-field path
              * from the action metadata (may contain dots, e.g. `"user.email"`), so it
@@ -364,12 +403,7 @@ export function useObjectLabel() {
             actionResultDialog: (objectName, actionName, spec) => {
                 if (!spec || !actionName)
                     return spec;
-                const suffixesFor = (attr) => {
-                    const tail = `_actions.${actionName}.resultDialog.${attr}`;
-                    return objectName
-                        ? objectSuffixes(objectName, tail)
-                        : [`globalActions.${actionName}.resultDialog.${attr}`];
-                };
+                const suffixesFor = (attr) => actionSuffixes(objectName, actionName, `resultDialog.${attr}`);
                 const textFor = (attr) => {
                     const resolved = resolve(suffixesFor(attr), spec[attr] ?? '');
                     return resolved || spec[attr];
@@ -420,11 +454,7 @@ export function useObjectLabel() {
                 const fb = fallback ?? '';
                 if (!actionName || !paramName)
                     return fb || undefined;
-                const suffix = `_actions.${actionName}.params.${paramName}.${attr}`;
-                const suffixes = objectName
-                    ? objectSuffixes(objectName, suffix)
-                    : `globalActions.${actionName}.params.${paramName}.${attr}`;
-                const resolved = resolve(suffixes, fb);
+                const resolved = resolve(actionSuffixes(objectName, actionName, `params.${paramName}.${attr}`), fb);
                 return resolved || undefined;
             },
             /**
@@ -435,11 +465,7 @@ export function useObjectLabel() {
             actionParamOptionLabel: (objectName, actionName, paramName, optionValue, fallback) => {
                 if (!actionName || !paramName)
                     return fallback;
-                const suffix = `_actions.${actionName}.params.${paramName}.options.${optionValue}`;
-                const suffixes = objectName
-                    ? objectSuffixes(objectName, suffix)
-                    : `globalActions.${actionName}.params.${paramName}.options.${optionValue}`;
-                return resolve(suffixes, fallback);
+                return resolve(actionSuffixes(objectName, actionName, `params.${paramName}.options.${optionValue}`), fallback);
             },
         };
     }, [t, i18n]);

package/dist/useSafeTranslation.d.ts

@@ -1,7 +1,9 @@
 export declare function createSafeTranslation(defaults: Record<string, string>, testKey: string): () => {
     t: (key: string, options?: Record<string, unknown>) => string;
+    language: string;
 } | {
     t: import("i18next").TFunction<string, undefined>;
+    language: string;
 };
 /**
  * Per-call graceful translate hook for plugin renderers.

package/dist/useSafeTranslation.js

@@ -32,10 +32,15 @@ export function createSafeTranslation(defaults, testKey) {
         // "translations not configured" fallback.
         const result = useObjectTranslation();
         const testValue = result.t(testKey);
+        // `language` is surfaced so consumers that localize dates/numbers
+        // alongside their copy (data-table, gantt) don't have to call
+        // `useObjectTranslation` a second time just to read it. With no provider
+        // it is whatever react-i18next reports, which callers may treat as
+        // "follow the runtime default".
         if (testValue === testKey) {
-            return { t: fallbackT };
+            return { t: fallbackT, language: result.language };
         }
-        return { t: result.t };
+        return { t: result.t, language: result.language };
     };
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@object-ui/i18n",
-  "version": "16.1.0",
+  "version": "17.2.0",
   "type": "module",
   "sideEffects": false,
   "license": "MIT",
@@ -31,14 +31,14 @@
   },
   "dependencies": {
     "i18next": "^26.3.6",
-    "react-i18next": "^17.0.10"
+    "react-i18next": "^17.0.11"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0"
   },
   "devDependencies": {
     "@types/react": "19.2.17",
-    "react": "19.2.7",
+    "react": "19.2.8",
     "typescript": "^6.0.3",
     "vitest": "^4.1.10"
   },