@visma-swno/customer-onboarding-wizard 1.0.16 → 1.0.18

package/README.md

@@ -191,16 +191,19 @@ document.addEventListener('http-error', async (event) => {
 **Detail**:
 ```typescript
 {
-  status: number;           // HTTP status code or 0 for network errors
-  errorKey: string;         // Translation key (e.g., 'serverError', 'validationError')
-  endpoint: string;         // Failed endpoint
-  method: string;           // HTTP method
+  status: number;                // HTTP status code or 0 for network errors
+  errorKey: string;              // Translation key (e.g., 'serverError', 'validationError')
+  endpoint: string;              // Failed endpoint
+  method: string;                // HTTP method
+  code?: string;                 // Structured backend error code, when present
+  messageParameters?: string[];  // Ordered values for the code's translated template
 }
 ```
 
 **Handled Automatically**: Host application does not need to listen to this event. The component:
 - Displays a red error banner at the top of the wizard
 - Automatically translates error title and message to the user's selected language
+- When the response carries a structured `{ code, messageParameters }` body, composes the message from the **translated** template for that `code` (ignoring the backend's untranslated `message`); `SCREAMING_SNAKE_CASE` parameters like `CONSULTANT` are themselves translated, ids/names are inserted verbatim. Unmapped codes fall back to the status-based message.
 - Supports 6 translation sets: da-DK, en-US, fi-FI, nb-NO, nl-NL, sv-SE (`en-GB` is accepted and served using `en-US` translations)
 - Banner remains visible until the user manually dismisses it by clicking the X button
 - Allows users to report errors to support

package/dist/core/http.service.d.ts

@@ -123,6 +123,17 @@ export interface ErrorMessageDetail {
     errorKey: 'invalidRequest' | 'validationError' | 'notFound' | 'serverError' | 'requestTimeout' | 'networkError' | 'requestFailed';
     endpoint: string;
     method: string;
+    /**
+     * Backend error code from a structured error body (e.g. 'ROLE_ALREADY_ASSIGNED_FOR_CUSTOMER').
+     * When present, the component composes a translated message from this code + `messageParameters`
+     * instead of using the status-based `errorKey`. Absent when the response had no structured body.
+     */
+    code?: string;
+    /**
+     * Ordered substitution values for the structured error's translated template.
+     * Only meaningful together with `code`.
+     */
+    messageParameters?: string[];
 }
 export declare class HttpService {
     private baseUrl;
@@ -160,6 +171,13 @@ export declare class HttpService {
      */
     private emitErrorMessage;
     request<T>(endpoint: string, config?: RequestConfig): Promise<T>;
+    /**
+     * Parse a structured error body of the shape `{ code, messageParameters }`.
+     * Returns null when the body is missing, not JSON, or has no string `code`, so the caller
+     * falls back to the status-based error key. The response body is otherwise unused on the
+     * error path, so consuming it here is safe.
+     */
+    private parseStructuredError;
     /**
      * Get error key based on status code for i18n translation
      */

package/dist/core/i18n.service.d.ts

@@ -119,6 +119,18 @@ export interface Translations {
             message: string;
         };
     };
+    /**
+     * Structured backend errors. When a failed response carries a `{ code, messageParameters }`
+     * object, the banner message is composed from `codes[code]` (positional `{0}`, `{1}`, …
+     * placeholders) instead of the untranslated `message` from the API. Parameters that are
+     * SCREAMING_SNAKE_CASE enum values (e.g. `CONSULTANT`) are themselves translated via `params`.
+     * Only a subset of the backend's codes is mapped — unmapped codes fall back to the
+     * status-based `errors` entry. See `I18nService.composeBackendError`.
+     */
+    backendErrors: {
+        codes: Record<string, string>;
+        params: Record<string, string>;
+    };
 }
 /**
  * I18n Service Class
@@ -140,6 +152,28 @@ export declare class I18nService {
      * Get translations for the current locale
      */
     getTranslations(): Translations;
+    /**
+     * Compose a translated message for a structured backend error.
+     *
+     * Looks up the template for `code` in the current locale's `backendErrors.codes` and fills its
+     * positional placeholders (`{0}`, `{1}`, …) from `messageParameters`. Parameters that are
+     * SCREAMING_SNAKE_CASE enum values (matching `/^[A-Z][A-Z0-9_]*$/`, e.g. `CONSULTANT`) are
+     * themselves translated via `backendErrors.params`, falling back to a humanized form when the
+     * value is not yet mapped. All other parameters (ids, names, numbers) are inserted verbatim.
+     *
+     * Returns `null` when `code` is unmapped, or when the template has a positional placeholder with
+     * no matching parameter, so the caller can fall back to the status-based error instead of showing
+     * a message with a raw `{n}` token.
+     *
+     * @param code - Backend error code (e.g. 'ROLE_ALREADY_ASSIGNED_FOR_CUSTOMER')
+     * @param messageParameters - Ordered substitution values from the API response
+     */
+    composeBackendError(code: string, messageParameters?: string[]): string | null;
+    /**
+     * Translate a single backend-error parameter. SCREAMING_SNAKE_CASE values are treated as
+     * translatable enum tokens; everything else is returned unchanged.
+     */
+    private resolveBackendErrorParam;
     /**
      * Get a translation by key path
      */