@object-ui/i18n 15.0.0 → 16.1.0

package/dist/useObjectLabel.js

@@ -349,6 +349,67 @@ export function useObjectLabel() {
                 const resolved = resolve(suffixes, 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.
+             *
+             * 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
+             * is fetched whole with `returnObjects` and indexed directly — never
+             * resolved through a dotted i18next key.
+             */
+            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 textFor = (attr) => {
+                    const resolved = resolve(suffixesFor(attr), spec[attr] ?? '');
+                    return resolved || spec[attr];
+                };
+                const fieldsMap = (() => {
+                    try {
+                        for (const ns of getAppNamespaces()) {
+                            for (const suffix of suffixesFor('fields')) {
+                                const node = t(`${ns}.${suffix}`, {
+                                    returnObjects: true,
+                                    defaultValue: null,
+                                    [I18N_PROBE_FLAG]: true,
+                                });
+                                if (node && typeof node === 'object' && !Array.isArray(node)) {
+                                    return node;
+                                }
+                            }
+                        }
+                    }
+                    catch {
+                        // Graceful degradation when i18n provider is not available
+                    }
+                    return undefined;
+                })();
+                const fields = Array.isArray(spec.fields)
+                    ? spec.fields.map((field) => {
+                        if (!field || typeof field.path !== 'string')
+                            return field;
+                        const label = fieldsMap?.[field.path];
+                        return typeof label === 'string' && label.length > 0 ? { ...field, label } : field;
+                    })
+                    : spec.fields;
+                return {
+                    ...spec,
+                    title: textFor('title'),
+                    description: textFor('description'),
+                    acknowledge: textFor('acknowledge'),
+                    fields,
+                };
+            },
             /**
              * Resolve translated action-PARAMETER text (label / placeholder / helpText).
              * Convention: `{ns}.objects.{objectName}._actions.{actionName}.params.{paramName}.{attr}`.
@@ -402,15 +463,10 @@ const SAFE_FIELD_LABEL_FALLBACK = {
  * may be rendered outside an i18n context.
  */
 export function useSafeFieldLabel() {
-    let resolved = null;
-    try {
-        resolved = useObjectLabel();
-    }
-    catch {
-        resolved = null;
-    }
-    // useObjectLabel already returns a stable (memoized) object per language —
-    // pass-through avoids creating a fresh wrapper here. The module-level
-    // fallback object is reused when no provider is mounted.
-    return resolved ?? SAFE_FIELD_LABEL_FALLBACK;
+    // useObjectLabel delegates to the provider-safe useObjectTranslation (react-
+    // i18next falls back to the global instance and never throws), so it needs no
+    // try/catch — wrapping the hook call would violate rules-of-hooks. It already
+    // returns a stable memoized object; the module-level fallback stays as a
+    // defensive default, reached only if it ever returns nullish.
+    return useObjectLabel() ?? SAFE_FIELD_LABEL_FALLBACK;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@object-ui/i18n",
-  "version": "15.0.0",
+  "version": "16.1.0",
   "type": "module",
   "sideEffects": false,
   "license": "MIT",
@@ -31,7 +31,7 @@
   },
   "dependencies": {
     "i18next": "^26.3.6",
-    "react-i18next": "^17.0.9"
+    "react-i18next": "^17.0.10"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0"