tycho-components 0.38.7 → 0.39.0

package/dist/common/AppToast/AppToast.d.ts

@@ -1,2 +1,3 @@
 import 'react-toastify/dist/ReactToastify.css';
+import './style.scss';
 export default function AppToast(): import("react").JSX.Element;

package/dist/common/AppToast/AppToast.js

@@ -1,34 +1,65 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useContext, useEffect } from 'react';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useContext, useEffect, useRef, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import ReactLoading from 'react-loading';
 import { ToastContainer, toast } from 'react-toastify';
 import 'react-toastify/dist/ReactToastify.css';
 import CommonContext from '../../configs/CommonContext';
 import { message } from '../../configs/store/actions';
+import ServerErrorReport from '../../features/ServerErrorReport';
 import { EMPTY_TOAST } from './ToastMessage';
+import './style.scss';
 export default function AppToast() {
     const { t } = useTranslation('common');
     const { dispatch, state } = useContext(CommonContext);
+    const [reportModalOpen, setReportModalOpen] = useState(false);
+    const [reportErrorContext, setReportErrorContext] = useState();
+    const openingReportModalRef = useRef(false);
     const handleClose = () => {
         toast.dismiss();
         dispatch(message(EMPTY_TOAST));
+        if (openingReportModalRef.current) {
+            openingReportModalRef.current = false;
+            return;
+        }
+        setReportModalOpen(false);
+        setReportErrorContext(undefined);
     };
     const handleClipboard = () => {
         navigator.clipboard.writeText(state.message.value);
     };
+    const handleToastAction = () => {
+        if (state.message.action === 'report') {
+            setReportErrorContext(state.message.errorContext);
+            openingReportModalRef.current = true;
+            setReportModalOpen(true);
+            toast.dismiss();
+            dispatch(message(EMPTY_TOAST));
+            return;
+        }
+        handleClipboard();
+    };
+    const handleReportModalClose = () => {
+        setReportModalOpen(false);
+        setReportErrorContext(undefined);
+    };
+    const handleReportSent = () => {
+        setReportModalOpen(false);
+        setReportErrorContext(undefined);
+        dispatch(message({ value: t('server.error.report.sent'), type: 'success' }));
+    };
     const getLoading = () => (_jsxs("div", { className: "d-flex", children: [_jsx(ReactLoading, { type: "spinningBubbles", color: "blue", height: 24, width: 24 }), _jsx("span", { className: "ms-3", children: state.toastLoadingText ?? t('generic.loading') })] }));
     const attachCloseToEscape = () => {
         const closeOnEscape = (e) => {
-            if (e.keyCode === 27)
+            if (e.key === 'Escape' && !reportModalOpen)
                 handleClose();
         };
         window.addEventListener('keydown', closeOnEscape);
         return () => window.removeEventListener('keydown', closeOnEscape);
     };
     useEffect(() => {
-        attachCloseToEscape();
-    }, []);
+        return attachCloseToEscape();
+    }, [reportModalOpen]);
     useEffect(() => {
         if (state.toastLoading) {
             toast(getLoading(), {
@@ -44,32 +75,34 @@ export default function AppToast() {
             });
         }
         else {
-            toast.dismiss();
+            toast.dismiss('loading');
         }
     }, [state.toastLoading, state.toastLoadingText]);
     useEffect(() => {
         if (state.message && state.message.value !== '') {
+            const persistent = state.message.autoClose === false;
+            const toastOptions = {
+                onClose: () => handleClose(),
+                onClick: () => handleToastAction(),
+                ...(persistent
+                    ? { autoClose: false, closeOnClick: false }
+                    : {}),
+                ...(state.message.action === 'report'
+                    ? { bodyClassName: 'toast-report-action' }
+                    : {}),
+            };
             switch (state.message.type) {
                 case 'error':
-                    toast.error(state.message.value, {
-                        onClose: () => handleClose(),
-                        onClick: () => handleClipboard(),
-                    });
+                    toast.error(state.message.value, toastOptions);
                     break;
                 case 'warning':
-                    toast.warning(state.message.value, {
-                        onClose: () => handleClose(),
-                    });
+                    toast.warning(state.message.value, toastOptions);
                     break;
                 case 'success':
-                    toast.success(state.message.value, {
-                        onClose: () => handleClose(),
-                    });
+                    toast.success(state.message.value, toastOptions);
                     break;
                 default:
-                    toast(state.message.value, {
-                        onClose: () => handleClose(),
-                    });
+                    toast(state.message.value, toastOptions);
                     break;
             }
         }
@@ -77,5 +110,5 @@ export default function AppToast() {
             dispatch(message(EMPTY_TOAST));
         }
     }, [state.message]);
-    return _jsx(ToastContainer, { closeOnClick: true });
+    return (_jsxs(_Fragment, { children: [_jsx(ToastContainer, { closeOnClick: state.message.action !== 'report' }), reportModalOpen && (_jsx(ServerErrorReport, { errorContext: reportErrorContext, corpus: state.corpus, onClose: handleReportModalClose, onSent: handleReportSent }))] }));
 }

package/dist/common/AppToast/ToastMessage.d.ts

@@ -1,8 +1,18 @@
+export type ToastAction = 'report' | 'copy';
+export type ServerErrorContext = {
+    status?: number;
+    url?: string;
+    method?: string;
+    responseMessage?: string;
+    responseDescription?: string;
+    requestId?: string;
+    occurredAt?: string;
+};
 export default interface ToastMessage {
     value: string;
     type: string;
+    autoClose?: boolean;
+    action?: ToastAction;
+    errorContext?: ServerErrorContext;
 }
-export declare const EMPTY_TOAST: {
-    value: string;
-    type: string;
-};
+export declare const EMPTY_TOAST: ToastMessage;

package/dist/common/AppToast/style.scss

@@ -0,0 +1,3 @@
+.toast-report-action {
+  cursor: pointer;
+}

package/dist/configs/CommonDispatchBridge.d.ts

@@ -0,0 +1,2 @@
+/** Registers CommonContext.dispatch for non-React callers (e.g. axios interceptors). */
+export default function CommonDispatchBridge(): null;

package/dist/configs/CommonDispatchBridge.js

@@ -0,0 +1,13 @@
+import { useContext, useEffect } from 'react';
+import CommonContext from './CommonContext';
+import { registerCommonDispatch } from './store/commonDispatchBridge';
+/** Registers CommonContext.dispatch for non-React callers (e.g. axios interceptors). */
+export default function CommonDispatchBridge() {
+    const { dispatch } = useContext(CommonContext);
+    useEffect(() => {
+        registerCommonDispatch(dispatch);
+        const noopDispatch = () => undefined;
+        return () => registerCommonDispatch(noopDispatch);
+    }, [dispatch]);
+    return null;
+}

package/dist/configs/api/apiHandledError.d.ts

@@ -0,0 +1,16 @@
+import type { AxiosError } from 'axios';
+export type ApiErrorHandled = AxiosError & {
+    apiErrorHandled?: boolean;
+    /** @deprecated use apiErrorHandled */
+    authErrorHandled?: boolean;
+};
+export declare function isServerError(status: number | undefined): boolean;
+export declare function markApiErrorHandled(error: AxiosError): void;
+/** True when the API client already surfaced a 5xx error via dispatchApiError. */
+export declare function isHandledApiError(reason: unknown): boolean;
+/** @deprecated use markApiErrorHandled */
+export declare const markAuthErrorHandled: typeof markApiErrorHandled;
+/** @deprecated use isHandledApiError */
+export declare const isHandledAuthError: typeof isHandledApiError;
+/** @deprecated use ApiErrorHandled */
+export type AuthErrorHandled = ApiErrorHandled;

package/dist/configs/api/apiHandledError.js

@@ -0,0 +1,22 @@
+export function isServerError(status) {
+    return status !== undefined && status >= 500 && status < 600;
+}
+export function markApiErrorHandled(error) {
+    error.apiErrorHandled = true;
+}
+/** True when the API client already surfaced a 5xx error via dispatchApiError. */
+export function isHandledApiError(reason) {
+    if (!reason || typeof reason !== 'object')
+        return false;
+    const err = reason;
+    if (err.apiErrorHandled || err.authErrorHandled)
+        return true;
+    const status = err.response?.status;
+    if (!err.config || status === undefined)
+        return false;
+    return isServerError(status);
+}
+/** @deprecated use markApiErrorHandled */
+export const markAuthErrorHandled = markApiErrorHandled;
+/** @deprecated use isHandledApiError */
+export const isHandledAuthError = isHandledApiError;

package/dist/configs/api/applyAuthErrorHandling.d.ts

@@ -0,0 +1,15 @@
+import type { AxiosInstance } from 'axios';
+export type AuthErrorHandling = 'toast' | 'redirect' | 'none';
+export type ApplyAuthErrorHandlingOptions = {
+    authErrorHandling?: AuthErrorHandling;
+    /** HTTP statuses that trigger auth handling. Defaults to [401, 403]. */
+    authStatuses?: Array<401 | 403>;
+    redirect?: {
+        on401?: string;
+        on403?: string;
+    };
+    onBeforeRedirect?: (status: 401 | 403) => void;
+    skipAuthHandlingInStorybook?: boolean;
+};
+/** Opt-in 401/403 handling per app. Not part of the shared 5xx dispatchError path. */
+export declare function applyAuthErrorHandling(api: AxiosInstance, options: ApplyAuthErrorHandlingOptions): AxiosInstance;

package/dist/configs/api/applyAuthErrorHandling.js

@@ -0,0 +1,72 @@
+import { markApiErrorHandled } from './apiHandledError';
+import CookieStorage from '../CookieStorage';
+import { resolveAccessDeniedMessage } from './resolveAccessDeniedMessage';
+import { logged, message } from '../store/actions';
+import { getCommonDispatch } from '../store/commonDispatchBridge';
+const isStorybook = () => typeof window !== 'undefined' &&
+    (window.location.port === '6006' ||
+        window.__STORYBOOK__);
+function defaultRedirectUrls() {
+    const publicUrl = import.meta.env.VITE_APP_PUBLIC_URL;
+    return {
+        on401: import.meta.env.VITE_APP_AUTH_URL,
+        on403: import.meta.env.VITE_APP_UNAUTHORIZED_URL ??
+            (publicUrl ? `${publicUrl}/unauthorized` : undefined),
+    };
+}
+function clearAuthStorage() {
+    CookieStorage.removeJwtToken();
+    sessionStorage.clear();
+    localStorage.clear();
+}
+function handleToastAuthError(status) {
+    if (status === 401) {
+        clearAuthStorage();
+        getCommonDispatch()?.(logged(undefined));
+    }
+    getCommonDispatch()?.(message({
+        value: resolveAccessDeniedMessage(),
+        type: 'error',
+    }));
+}
+function handleRedirectAuthError(status, redirect, onBeforeRedirect, skipAuthHandlingInStorybook = true) {
+    if (skipAuthHandlingInStorybook && isStorybook()) {
+        return;
+    }
+    onBeforeRedirect?.(status);
+    if (status === 401) {
+        clearAuthStorage();
+        if (redirect.on401) {
+            window.location.replace(redirect.on401);
+        }
+        return;
+    }
+    if (redirect.on403) {
+        window.location.href = redirect.on403;
+    }
+}
+/** Opt-in 401/403 handling per app. Not part of the shared 5xx dispatchError path. */
+export function applyAuthErrorHandling(api, options) {
+    const { authErrorHandling = 'none', authStatuses = [401, 403], redirect: redirectOverrides, onBeforeRedirect, skipAuthHandlingInStorybook = true, } = options;
+    if (authErrorHandling === 'none') {
+        return api;
+    }
+    const redirect = { ...defaultRedirectUrls(), ...redirectOverrides };
+    api.interceptors.response.use((response) => response, async (error) => {
+        const status = error.response?.status;
+        if (status === 401 || status === 403) {
+            if (!authStatuses.includes(status)) {
+                return Promise.reject(error);
+            }
+            if (authErrorHandling === 'toast') {
+                handleToastAuthError(status);
+            }
+            else if (authErrorHandling === 'redirect') {
+                handleRedirectAuthError(status, redirect, onBeforeRedirect, skipAuthHandlingInStorybook);
+            }
+            markApiErrorHandled(error);
+        }
+        return Promise.reject(error);
+    });
+    return api;
+}

package/dist/configs/api/createApiClient.d.ts

@@ -0,0 +1,16 @@
+import { AxiosInstance, InternalAxiosRequestConfig } from 'axios';
+export type ServerErrorHandling = 'toast' | 'none';
+export type CreateApiClientOptions = {
+    baseURL: string;
+    attachJwt?: boolean;
+    /** How to surface 5xx responses. Defaults to 'toast'. */
+    serverErrorHandling?: ServerErrorHandling;
+    augmentRequest?: (config: InternalAxiosRequestConfig) => InternalAxiosRequestConfig;
+};
+/**
+ * Shared API client: JWT attachment + global 5xx dispatchError toast.
+ * Handled 5xx responses resolve (they do not reach .catch()).
+ * 4xx are left to front-end callers unless the app opts in via
+ * applyAuthErrorHandling() in its local api.ts wrapper.
+ */
+export declare function createApiClient(options: CreateApiClientOptions): AxiosInstance;

package/dist/configs/api/createApiClient.js

@@ -0,0 +1,59 @@
+import axios from 'axios';
+import { isServerError, markApiErrorHandled } from './apiHandledError';
+import CookieStorage from '../CookieStorage';
+import { dispatchServerApiError } from './dispatchApiError';
+const DEFAULT_HEADERS = {
+    'Cache-Control': 'no-cache, no-store, must-revalidate',
+    Pragma: 'no-cache',
+    'Content-Type': 'application/json',
+    Accept: 'application/json',
+};
+function toHandledServerErrorResponse(error) {
+    const status = error.response?.status ?? 500;
+    return {
+        data: null,
+        status,
+        statusText: error.response?.statusText ?? 'Internal Server Error',
+        headers: error.response?.headers ?? {},
+        config: error.config,
+    };
+}
+/**
+ * Shared API client: JWT attachment + global 5xx dispatchError toast.
+ * Handled 5xx responses resolve (they do not reach .catch()).
+ * 4xx are left to front-end callers unless the app opts in via
+ * applyAuthErrorHandling() in its local api.ts wrapper.
+ */
+export function createApiClient(options) {
+    const { baseURL, attachJwt = true, serverErrorHandling = 'toast', augmentRequest, } = options;
+    const api = axios.create({
+        headers: DEFAULT_HEADERS,
+        baseURL,
+    });
+    api.interceptors.response.use((response) => response, async (error) => {
+        const status = error.response?.status;
+        if (isServerError(status) && serverErrorHandling === 'toast') {
+            dispatchServerApiError({ err: error });
+            markApiErrorHandled(error);
+            return toHandledServerErrorResponse(error);
+        }
+        if (error.status === null) {
+            console.log(JSON.stringify(error));
+        }
+        return Promise.reject(error);
+    });
+    api.interceptors.request.use((config) => {
+        if (!config?.headers) {
+            throw new Error('no header available');
+        }
+        if (attachJwt) {
+            const token = CookieStorage.getJwtToken();
+            if (token) {
+                // eslint-disable-next-line no-param-reassign
+                config.headers.Authorization = `Bearer ${token}`;
+            }
+        }
+        return augmentRequest ? augmentRequest(config) : config;
+    });
+    return api;
+}

package/dist/configs/api/dispatchApiError.d.ts

@@ -0,0 +1,16 @@
+import type { AxiosResponseHeaders, RawAxiosResponseHeaders } from 'axios';
+import type { TFunction } from 'i18next';
+type DispatchApiErrorOptions = {
+    err: unknown;
+    t?: TFunction;
+    key?: string;
+    autoClose?: boolean;
+};
+export declare function extractRequestId(headers?: RawAxiosResponseHeaders | AxiosResponseHeaders): string | undefined;
+export declare function dispatchApiError({ err, t, key, autoClose, }: DispatchApiErrorOptions): void;
+/** Persistent 5xx toast that opens the server-error report modal on click. */
+export declare function dispatchServerApiError({ err, t, }: {
+    err: unknown;
+    t?: TFunction;
+}): void;
+export {};

package/dist/configs/api/dispatchApiError.js

@@ -0,0 +1,71 @@
+import i18n from 'i18next';
+import { getErrorMessageValue } from '../useMessageUtils';
+import { message } from '../store/actions';
+import { getCommonDispatch } from '../store/commonDispatchBridge';
+const REQUEST_ID_HEADERS = [
+    'x-request-id',
+    'x-correlation-id',
+    'traceparent',
+    'x-amzn-trace-id',
+];
+function normalizeHeaderValue(value) {
+    if (typeof value === 'string' && value.trim()) {
+        return value.trim();
+    }
+    if (Array.isArray(value) && typeof value[0] === 'string' && value[0].trim()) {
+        return value[0].trim();
+    }
+    return undefined;
+}
+export function extractRequestId(headers) {
+    if (!headers || typeof headers !== 'object') {
+        return undefined;
+    }
+    const normalized = Object.fromEntries(Object.entries(headers).map(([key, value]) => [key.toLowerCase(), value]));
+    for (const header of REQUEST_ID_HEADERS) {
+        const value = normalizeHeaderValue(normalized[header]);
+        if (value) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function buildServerErrorContext(err) {
+    if (!err || typeof err !== 'object' || !('response' in err)) {
+        return {};
+    }
+    const axiosErr = err;
+    const data = axiosErr.response?.data;
+    return {
+        status: axiosErr.response?.status,
+        url: axiosErr.config?.url,
+        method: axiosErr.config?.method?.toUpperCase(),
+        responseMessage: typeof data?.message === 'string' ? data.message : undefined,
+        responseDescription: typeof data?.description === 'string' ? data.description : undefined,
+        requestId: extractRequestId(axiosErr.response?.headers),
+        occurredAt: new Date().toISOString(),
+    };
+}
+export function dispatchApiError({ err, t, key, autoClose, }) {
+    const translate = t ?? i18n.t.bind(i18n);
+    const value = getErrorMessageValue({ err, t: translate, key });
+    getCommonDispatch()?.(message({
+        value,
+        type: 'error',
+        autoClose,
+        action: 'copy',
+    }));
+}
+/** Persistent 5xx toast that opens the server-error report modal on click. */
+export function dispatchServerApiError({ err, t, }) {
+    const translate = t ?? i18n.t.bind(i18n);
+    const value = translate('server.error.report.prompt', { ns: 'common' });
+    const errorContext = buildServerErrorContext(err);
+    getCommonDispatch()?.(message({
+        value,
+        type: 'error',
+        autoClose: false,
+        action: 'report',
+        errorContext,
+    }));
+}

package/dist/configs/api/index.d.ts

@@ -0,0 +1,18 @@
+/** Platform API roots (formerly separate env vars per service). */
+export declare const platformApi: {
+    base: string;
+    revision: string;
+    catalog: string;
+    editor: string;
+};
+export declare const parserApiBase: string;
+declare const api: import("axios").AxiosInstance;
+export { createApiClient } from './createApiClient';
+export type { CreateApiClientOptions, ServerErrorHandling } from './createApiClient';
+export { applyAuthErrorHandling } from './applyAuthErrorHandling';
+export type { ApplyAuthErrorHandlingOptions, AuthErrorHandling, } from './applyAuthErrorHandling';
+export { isHandledApiError, isHandledAuthError, markApiErrorHandled, markAuthErrorHandled, } from './apiHandledError';
+export type { ApiErrorHandled, AuthErrorHandled } from './apiHandledError';
+export { dispatchApiError, dispatchServerApiError } from './dispatchApiError';
+export { resolveAccessDeniedMessage } from './resolveAccessDeniedMessage';
+export default api;

package/dist/configs/api/index.js

@@ -0,0 +1,18 @@
+import { applyAuthErrorHandling } from './applyAuthErrorHandling';
+import { createApiClient } from './createApiClient';
+const platformApiBase = import.meta.env.VITE_APP_PLATFORM_API;
+/** Platform API roots (formerly separate env vars per service). */
+export const platformApi = {
+    base: platformApiBase,
+    revision: `${platformApiBase}/revision`,
+    catalog: `${platformApiBase}/catalog`,
+    editor: `${platformApiBase}/editor`,
+};
+export const parserApiBase = import.meta.env.VITE_APP_PARSER_API;
+const api = applyAuthErrorHandling(createApiClient({ baseURL: platformApiBase }), { authErrorHandling: 'redirect' });
+export { createApiClient } from './createApiClient';
+export { applyAuthErrorHandling } from './applyAuthErrorHandling';
+export { isHandledApiError, isHandledAuthError, markApiErrorHandled, markAuthErrorHandled, } from './apiHandledError';
+export { dispatchApiError, dispatchServerApiError } from './dispatchApiError';
+export { resolveAccessDeniedMessage } from './resolveAccessDeniedMessage';
+export default api;

package/dist/configs/api/resolveAccessDeniedMessage.d.ts

@@ -0,0 +1,2 @@
+/** Resolves the access-denied toast message, with BaseTexts fallback when i18n is not ready. */
+export declare function resolveAccessDeniedMessage(): string;

package/dist/configs/api/resolveAccessDeniedMessage.js

@@ -0,0 +1,19 @@
+import i18n from 'i18next';
+import { BaseTexts } from '../localization/BaseTexts';
+const ACCESS_DENIED_KEY = 'error.access.authorization';
+function resolveLocale() {
+    const lng = i18n.resolvedLanguage || i18n.language || 'en';
+    if (lng.startsWith('pt'))
+        return 'pt-BR';
+    if (lng.startsWith('it'))
+        return 'it';
+    return 'en';
+}
+/** Resolves the access-denied toast message, with BaseTexts fallback when i18n is not ready. */
+export function resolveAccessDeniedMessage() {
+    const translated = i18n.t(ACCESS_DENIED_KEY, { ns: 'message' });
+    if (translated && translated !== ACCESS_DENIED_KEY) {
+        return translated;
+    }
+    return BaseTexts[resolveLocale()][ACCESS_DENIED_KEY];
+}

package/dist/configs/index.d.ts

@@ -1,6 +1,10 @@
 export { CommonProvider } from "./CommonContext";
 export { default as CommonContext } from "./CommonContext";
+export { default as CommonDispatchBridge } from "./CommonDispatchBridge";
 export { default as CookieStorage } from "./CookieStorage";
+export { createApiClient, applyAuthErrorHandling, dispatchApiError, dispatchServerApiError, resolveAccessDeniedMessage, isHandledApiError, isHandledAuthError, markApiErrorHandled, markAuthErrorHandled, platformApi, parserApiBase, } from "./api";
+export type { ApplyAuthErrorHandlingOptions, AuthErrorHandling, CreateApiClientOptions, ServerErrorHandling, ApiErrorHandled, AuthErrorHandled, } from "./api";
+export { getCommonDispatch, registerCommonDispatch, } from "./store/commonDispatchBridge";
 export { commonResources, featureResources, mergeResources, commonLocalization, } from "./Localization";
 export { default as ProfileService } from "./services/ProfileService";
 export type { Corpus, CorpusRequest, Github } from "./types/Corpus";
@@ -30,4 +34,4 @@ export { useLoggedUtils } from "./useLoggedUtils";
 export { useMessageUtils } from "./useMessageUtils";
 export { useTourUtils } from "./useTourUtils";
 export { useDriverTour, loadKnowledgeBase, defaultMatchPathnames, buildAnchorMap, flattenWorkflowSteps, getWorkflowsForPath, buildDriveSteps, createTourDriver, hasMatchingWorkflow, resolveAnchor, resolveAnchorById, waitForSelector, localizeKnowledgeBase, pickLocalizedString, resolveTourLocale, TOUR_FALLBACK_LOCALE, TOUR_LOCALES, } from "./tour";
-export type { AnchorSelector, KnowledgeBase, KnowledgeBaseRaw, LocalizedString, PopoverSide, ResolveKnowledgeBaseUrl, TourAnchor, TourButtonLabels, TourStep, TourStepCopy, TourStepStructural, TourWorkflow, TourWorkflowRaw, UseDriverTourOptions, } from "./tour";
+export type { AnchorSelector, Driver, KnowledgeBase, KnowledgeBaseRaw, LocalizedString, PopoverSide, ResolveKnowledgeBaseUrl, TourAnchor, TourButtonLabels, TourStep, TourStepCopy, TourStepStructural, TourWorkflow, TourWorkflowRaw, UseDriverTourOptions, } from "./tour";

package/dist/configs/index.js

@@ -1,6 +1,9 @@
 export { CommonProvider } from "./CommonContext";
 export { default as CommonContext } from "./CommonContext";
+export { default as CommonDispatchBridge } from "./CommonDispatchBridge";
 export { default as CookieStorage } from "./CookieStorage";
+export { createApiClient, applyAuthErrorHandling, dispatchApiError, dispatchServerApiError, resolveAccessDeniedMessage, isHandledApiError, isHandledAuthError, markApiErrorHandled, markAuthErrorHandled, platformApi, parserApiBase, } from "./api";
+export { getCommonDispatch, registerCommonDispatch, } from "./store/commonDispatchBridge";
 export { commonResources, featureResources, mergeResources, commonLocalization, } from "./Localization";
 export { default as ProfileService } from "./services/ProfileService";
 export { CorpusStatusNames } from "./types/CorpusStatus";

package/dist/configs/localization/CommonTexts.d.ts

@@ -42,6 +42,14 @@ export declare const CommonTexts: {
         'user.status.visitor': string;
         'update.success': string;
         'internal.server.error': string;
+        'server.error.report.prompt': string;
+        'server.error.report.modal.title': string;
+        'server.error.report.modal.subtitle': string;
+        'server.error.report.modal.placeholder': string;
+        'server.error.report.modal.send': string;
+        'server.error.report.validation': string;
+        'server.error.report.send.failed': string;
+        'server.error.report.sent': string;
         'table.label.rows-page': string;
         'table.label.items': string;
         'table.pagination.scroll-strip-left': string;
@@ -121,6 +129,14 @@ export declare const CommonTexts: {
         'user.status.visitor': string;
         'update.success': string;
         'internal.server.error': string;
+        'server.error.report.prompt': string;
+        'server.error.report.modal.title': string;
+        'server.error.report.modal.subtitle': string;
+        'server.error.report.modal.placeholder': string;
+        'server.error.report.modal.send': string;
+        'server.error.report.validation': string;
+        'server.error.report.send.failed': string;
+        'server.error.report.sent': string;
         'table.label.rows-page': string;
         'table.label.items': string;
         'table.pagination.scroll-strip-left': string;
@@ -200,6 +216,14 @@ export declare const CommonTexts: {
         'user.status.visitor': string;
         'update.success': string;
         'internal.server.error': string;
+        'server.error.report.prompt': string;
+        'server.error.report.modal.title': string;
+        'server.error.report.modal.subtitle': string;
+        'server.error.report.modal.placeholder': string;
+        'server.error.report.modal.send': string;
+        'server.error.report.validation': string;
+        'server.error.report.send.failed': string;
+        'server.error.report.sent': string;
         'table.label.rows-page': string;
         'table.label.items': string;
         'table.pagination.scroll-strip-left': string;

package/dist/configs/localization/CommonTexts.js

@@ -42,6 +42,14 @@ export const CommonTexts = {
         'user.status.visitor': 'Visitor',
         'update.success': 'saved!',
         'internal.server.error': 'An unexpected error occurred. Contact the administrator.',
+        'server.error.report.prompt': 'Something went wrong on our end. Click here to tell us what happened.',
+        'server.error.report.modal.title': 'Report a problem',
+        'server.error.report.modal.subtitle': 'Describe what you were doing when the error occurred. We will use your message to investigate.',
+        'server.error.report.modal.placeholder': 'What were you trying to do? Any extra details help us reproduce the issue.',
+        'server.error.report.modal.send': 'Send report',
+        'server.error.report.validation': 'Please describe what happened before sending.',
+        'server.error.report.send.failed': 'We could not send your report. Please try again in a moment.',
+        'server.error.report.sent': 'Thank you — your report was sent.',
         'table.label.rows-page': 'Items per page',
         'table.label.items': '{{first}} - {{last}} of {{total}}',
         'table.pagination.scroll-strip-left': 'Scroll page numbers left',
@@ -121,6 +129,14 @@ export const CommonTexts = {
         'user.status.visitor': 'Visitante',
         'update.success': 'salvo!',
         'internal.server.error': 'Ocorreu um erro inesperado. Entre em contato com o administrador.',
+        'server.error.report.prompt': 'Algo deu errado do nosso lado. Clique aqui para nos contar o que aconteceu.',
+        'server.error.report.modal.title': 'Reportar um problema',
+        'server.error.report.modal.subtitle': 'Descreva o que você estava fazendo quando o erro ocorreu. Usaremos sua mensagem para investigar.',
+        'server.error.report.modal.placeholder': 'O que você estava tentando fazer? Detalhes extras nos ajudam a reproduzir o problema.',
+        'server.error.report.modal.send': 'Enviar relatório',
+        'server.error.report.validation': 'Descreva o que aconteceu antes de enviar.',
+        'server.error.report.send.failed': 'Não foi possível enviar seu relatório. Tente novamente em instantes.',
+        'server.error.report.sent': 'Obrigado — seu relatório foi enviado.',
         'table.label.rows-page': 'Itens por página',
         'table.label.items': '{{first}} - {{last}} de {{total}}',
         'table.pagination.scroll-strip-left': 'Rolar números das páginas à esquerda',
@@ -200,6 +216,14 @@ export const CommonTexts = {
         'user.status.visitor': 'Visitatore',
         'update.success': 'salvato!',
         'internal.server.error': "Si è verificato un errore inaspettato. Contatta l'amministratore.",
+        'server.error.report.prompt': 'Qualcosa è andato storto da parte nostra. Clicca qui per raccontarci cosa è successo.',
+        'server.error.report.modal.title': 'Segnala un problema',
+        'server.error.report.modal.subtitle': 'Descrivi cosa stavi facendo quando si è verificato l\'errore. Useremo il tuo messaggio per indagare.',
+        'server.error.report.modal.placeholder': 'Cosa stavi cercando di fare? Dettagli aggiuntivi ci aiutano a riprodurre il problema.',
+        'server.error.report.modal.send': 'Invia segnalazione',
+        'server.error.report.validation': 'Descrivi cosa è successo prima di inviare.',
+        'server.error.report.send.failed': 'Impossibile inviare la segnalazione. Riprova tra poco.',
+        'server.error.report.sent': 'Grazie — la tua segnalazione è stata inviata.',
         'table.label.rows-page': 'Elementi per pagina',
         'table.label.items': '{{first}} - {{last}} di {{total}}',
         'table.pagination.scroll-strip-left': 'Scorri i numeri di pagina a sinistra',

package/dist/configs/services/ErrorReportService.d.ts

@@ -0,0 +1,34 @@
+import type { ServerErrorContext } from '../../common/AppToast/ToastMessage';
+export type ReportSendContext = {
+    locale?: string;
+    corpusUid?: string;
+    corpusName?: string;
+};
+type ClientContext = {
+    timestamp?: string;
+    timezone?: string;
+    appUrl?: string;
+    environment?: string;
+    locale?: string;
+    corpusUid?: string;
+    corpusName?: string;
+    userAgent?: string;
+    viewport?: string;
+    screen?: string;
+    referrer?: string;
+    pageUrl?: string;
+};
+type ErrorReportPayload = {
+    userMessage: string;
+    errorContext?: ServerErrorContext;
+    sendContext?: ReportSendContext;
+};
+declare function send({ userMessage, errorContext, sendContext, }: ErrorReportPayload): Promise<import("axios").AxiosResponse<any, {
+    userMessage: string;
+    errorContext: ServerErrorContext | undefined;
+    clientContext: ClientContext;
+}, {}, any>>;
+declare const ErrorReportService: {
+    send: typeof send;
+};
+export default ErrorReportService;

package/dist/configs/services/ErrorReportService.js

@@ -0,0 +1,63 @@
+import { createApiClient } from '../api/createApiClient';
+function getFunctionsApiBase() {
+    const explicit = import.meta.env.VITE_APP_FUNCTIONS_API;
+    if (explicit?.trim()) {
+        return explicit.trim().replace(/\/+$/, '');
+    }
+    const origin = import.meta.env.VITE_APP_ORIGIN;
+    if (origin?.trim()) {
+        return `${origin.trim().replace(/\/+$/, '')}/api/functions`;
+    }
+    return undefined;
+}
+function buildClientContext(sendContext) {
+    const now = new Date();
+    const timezone = typeof Intl !== 'undefined'
+        ? Intl.DateTimeFormat().resolvedOptions().timeZone
+        : undefined;
+    const clientContext = {
+        timestamp: now.toISOString(),
+        timezone,
+        environment: import.meta.env.MODE,
+        locale: sendContext?.locale,
+        corpusUid: sendContext?.corpusUid,
+        corpusName: sendContext?.corpusName,
+    };
+    const appUrl = import.meta.env.VITE_APP_PUBLIC_URL;
+    if (appUrl) {
+        clientContext.appUrl = appUrl;
+    }
+    if (typeof navigator !== 'undefined' && navigator.userAgent) {
+        clientContext.userAgent = navigator.userAgent;
+    }
+    if (typeof window !== 'undefined') {
+        clientContext.pageUrl = window.location.href;
+        clientContext.viewport = `${window.innerWidth}×${window.innerHeight}`;
+        const dpr = window.devicePixelRatio ?? 1;
+        clientContext.screen =
+            typeof screen !== 'undefined'
+                ? `${screen.width}×${screen.height} (DPR: ${dpr})`
+                : 'unknown';
+    }
+    if (typeof document !== 'undefined' && document.referrer) {
+        clientContext.referrer = document.referrer;
+    }
+    return clientContext;
+}
+function send({ userMessage, errorContext, sendContext, }) {
+    const functionsApiBase = getFunctionsApiBase();
+    if (!functionsApiBase) {
+        return Promise.reject(new Error('functions.api.unavailable'));
+    }
+    return createApiClient({
+        baseURL: functionsApiBase,
+        attachJwt: true,
+        serverErrorHandling: 'none',
+    }).post('/error-report', {
+        userMessage,
+        errorContext,
+        clientContext: buildClientContext(sendContext),
+    });
+}
+const ErrorReportService = { send };
+export default ErrorReportService;

package/dist/configs/store/commonDispatchBridge.d.ts

@@ -0,0 +1,6 @@
+import type { Dispatch } from 'react';
+import type { StoreAction } from './types';
+type CommonDispatch = Dispatch<StoreAction>;
+export declare function registerCommonDispatch(dispatch: CommonDispatch): void;
+export declare function getCommonDispatch(): CommonDispatch | null;
+export {};

package/dist/configs/store/commonDispatchBridge.js

@@ -0,0 +1,7 @@
+let commonDispatch = null;
+export function registerCommonDispatch(dispatch) {
+    commonDispatch = dispatch;
+}
+export function getCommonDispatch() {
+    return commonDispatch;
+}

package/dist/configs/tour/index.d.ts

@@ -4,3 +4,4 @@ export { buildDriveSteps, createTourDriver, hasMatchingWorkflow, } from './drive
 export { localizeKnowledgeBase, pickLocalizedString, resolveTourLocale, TOUR_FALLBACK_LOCALE, TOUR_LOCALES, } from './localizeKnowledgeBase';
 export { resolveAnchor, resolveAnchorById, waitForSelector, } from './anchorResolver';
 export type { AnchorSelector, KnowledgeBase, KnowledgeBaseRaw, LocalizedString, PopoverSide, ResolveKnowledgeBaseUrl, TourAnchor, TourButtonLabels, TourStep, TourStepCopy, TourStepStructural, TourWorkflow, TourWorkflowRaw, UseDriverTourOptions, } from './types';
+export type { Driver } from 'driver.js';

package/dist/configs/useMessageUtils.js

@@ -1,4 +1,5 @@
 import { useContext } from "react";
+import { dispatchApiError } from "./api/dispatchApiError";
 import { message, silentLoading, toastLoading } from "../configs/store/actions";
 import CommonContext from "./CommonContext";
 const translateErrorValue = (t, namespace, rawValue) => {
@@ -49,8 +50,7 @@ export const useMessageUtils = () => {
             : toastLoading(val));
     };
     const dispatchError = ({ err, t, key }) => {
-        const value = getErrorMessageValue({ err, t, key });
-        dispatch(message({ value, type: "error" }));
+        dispatchApiError({ err, t, key });
     };
     const dispatchMessage = ({ key, ns, t }) => {
         const entry = ns ? `${ns}:${key}` : `message:${key}`;

package/dist/features/ServerErrorReport/ServerErrorReport.d.ts

@@ -0,0 +1,11 @@
+import type { ServerErrorContext } from '../../common/AppToast/ToastMessage';
+import type { Corpus } from '../../configs/types/Corpus';
+import './styles.scss';
+type Props = {
+    errorContext?: ServerErrorContext;
+    corpus?: Corpus;
+    onClose: () => void;
+    onSent: () => void;
+};
+export default function ServerErrorReport({ errorContext, corpus, onClose, onSent, }: Props): import("react").JSX.Element;
+export {};

package/dist/features/ServerErrorReport/ServerErrorReport.js

@@ -0,0 +1,49 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import axios from 'axios';
+import { useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import AppModal from '../../common/AppModal/AppModal';
+import AppTextArea from '../../common/AppTextArea/AppTextArea';
+import ErrorReportService from '../../configs/services/ErrorReportService';
+import './styles.scss';
+export default function ServerErrorReport({ errorContext, corpus, onClose, onSent, }) {
+    const { t, i18n } = useTranslation('common');
+    const [userMessage, setUserMessage] = useState('');
+    const [sending, setSending] = useState(false);
+    const [sendError, setSendError] = useState(null);
+    const handleSend = () => {
+        if (!userMessage.trim()) {
+            setSendError(t('server.error.report.validation'));
+            return;
+        }
+        setSending(true);
+        setSendError(null);
+        ErrorReportService.send({
+            userMessage,
+            errorContext,
+            sendContext: {
+                locale: i18n.resolvedLanguage || i18n.language,
+                corpusUid: corpus?.uid,
+                corpusName: corpus?.name,
+            },
+        })
+            .then(() => {
+            onSent();
+        })
+            .catch((error) => {
+            console.error('Failed to send server error report:', axios.isAxiosError(error)
+                ? {
+                    message: error.message,
+                    status: error.response?.status,
+                    data: error.response?.data,
+                    url: error.config?.url,
+                }
+                : error);
+            setSendError(t('server.error.report.send.failed'));
+        })
+            .finally(() => {
+            setSending(false);
+        });
+    };
+    return (_jsx(AppModal, { title: t('server.error.report.modal.title'), subtitle: t('server.error.report.modal.subtitle'), close: onClose, confirm: handleSend, disableConfirm: sending || !userMessage.trim(), confirmLabel: t('server.error.report.modal.send'), className: "server-error-report-modal", children: _jsxs("div", { className: "server-error-report-modal__body", children: [_jsx(AppTextArea, { value: userMessage, onChange: (e) => setUserMessage(e.target.value), placeholder: t('server.error.report.modal.placeholder'), rows: 6, disabled: sending, "aria-label": t('server.error.report.modal.placeholder') }), sendError && (_jsx("p", { className: "server-error-report-modal__error", role: "alert", children: sendError }))] }) }));
+}

package/dist/features/ServerErrorReport/index.d.ts

@@ -0,0 +1,2 @@
+import ServerErrorReport from './ServerErrorReport';
+export default ServerErrorReport;

package/dist/features/ServerErrorReport/index.js

@@ -0,0 +1,2 @@
+import ServerErrorReport from './ServerErrorReport';
+export default ServerErrorReport;

package/dist/features/ServerErrorReport/styles.scss

@@ -0,0 +1,20 @@
+.server-error-report-modal {
+  &__body {
+    display: flex;
+    flex-direction: column;
+    gap: var(--spacing-200);
+  }
+
+  &__error {
+    margin: 0;
+    color: var(--text-danger);
+    @include body-small-1;
+  }
+
+  .app-text-area {
+    min-height: 160px;
+    border: var(--border-default);
+    border-radius: var(--radius-100);
+    background-color: var(--background-default);
+  }
+}

package/dist/shell/Base/ErrorBoundary.js

@@ -1,6 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
 import { useTranslation } from 'react-i18next';
+import { isHandledApiError } from '../../configs/api';
 import logo from './logo.png';
 import './style.scss';
 export default function ErrorBoundary({ children }) {
@@ -9,27 +10,30 @@ export default function ErrorBoundary({ children }) {
         hasError: false,
         error: null,
     });
-    // Hook to simulate the behavior of componentDidCatch
     useEffect(() => {
         const handleError = (error) => {
             console.error('Caught by ErrorBoundary:', error);
             setState({ hasError: true, error });
         };
-        // Catch unhandled promise rejections globally
-        window.addEventListener('unhandledrejection', (event) => {
+        const onUnhandledRejection = (event) => {
+            if (isHandledApiError(event.reason)) {
+                event.preventDefault();
+                return;
+            }
             handleError(event.reason);
-        });
-        // Catch uncaught errors globally
-        window.addEventListener('error', (event) => {
+        };
+        const onError = (event) => {
+            if (isHandledApiError(event.error)) {
+                event.preventDefault();
+                return;
+            }
             handleError(event.error);
-        });
+        };
+        window.addEventListener('unhandledrejection', onUnhandledRejection);
+        window.addEventListener('error', onError);
         return () => {
-            window.removeEventListener('unhandledrejection', (event) => {
-                handleError(event.reason);
-            });
-            window.removeEventListener('error', (event) => {
-                handleError(event.error);
-            });
+            window.removeEventListener('unhandledrejection', onUnhandledRejection);
+            window.removeEventListener('error', onError);
         };
     }, []);
     if (state.hasError && state.error) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tycho-components",
   "private": false,
-  "version": "0.38.7",
+  "version": "0.39.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -49,7 +49,6 @@
   "dependencies": {
     "@hookform/resolvers": "^5.2.2",
     "@tanstack/react-table": "^8.20.6",
-    "axios": "^1.13.6",
     "classnames": "^2.5.1",
     "cytoscape": "^3.28.1",
     "cytoscape-dagre": "^2.5.0",
@@ -74,6 +73,7 @@
     "@emotion/styled": "^11.13.0",
     "@mui/icons-material": "7.3.0",
     "@mui/material": "7.3.0",
+    "axios": "^1.13.0",
     "i18next": "^23.3.0",
     "i18next-browser-languagedetector": "^7.1.0",
     "react": ">=17 <19",
@@ -101,6 +101,7 @@
     "@typescript-eslint/eslint-plugin": "^5.62.0",
     "@typescript-eslint/parser": "^5.62.0",
     "@vitejs/plugin-react": "^5.0.0",
+    "axios": "^1.13.6",
     "eslint": "^8.57.1",
     "eslint-plugin-react-hooks": "^4.6.2",
     "eslint-plugin-react-refresh": "^0.4.1",

package/dist/configs/api.d.ts

@@ -1,10 +0,0 @@
-/** Platform API roots (formerly separate env vars per service). */
-export declare const platformApi: {
-    base: string;
-    revision: string;
-    catalog: string;
-    editor: string;
-};
-export declare const parserApiBase: string;
-declare const api: import("axios").AxiosInstance;
-export default api;

package/dist/configs/api.js

@@ -1,52 +0,0 @@
-import axios from 'axios';
-import CookieStorage from './CookieStorage';
-const platformApiBase = import.meta.env.VITE_APP_PLATFORM_API;
-/** Platform API roots (formerly separate env vars per service). */
-export const platformApi = {
-    base: platformApiBase,
-    revision: `${platformApiBase}/revision`,
-    catalog: `${platformApiBase}/catalog`,
-    editor: `${platformApiBase}/editor`,
-};
-export const parserApiBase = import.meta.env.VITE_APP_PARSER_API;
-const api = axios.create({
-    headers: {
-        'Cache-Control': 'no-cache, no-store, must-revalidate',
-        Pragma: 'no-cache',
-        'Content-Type': 'application/json',
-        Accept: 'application/json',
-    },
-    baseURL: platformApiBase,
-});
-const isStorybook = () => typeof window !== 'undefined' &&
-    (window.location.port === '6006' ||
-        window.__STORYBOOK__);
-api.interceptors.response.use((response) => response, async (error) => {
-    if (error.response?.status === 401) {
-        CookieStorage.removeJwtToken();
-        sessionStorage.clear();
-        localStorage.clear();
-        if (!isStorybook()) {
-            window.location.replace(import.meta.env.VITE_APP_AUTH_URL);
-        }
-    }
-    else if (error.response?.status === 403 && !isStorybook()) {
-        window.location.href = import.meta.env.VITE_APP_UNAUTHORIZED_URL;
-    }
-    else if (error.status === null) {
-        console.log(JSON.stringify(error));
-    }
-    return Promise.reject(error);
-});
-api.interceptors.request.use((config) => {
-    if (!config?.headers) {
-        throw new Error('no header available');
-    }
-    const token = CookieStorage.getJwtToken();
-    if (!token)
-        return config;
-    // eslint-disable-next-line no-param-reassign
-    config.headers.Authorization = `Bearer ${token}`;
-    return config;
-});
-export default api;