@ifto/mantine-kit 0.0.0-stage → 0.2.0

package/dist/hook/useIsMobile.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tells whether the user is on a mobile device.
+ * @return true if the screen has the width of a mobile device, false otherwise
+ */
+export declare const useIsMobile: () => boolean;

package/dist/hook/useIsMobile.js

@@ -0,0 +1,16 @@
+"use client";
+import { useMediaQuery } from "@mantine/hooks";
+// src/hook/useIsMobile.ts
+/** Maximum screen width considered a mobile device. */
+var MOBILE_MEDIA_QUERY = "(max-width: 768px)";
+/**
+* Tells whether the user is on a mobile device.
+* @return true if the screen has the width of a mobile device, false otherwise
+*/
+var useIsMobile = () => {
+	const isMobile = useMediaQuery(MOBILE_MEDIA_QUERY);
+	return isMobile == void 0 ? false : isMobile;
+};
+export { useIsMobile };
+
+//# sourceMappingURL=useIsMobile.js.map

package/dist/hook/useIsMobile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIsMobile.js","names":[],"sources":["../../src/hook/useIsMobile.ts"],"sourcesContent":["import { useMediaQuery } from '@mantine/hooks';\n\n/** Maximum screen width considered a mobile device. */\nconst MOBILE_MEDIA_QUERY = '(max-width: 768px)';\n\n/**\n * Tells whether the user is on a mobile device.\n * @return true if the screen has the width of a mobile device, false otherwise\n */\nexport const useIsMobile = () => {\n    const isMobile = useMediaQuery(MOBILE_MEDIA_QUERY);\n\n    /* `useMediaQuery` returns `undefined` before the first measurement. The caller expects just true or false, so it is\n       treated as false. */\n    return isMobile == undefined ? false : isMobile;\n};\n"],"mappings":";;;;AAGA,IAAM,qBAAqB;;;;;AAM3B,IAAa,oBAAoB;CAC7B,MAAM,WAAW,cAAc,kBAAkB;CAIjD,OAAO,YAAY,KAAA,IAAY,QAAQ;AAC3C"}

package/dist/hook/useKeyedService.d.ts

@@ -0,0 +1,22 @@
+/** Key of a fetch (e.g. the year being queried), which tells which selection a result belongs to. */
+export type ServiceKey = string | number;
+/** Values returned by {@link useKeyedService}. */
+export type UseKeyedService<T> = {
+    /** Data of the fetch of the current key; `undefined` while it has not finished or if it failed. */
+    data?: T;
+    /** Error of the fetch of the current key; `undefined` if it has not finished yet or succeeded. */
+    error?: unknown;
+    /** Whether the fetch of the current key has not finished yet. */
+    loading: boolean;
+};
+/**
+ * Fetches data that depends on a key (e.g. a filter of the screen) and exposes only the result of the current key.
+ * When the key changes, the data and the error of the previous fetch are no longer exposed and `loading` becomes
+ * `true` until the new fetch finishes, so the screen never shows data of another selection. A response that arrives
+ * after the key changed is discarded.
+ * @param key key of the fetch; a new key triggers a new fetch
+ * @param fetchMethod function that fetches the data of a key. It must be stable (e.g. defined outside the component),
+ *        since a new function also triggers a new fetch
+ * @return the data, the error and the loading state of the current key
+ */
+export declare function useKeyedService<T>(key: ServiceKey, fetchMethod: (key: ServiceKey) => Promise<T>): UseKeyedService<T>;

package/dist/hook/useKeyedService.js

@@ -0,0 +1,38 @@
+"use client";
+import { useEffect, useState } from "react";
+// src/hook/useKeyedService.ts
+/**
+* Fetches data that depends on a key (e.g. a filter of the screen) and exposes only the result of the current key.
+* When the key changes, the data and the error of the previous fetch are no longer exposed and `loading` becomes
+* `true` until the new fetch finishes, so the screen never shows data of another selection. A response that arrives
+* after the key changed is discarded.
+* @param key key of the fetch; a new key triggers a new fetch
+* @param fetchMethod function that fetches the data of a key. It must be stable (e.g. defined outside the component),
+*        since a new function also triggers a new fetch
+* @return the data, the error and the loading state of the current key
+*/
+function useKeyedService(key, fetchMethod) {
+	const [result, setResult] = useState();
+	useEffect(() => {
+		let obsolete = false;
+		fetchMethod(key).then((data) => !obsolete && setResult({
+			key,
+			data
+		})).catch((error) => !obsolete && setResult({
+			key,
+			error
+		}));
+		return () => {
+			obsolete = true;
+		};
+	}, [key, fetchMethod]);
+	const current = result?.key === key ? result : void 0;
+	return {
+		data: current?.data,
+		error: current?.error,
+		loading: !current
+	};
+}
+export { useKeyedService };
+
+//# sourceMappingURL=useKeyedService.js.map

package/dist/hook/useKeyedService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useKeyedService.js","names":[],"sources":["../../src/hook/useKeyedService.ts"],"sourcesContent":["import { useEffect, useState } from 'react';\n\n/** Key of a fetch (e.g. the year being queried), which tells which selection a result belongs to. */\nexport type ServiceKey = string | number;\n\n/** Values returned by {@link useKeyedService}. */\nexport type UseKeyedService<T> = {\n    /** Data of the fetch of the current key; `undefined` while it has not finished or if it failed. */\n    data?: T;\n\n    /** Error of the fetch of the current key; `undefined` if it has not finished yet or succeeded. */\n    error?: unknown;\n\n    /** Whether the fetch of the current key has not finished yet. */\n    loading: boolean;\n};\n\n/** Result of a fetch, kept with the key that was queried. */\ntype KeyedResult<T> = { key: ServiceKey; data?: T; error?: unknown };\n\n/**\n * Fetches data that depends on a key (e.g. a filter of the screen) and exposes only the result of the current key.\n * When the key changes, the data and the error of the previous fetch are no longer exposed and `loading` becomes\n * `true` until the new fetch finishes, so the screen never shows data of another selection. A response that arrives\n * after the key changed is discarded.\n * @param key key of the fetch; a new key triggers a new fetch\n * @param fetchMethod function that fetches the data of a key. It must be stable (e.g. defined outside the component),\n *        since a new function also triggers a new fetch\n * @return the data, the error and the loading state of the current key\n */\nexport function useKeyedService<T>(key: ServiceKey, fetchMethod: (key: ServiceKey) => Promise<T>): UseKeyedService<T> {\n    const [result, setResult] = useState<KeyedResult<T>>();\n\n    useEffect(() => {\n        // If the key changes before the fetch finishes, its response cannot replace the one of the new key.\n        let obsolete = false;\n        fetchMethod(key)\n            .then(data => !obsolete && setResult({ key, data }))\n            .catch(error => !obsolete && setResult({ key, error }));\n\n        return () => {\n            obsolete = true;\n        };\n    }, [key, fetchMethod]);\n\n    // A result of another key stays in the state until the new fetch finishes: it is not exposed.\n    const current = result?.key === key ? result : undefined;\n    return { data: current?.data, error: current?.error, loading: !current };\n}\n"],"mappings":";;;;;;;;;;;;;AA8BA,SAAgB,gBAAmB,KAAiB,aAAkE;CAClH,MAAM,CAAC,QAAQ,aAAa,SAAyB;CAErD,gBAAgB;EAEZ,IAAI,WAAW;EACf,YAAY,GAAG,CAAC,CACX,MAAK,SAAQ,CAAC,YAAY,UAAU;GAAE;GAAK;EAAK,CAAC,CAAC,CAAC,CACnD,OAAM,UAAS,CAAC,YAAY,UAAU;GAAE;GAAK;EAAM,CAAC,CAAC;EAE1D,aAAa;GACT,WAAW;EACf;CACJ,GAAG,CAAC,KAAK,WAAW,CAAC;CAGrB,MAAM,UAAU,QAAQ,QAAQ,MAAM,SAAS,KAAA;CAC/C,OAAO;EAAE,MAAM,SAAS;EAAM,OAAO,SAAS;EAAO,SAAS,CAAC;CAAQ;AAC3E"}

package/dist/hook/useLightColorSchemeOnPrint.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Always prints the page with the light color scheme, even if the user uses the dark one: on paper (or in a PDF),
+ * light text on a dark background wastes ink and is hard to read. The scheme changes only while the print dialog is
+ * open (`beforeprint`/`afterprint`), without changing the preference saved by the user.
+ *
+ * It changes only what comes from the Mantine CSS variables. A component that chooses the color in JavaScript from the
+ * color scheme (e.g. with `useMantineColorScheme`) is not redrawn and keeps the dark colors.
+ */
+export declare function useLightColorSchemeOnPrint(): void;

package/dist/hook/useLightColorSchemeOnPrint.js

@@ -0,0 +1,36 @@
+"use client";
+import { useEffect } from "react";
+// src/hook/useLightColorSchemeOnPrint.ts
+/** Attribute where Mantine stores the color scheme of the page (`light` or `dark`). */
+var COLOR_SCHEME_ATTRIBUTE = "data-mantine-color-scheme";
+/**
+* Always prints the page with the light color scheme, even if the user uses the dark one: on paper (or in a PDF),
+* light text on a dark background wastes ink and is hard to read. The scheme changes only while the print dialog is
+* open (`beforeprint`/`afterprint`), without changing the preference saved by the user.
+*
+* It changes only what comes from the Mantine CSS variables. A component that chooses the color in JavaScript from the
+* color scheme (e.g. with `useMantineColorScheme`) is not redrawn and keeps the dark colors.
+*/
+function useLightColorSchemeOnPrint() {
+	useEffect(() => {
+		const html = document.documentElement;
+		let savedScheme = null;
+		const beforePrint = () => {
+			savedScheme = html.getAttribute(COLOR_SCHEME_ATTRIBUTE);
+			html.setAttribute(COLOR_SCHEME_ATTRIBUTE, "light");
+		};
+		const afterPrint = () => {
+			if (savedScheme) html.setAttribute(COLOR_SCHEME_ATTRIBUTE, savedScheme);
+			else html.removeAttribute(COLOR_SCHEME_ATTRIBUTE);
+		};
+		window.addEventListener("beforeprint", beforePrint);
+		window.addEventListener("afterprint", afterPrint);
+		return () => {
+			window.removeEventListener("beforeprint", beforePrint);
+			window.removeEventListener("afterprint", afterPrint);
+		};
+	}, []);
+}
+export { useLightColorSchemeOnPrint };
+
+//# sourceMappingURL=useLightColorSchemeOnPrint.js.map

package/dist/hook/useLightColorSchemeOnPrint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLightColorSchemeOnPrint.js","names":[],"sources":["../../src/hook/useLightColorSchemeOnPrint.ts"],"sourcesContent":["import { useEffect } from 'react';\n\n/** Attribute where Mantine stores the color scheme of the page (`light` or `dark`). */\nconst COLOR_SCHEME_ATTRIBUTE = 'data-mantine-color-scheme';\n\n/**\n * Always prints the page with the light color scheme, even if the user uses the dark one: on paper (or in a PDF),\n * light text on a dark background wastes ink and is hard to read. The scheme changes only while the print dialog is\n * open (`beforeprint`/`afterprint`), without changing the preference saved by the user.\n *\n * It changes only what comes from the Mantine CSS variables. A component that chooses the color in JavaScript from the\n * color scheme (e.g. with `useMantineColorScheme`) is not redrawn and keeps the dark colors.\n */\nexport function useLightColorSchemeOnPrint(): void {\n    useEffect(() => {\n        const html = document.documentElement;\n        let savedScheme: string | null = null;\n\n        const beforePrint = (): void => {\n            savedScheme = html.getAttribute(COLOR_SCHEME_ATTRIBUTE);\n            html.setAttribute(COLOR_SCHEME_ATTRIBUTE, 'light');\n        };\n        // Without a scheme before printing, removes the attribute, instead of leaving the light scheme set.\n        const afterPrint = (): void => {\n            if (savedScheme) html.setAttribute(COLOR_SCHEME_ATTRIBUTE, savedScheme);\n            else html.removeAttribute(COLOR_SCHEME_ATTRIBUTE);\n        };\n\n        window.addEventListener('beforeprint', beforePrint);\n        window.addEventListener('afterprint', afterPrint);\n        return (): void => {\n            window.removeEventListener('beforeprint', beforePrint);\n            window.removeEventListener('afterprint', afterPrint);\n        };\n    }, []);\n}\n"],"mappings":";;;;AAGA,IAAM,yBAAyB;;;;;;;;;AAU/B,SAAgB,6BAAmC;CAC/C,gBAAgB;EACZ,MAAM,OAAO,SAAS;EACtB,IAAI,cAA6B;EAEjC,MAAM,oBAA0B;GAC5B,cAAc,KAAK,aAAa,sBAAsB;GACtD,KAAK,aAAa,wBAAwB,OAAO;EACrD;EAEA,MAAM,mBAAyB;GAC3B,IAAI,aAAa,KAAK,aAAa,wBAAwB,WAAW;QACjE,KAAK,gBAAgB,sBAAsB;EACpD;EAEA,OAAO,iBAAiB,eAAe,WAAW;EAClD,OAAO,iBAAiB,cAAc,UAAU;EAChD,aAAmB;GACf,OAAO,oBAAoB,eAAe,WAAW;GACrD,OAAO,oBAAoB,cAAc,UAAU;EACvD;CACJ,GAAG,CAAC,CAAC;AACT"}

package/dist/hook/useService.d.ts

@@ -0,0 +1,27 @@
+/** Values returned by {@link useService}. */
+export type UseService<D> = {
+    /** Data of the fetch, or the initial value while it has not finished (or if it failed). */
+    data: D;
+    /** Error of the fetch; `null` if it has not finished yet or succeeded. */
+    error: unknown | null;
+    /** Whether the fetch has not finished yet. */
+    loading: boolean;
+};
+/**
+ * Fetches data when the component mounts and every time `fetchMethod` changes.
+ * Without an initial value, `data` is `undefined` while loading (or after a failure), so the caller must handle it.
+ * @param fetchMethod function that fetches the data. It must be stable (e.g. with `useCallback`), since a new function
+ *        triggers a new fetch
+ * @return the data (`undefined` until the fetch finishes), the error and whether the fetch is still running
+ */
+declare function useService<T>(fetchMethod: () => Promise<T>): UseService<T | undefined>;
+/**
+ * Fetches data when the component mounts and every time `fetchMethod` changes, starting with the given value (e.g. an
+ * empty array for a list), so `data` always has the type of the fetched data.
+ * @param fetchMethod function that fetches the data. It must be stable (e.g. with `useCallback`), since a new function
+ *        triggers a new fetch
+ * @param initialData value of `data` until the fetch finishes (and after a failure)
+ * @return the data, the error and whether the fetch is still running
+ */
+declare function useService<T>(fetchMethod: () => Promise<T>, initialData: T): UseService<T>;
+export default useService;

package/dist/hook/useService.js

@@ -0,0 +1,23 @@
+"use client";
+import { useEffect, useState } from "react";
+// src/hook/useService.ts
+function useService(fetchMethod, initialData) {
+	const [data, setData] = useState(initialData);
+	const [error, setError] = useState(null);
+	const [loading, setLoading] = useState(true);
+	useEffect(() => {
+		let obsolete = false;
+		fetchMethod().then((responseData) => !obsolete && setData(responseData)).catch((e) => !obsolete && setError(e)).finally(() => !obsolete && setLoading(false));
+		return () => {
+			obsolete = true;
+		};
+	}, [fetchMethod]);
+	return {
+		data,
+		error,
+		loading
+	};
+}
+export { useService as default };
+
+//# sourceMappingURL=useService.js.map

package/dist/hook/useService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useService.js","names":[],"sources":["../../src/hook/useService.ts"],"sourcesContent":["import { useEffect, useState } from 'react';\n\n/** Values returned by {@link useService}. */\nexport type UseService<D> = {\n    /** Data of the fetch, or the initial value while it has not finished (or if it failed). */\n    data: D;\n\n    /** Error of the fetch; `null` if it has not finished yet or succeeded. */\n    error: unknown | null;\n\n    /** Whether the fetch has not finished yet. */\n    loading: boolean;\n};\n\n/**\n * Fetches data when the component mounts and every time `fetchMethod` changes.\n * Without an initial value, `data` is `undefined` while loading (or after a failure), so the caller must handle it.\n * @param fetchMethod function that fetches the data. It must be stable (e.g. with `useCallback`), since a new function\n *        triggers a new fetch\n * @return the data (`undefined` until the fetch finishes), the error and whether the fetch is still running\n */\nfunction useService<T>(fetchMethod: () => Promise<T>): UseService<T | undefined>;\n\n/**\n * Fetches data when the component mounts and every time `fetchMethod` changes, starting with the given value (e.g. an\n * empty array for a list), so `data` always has the type of the fetched data.\n * @param fetchMethod function that fetches the data. It must be stable (e.g. with `useCallback`), since a new function\n *        triggers a new fetch\n * @param initialData value of `data` until the fetch finishes (and after a failure)\n * @return the data, the error and whether the fetch is still running\n */\nfunction useService<T>(fetchMethod: () => Promise<T>, initialData: T): UseService<T>;\n\nfunction useService<T>(fetchMethod: () => Promise<T>, initialData?: T): UseService<T | undefined> {\n    const [data, setData] = useState<T | undefined>(initialData);\n    const [error, setError] = useState<unknown | null>(null);\n    const [loading, setLoading] = useState(true);\n\n    useEffect(() => {\n        /* When fetchMethod changes (e.g. another filter), the previous fetch becomes obsolete. If its response arrives\n           after the one of the new fetch, it cannot overwrite the current data. */\n        let obsolete = false;\n        fetchMethod()\n            .then(responseData => !obsolete && setData(responseData))\n            .catch(e => !obsolete && setError(e))\n            .finally(() => !obsolete && setLoading(false));\n\n        return () => {\n            obsolete = true;\n        };\n    }, [fetchMethod]);\n\n    return { data, error, loading };\n}\n\nexport default useService;\n"],"mappings":";;;AAiCA,SAAS,WAAc,aAA+B,aAA4C;CAC9F,MAAM,CAAC,MAAM,WAAW,SAAwB,WAAW;CAC3D,MAAM,CAAC,OAAO,YAAY,SAAyB,IAAI;CACvD,MAAM,CAAC,SAAS,cAAc,SAAS,IAAI;CAE3C,gBAAgB;EAGZ,IAAI,WAAW;EACf,YAAY,CAAC,CACR,MAAK,iBAAgB,CAAC,YAAY,QAAQ,YAAY,CAAC,CAAC,CACxD,OAAM,MAAK,CAAC,YAAY,SAAS,CAAC,CAAC,CAAC,CACpC,cAAc,CAAC,YAAY,WAAW,KAAK,CAAC;EAEjD,aAAa;GACT,WAAW;EACf;CACJ,GAAG,CAAC,WAAW,CAAC;CAEhB,OAAO;EAAE;EAAM;EAAO;CAAQ;AAClC"}

package/dist/http/ApiError.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Error of a request to the API, with the user-friendly message already extracted by the {@link AxiosHttpClient}
+ * and, optionally, the `code` returned by the backend. The `code` allows the code that handles the error to identify
+ * the reason programmatically (e.g. a concurrent update), without relying on the text of `message`, which is just for
+ * display.
+ * @template C type of the error codes of the backend. An app may restrict it to the codes the backend sends (e.g. a
+ *           union of strings generated from a backend enum), so the compiler points out codes that no longer exist.
+ * @author Manoel Campos
+ */
+export declare class ApiError<C extends string = string> extends Error {
+    readonly code?: C;
+    constructor(message: string, code?: C);
+}

package/dist/http/ApiError.js

@@ -0,0 +1,22 @@
+"use client";
+// src/http/ApiError.ts
+/**
+* Error of a request to the API, with the user-friendly message already extracted by the {@link AxiosHttpClient}
+* and, optionally, the `code` returned by the backend. The `code` allows the code that handles the error to identify
+* the reason programmatically (e.g. a concurrent update), without relying on the text of `message`, which is just for
+* display.
+* @template C type of the error codes of the backend. An app may restrict it to the codes the backend sends (e.g. a
+*           union of strings generated from a backend enum), so the compiler points out codes that no longer exist.
+* @author Manoel Campos
+*/
+var ApiError = class extends Error {
+	code;
+	constructor(message, code) {
+		super(message);
+		this.name = "ApiError";
+		this.code = code;
+	}
+};
+export { ApiError };
+
+//# sourceMappingURL=ApiError.js.map

package/dist/http/ApiError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiError.js","names":[],"sources":["../../src/http/ApiError.ts"],"sourcesContent":["/**\n * Error of a request to the API, with the user-friendly message already extracted by the {@link AxiosHttpClient}\n * and, optionally, the `code` returned by the backend. The `code` allows the code that handles the error to identify\n * the reason programmatically (e.g. a concurrent update), without relying on the text of `message`, which is just for\n * display.\n * @template C type of the error codes of the backend. An app may restrict it to the codes the backend sends (e.g. a\n *           union of strings generated from a backend enum), so the compiler points out codes that no longer exist.\n * @author Manoel Campos\n */\nexport class ApiError<C extends string = string> extends Error {\n    public readonly code?: C;\n\n    constructor(message: string, code?: C) {\n        super(message);\n        this.name = 'ApiError';\n        this.code = code;\n    }\n}\n"],"mappings":";;;;;;;;;;;AASA,IAAa,WAAb,cAAyD,MAAM;CAC3D;CAEA,YAAY,SAAiB,MAAU;EACnC,MAAM,OAAO;EACb,KAAK,OAAO;EACZ,KAAK,OAAO;CAChB;AACJ"}

package/dist/http/AxiosHttpClient.d.ts

@@ -0,0 +1,21 @@
+import { AxiosInstance, AxiosRequestConfig } from 'axios';
+import { AxiosHttpClientConfig } from './AxiosHttpClientConfig';
+/**
+ * HTTP client of a REST API, on top of Axios. It centralizes the error handling: converts backend errors into an
+ * {@link ApiError}, with the user-friendly message and the error code, and network errors into a plain `Error`.
+ */
+export declare class AxiosHttpClient {
+    private readonly _axiosInstance;
+    private readonly _errorParser;
+    private readonly _messages;
+    constructor(config: AxiosHttpClientConfig);
+    /** Axios instance used in the requests, so the app can register interceptors (e.g. the authentication token). */
+    get axiosInstance(): AxiosInstance;
+    private _handleRequest;
+    private _handleError;
+    post<T>(path: string, data?: unknown, options?: AxiosRequestConfig): Promise<T>;
+    get<T>(path: string, options?: AxiosRequestConfig): Promise<T>;
+    put<T>(path: string, data?: unknown, options?: AxiosRequestConfig): Promise<T>;
+    patch<T>(path: string, data?: unknown, options?: AxiosRequestConfig): Promise<T>;
+    delete<T>(path: string, options?: AxiosRequestConfig): Promise<T>;
+}

package/dist/http/AxiosHttpClient.js

@@ -0,0 +1,67 @@
+"use client";
+import { resolveMessages } from "../i18n/resolveMessages.js";
+import { ApiError } from "./ApiError.js";
+import { parseErrorBody } from "./AxiosHttpClientConfig.js";
+import axios from "axios";
+// src/http/AxiosHttpClient.ts
+/**
+* HTTP client of a REST API, on top of Axios. It centralizes the error handling: converts backend errors into an
+* {@link ApiError}, with the user-friendly message and the error code, and network errors into a plain `Error`.
+*/
+var AxiosHttpClient = class {
+	_axiosInstance;
+	_errorParser;
+	_messages;
+	constructor(config) {
+		this._axiosInstance = axios.create({
+			baseURL: config.baseURL,
+			timeout: config.timeout ?? 5e3,
+			withCredentials: config.withCredentials ?? false,
+			headers: config.headers
+		});
+		this._errorParser = config.errorParser ?? parseErrorBody;
+		this._messages = resolveMessages(config.locale, { http: config.messages }).http;
+	}
+	/** Axios instance used in the requests, so the app can register interceptors (e.g. the authentication token). */
+	get axiosInstance() {
+		return this._axiosInstance;
+	}
+	async _handleRequest(method, path, data, options) {
+		try {
+			return (await this._axiosInstance.request({
+				method,
+				url: path,
+				data,
+				...options
+			})).data;
+		} catch (error) {
+			throw this._handleError(error);
+		}
+	}
+	_handleError(error) {
+		if (axios.isAxiosError(error) && error.response) {
+			const { message, code } = this._errorParser(error.response.data);
+			return new ApiError(message || this._messages.unknownError, code);
+		}
+		if (error.request) return new Error(this._messages.noResponse);
+		return new Error(error.message || this._messages.requestFailed);
+	}
+	async post(path, data, options) {
+		return this._handleRequest("post", path, data, options);
+	}
+	async get(path, options) {
+		return this._handleRequest("get", path, void 0, options);
+	}
+	async put(path, data, options) {
+		return this._handleRequest("put", path, data, options);
+	}
+	async patch(path, data, options) {
+		return this._handleRequest("patch", path, data, options);
+	}
+	async delete(path, options) {
+		return this._handleRequest("delete", path, void 0, options);
+	}
+};
+export { AxiosHttpClient };
+
+//# sourceMappingURL=AxiosHttpClient.js.map

package/dist/http/AxiosHttpClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AxiosHttpClient.js","names":[],"sources":["../../src/http/AxiosHttpClient.ts"],"sourcesContent":["import axios, { AxiosError, AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';\n\nimport { HttpMessages } from '../i18n/KitMessages';\nimport { resolveMessages } from '../i18n/resolveMessages';\nimport { ApiError } from './ApiError';\nimport { AxiosHttpClientConfig, DEFAULT_TIMEOUT_MS, ParsedApiError, parseErrorBody } from './AxiosHttpClientConfig';\n\n/**\n * HTTP client of a REST API, on top of Axios. It centralizes the error handling: converts backend errors into an\n * {@link ApiError}, with the user-friendly message and the error code, and network errors into a plain `Error`.\n */\nexport class AxiosHttpClient {\n    private readonly _axiosInstance: AxiosInstance;\n    private readonly _errorParser: (body: unknown) => ParsedApiError;\n    private readonly _messages: HttpMessages;\n\n    constructor(config: AxiosHttpClientConfig) {\n        this._axiosInstance = axios.create({\n            baseURL: config.baseURL,\n            timeout: config.timeout ?? DEFAULT_TIMEOUT_MS,\n            withCredentials: config.withCredentials ?? false,\n            headers: config.headers\n        });\n        this._errorParser = config.errorParser ?? parseErrorBody;\n        this._messages = resolveMessages(config.locale, { http: config.messages }).http;\n    }\n\n    /** Axios instance used in the requests, so the app can register interceptors (e.g. the authentication token). */\n    public get axiosInstance(): AxiosInstance {\n        return this._axiosInstance;\n    }\n\n    private async _handleRequest<T>(\n        method: string,\n        path: string,\n        data?: unknown,\n        options?: AxiosRequestConfig\n    ): Promise<T> {\n        try {\n            const response: AxiosResponse<T> = await this._axiosInstance.request<T>({\n                method,\n                url: path,\n                data,\n                ...options\n            });\n\n            return response.data;\n        } catch (error) {\n            throw this._handleError(error as AxiosError);\n        }\n    }\n\n    private _handleError(error: AxiosError): Error {\n        if (axios.isAxiosError(error) && error.response) {\n            const { message, code } = this._errorParser(error.response.data);\n            return new ApiError(message || this._messages.unknownError, code);\n        }\n\n        if (error.request) {\n            return new Error(this._messages.noResponse);\n        }\n\n        return new Error(error.message || this._messages.requestFailed);\n    }\n\n    public async post<T>(path: string, data?: unknown, options?: AxiosRequestConfig): Promise<T> {\n        return this._handleRequest<T>('post', path, data, options);\n    }\n\n    public async get<T>(path: string, options?: AxiosRequestConfig): Promise<T> {\n        return this._handleRequest<T>('get', path, undefined, options);\n    }\n\n    public async put<T>(path: string, data?: unknown, options?: AxiosRequestConfig): Promise<T> {\n        return this._handleRequest<T>('put', path, data, options);\n    }\n\n    public async patch<T>(path: string, data?: unknown, options?: AxiosRequestConfig): Promise<T> {\n        return this._handleRequest<T>('patch', path, data, options);\n    }\n\n    public async delete<T>(path: string, options?: AxiosRequestConfig): Promise<T> {\n        return this._handleRequest<T>('delete', path, undefined, options);\n    }\n}\n"],"mappings":";;;;;;;;;;AAWA,IAAa,kBAAb,MAA6B;CACzB;CACA;CACA;CAEA,YAAY,QAA+B;EACvC,KAAK,iBAAiB,MAAM,OAAO;GAC/B,SAAS,OAAO;GAChB,SAAS,OAAO,WAAA;GAChB,iBAAiB,OAAO,mBAAmB;GAC3C,SAAS,OAAO;EACpB,CAAC;EACD,KAAK,eAAe,OAAO,eAAe;EAC1C,KAAK,YAAY,gBAAgB,OAAO,QAAQ,EAAE,MAAM,OAAO,SAAS,CAAC,CAAC,CAAC;CAC/E;;CAGA,IAAW,gBAA+B;EACtC,OAAO,KAAK;CAChB;CAEA,MAAc,eACV,QACA,MACA,MACA,SACU;EACV,IAAI;GAQA,QAAO,MAPkC,KAAK,eAAe,QAAW;IACpE;IACA,KAAK;IACL;IACA,GAAG;GACP,CAAC,EAAA,CAEe;EACpB,SAAS,OAAO;GACZ,MAAM,KAAK,aAAa,KAAmB;EAC/C;CACJ;CAEA,aAAqB,OAA0B;EAC3C,IAAI,MAAM,aAAa,KAAK,KAAK,MAAM,UAAU;GAC7C,MAAM,EAAE,SAAS,SAAS,KAAK,aAAa,MAAM,SAAS,IAAI;GAC/D,OAAO,IAAI,SAAS,WAAW,KAAK,UAAU,cAAc,IAAI;EACpE;EAEA,IAAI,MAAM,SACN,OAAO,IAAI,MAAM,KAAK,UAAU,UAAU;EAG9C,OAAO,IAAI,MAAM,MAAM,WAAW,KAAK,UAAU,aAAa;CAClE;CAEA,MAAa,KAAQ,MAAc,MAAgB,SAA0C;EACzF,OAAO,KAAK,eAAkB,QAAQ,MAAM,MAAM,OAAO;CAC7D;CAEA,MAAa,IAAO,MAAc,SAA0C;EACxE,OAAO,KAAK,eAAkB,OAAO,MAAM,KAAA,GAAW,OAAO;CACjE;CAEA,MAAa,IAAO,MAAc,MAAgB,SAA0C;EACxF,OAAO,KAAK,eAAkB,OAAO,MAAM,MAAM,OAAO;CAC5D;CAEA,MAAa,MAAS,MAAc,MAAgB,SAA0C;EAC1F,OAAO,KAAK,eAAkB,SAAS,MAAM,MAAM,OAAO;CAC9D;CAEA,MAAa,OAAU,MAAc,SAA0C;EAC3E,OAAO,KAAK,eAAkB,UAAU,MAAM,KAAA,GAAW,OAAO;CACpE;AACJ"}

package/dist/http/AxiosHttpClientConfig.d.ts

@@ -0,0 +1,37 @@
+import { KitLocale } from '../i18n/KitLocale';
+import { HttpMessages } from '../i18n/KitMessages';
+/** Message and code extracted from the body of an error response of the backend. */
+export type ParsedApiError = {
+    /** Message to show to the user; if absent, a generic message is used. */
+    message?: string;
+    /** Code that identifies the reason of the error (see {@link ApiError}). */
+    code?: string;
+};
+/** Configuration of an {@link AxiosHttpClient}. */
+export type AxiosHttpClientConfig = {
+    /** Address of the API, prefixed to the paths of the requests (e.g. `http://localhost:8080`). */
+    baseURL: string;
+    /** Maximum time to wait for a response (ms). Default: {@link DEFAULT_TIMEOUT_MS}. */
+    timeout?: number;
+    /** Whether cookies and credentials are sent in requests to another origin. Default: `false`. */
+    withCredentials?: boolean;
+    /** Headers sent in every request. */
+    headers?: Record<string, string>;
+    /**
+     * Extracts the message and the code from the body of an error response. The default ({@link parseErrorBody})
+     * reads the `message` and `code` fields of a JSON object (e.g. the error body of a Spring API).
+     */
+    errorParser?: (body: unknown) => ParsedApiError;
+    /** Locale of the generic error messages. Default: `en-US`. */
+    locale?: KitLocale;
+    /** Generic error messages, replacing the ones of the locale. */
+    messages?: Partial<HttpMessages>;
+};
+/** Default maximum time to wait for a response (ms). */
+export declare const DEFAULT_TIMEOUT_MS = 5000;
+/**
+ * Default error parser: reads the `message` and `code` fields of the response body, if it is an object.
+ * @param body body of the error response
+ * @return the message and the code found
+ */
+export declare function parseErrorBody(body: unknown): ParsedApiError;

package/dist/http/AxiosHttpClientConfig.js

@@ -0,0 +1,19 @@
+"use client";
+// src/http/AxiosHttpClientConfig.ts
+/** Default maximum time to wait for a response (ms). */
+var DEFAULT_TIMEOUT_MS = 5e3;
+/**
+* Default error parser: reads the `message` and `code` fields of the response body, if it is an object.
+* @param body body of the error response
+* @return the message and the code found
+*/
+function parseErrorBody(body) {
+	if (body === null || typeof body !== "object") return {};
+	return {
+		message: "message" in body && body.message ? String(body.message) : void 0,
+		code: "code" in body && body.code ? String(body.code) : void 0
+	};
+}
+export { DEFAULT_TIMEOUT_MS, parseErrorBody };
+
+//# sourceMappingURL=AxiosHttpClientConfig.js.map

package/dist/http/AxiosHttpClientConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AxiosHttpClientConfig.js","names":[],"sources":["../../src/http/AxiosHttpClientConfig.ts"],"sourcesContent":["import { KitLocale } from '../i18n/KitLocale';\nimport { HttpMessages } from '../i18n/KitMessages';\n\n/** Message and code extracted from the body of an error response of the backend. */\nexport type ParsedApiError = {\n    /** Message to show to the user; if absent, a generic message is used. */\n    message?: string;\n\n    /** Code that identifies the reason of the error (see {@link ApiError}). */\n    code?: string;\n};\n\n/** Configuration of an {@link AxiosHttpClient}. */\nexport type AxiosHttpClientConfig = {\n    /** Address of the API, prefixed to the paths of the requests (e.g. `http://localhost:8080`). */\n    baseURL: string;\n\n    /** Maximum time to wait for a response (ms). Default: {@link DEFAULT_TIMEOUT_MS}. */\n    timeout?: number;\n\n    /** Whether cookies and credentials are sent in requests to another origin. Default: `false`. */\n    withCredentials?: boolean;\n\n    /** Headers sent in every request. */\n    headers?: Record<string, string>;\n\n    /**\n     * Extracts the message and the code from the body of an error response. The default ({@link parseErrorBody})\n     * reads the `message` and `code` fields of a JSON object (e.g. the error body of a Spring API).\n     */\n    errorParser?: (body: unknown) => ParsedApiError;\n\n    /** Locale of the generic error messages. Default: `en-US`. */\n    locale?: KitLocale;\n\n    /** Generic error messages, replacing the ones of the locale. */\n    messages?: Partial<HttpMessages>;\n};\n\n/** Default maximum time to wait for a response (ms). */\nexport const DEFAULT_TIMEOUT_MS = 5000;\n\n/**\n * Default error parser: reads the `message` and `code` fields of the response body, if it is an object.\n * @param body body of the error response\n * @return the message and the code found\n */\nexport function parseErrorBody(body: unknown): ParsedApiError {\n    if (body === null || typeof body !== 'object') return {};\n\n    const message = 'message' in body && body.message ? String(body.message) : undefined;\n    const code = 'code' in body && body.code ? String(body.code) : undefined;\n\n    return { message, code };\n}\n"],"mappings":";;;AAwCA,IAAa,qBAAqB;;;;;;AAOlC,SAAgB,eAAe,MAA+B;CAC1D,IAAI,SAAS,QAAQ,OAAO,SAAS,UAAU,OAAO,CAAC;CAKvD,OAAO;EAAE,SAHO,aAAa,QAAQ,KAAK,UAAU,OAAO,KAAK,OAAO,IAAI,KAAA;EAGzD,MAFL,UAAU,QAAQ,KAAK,OAAO,OAAO,KAAK,IAAI,IAAI,KAAA;CAExC;AAC3B"}

package/dist/i18n/KitLocale.d.ts

@@ -0,0 +1,4 @@
+/** Locales with a built-in message catalog. */
+export type KitLocale = 'pt-BR' | 'en-US';
+/** Locale used when the app does not choose one. */
+export declare const DEFAULT_LOCALE: KitLocale;

package/dist/i18n/KitLocale.js

@@ -0,0 +1,7 @@
+"use client";
+// src/i18n/KitLocale.ts
+/** Locale used when the app does not choose one. */
+var DEFAULT_LOCALE = "en-US";
+export { DEFAULT_LOCALE };
+
+//# sourceMappingURL=KitLocale.js.map

package/dist/i18n/KitLocale.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KitLocale.js","names":[],"sources":["../../src/i18n/KitLocale.ts"],"sourcesContent":["/** Locales with a built-in message catalog. */\nexport type KitLocale = 'pt-BR' | 'en-US';\n\n/** Locale used when the app does not choose one. */\nexport const DEFAULT_LOCALE: KitLocale = 'en-US';\n"],"mappings":";;;AAIA,IAAa,iBAA4B"}

package/dist/i18n/KitMessages.d.ts

@@ -0,0 +1,146 @@
+import type { ChartTypeId } from '../component/organism/EChart/chart/ChartTypeId';
+/** Pagination range shown below a table (e.g. "Showing 1 to 10 of 42 records"). */
+export type PaginationRange = {
+    from: number;
+    to: number;
+    totalRecords: number;
+};
+/** Action of a CRUD form, used to build its titles and messages. */
+export type FormAction = 'create' | 'edit' | 'view' | 'custom';
+/** Texts shared by many components. */
+export type CommonMessages = {
+    back: string;
+    save: string;
+    cancel: string;
+    confirm: string;
+    add: string;
+    home: string;
+    success: string;
+    warning: string;
+    error: string;
+    /** Title of the alert shown when the data of a component cannot be loaded. */
+    loadError: string;
+    /** Date format of date fields, in Day.js tokens (e.g. `DD/MM/YYYY`). */
+    dateFormat: string;
+};
+/** Texts of the CRUD form templates (`FormPage`, `CreateFormPage`, `EditFormPage`, `ViewPage`, `DataForm`). */
+export type FormMessages = {
+    /** Verb of each form action, used in titles and buttons (e.g. "Create", "Update"). */
+    action: Record<FormAction, string>;
+    /** Message shown after the record is saved, built from the action verb. */
+    saveSuccess: (action: string) => string;
+    /** Message shown when the record cannot be saved, built from the action verb. */
+    saveError: (action: string) => string;
+    createSuccess: string;
+    createError: string;
+    updateSuccess: string;
+    updateError: string;
+    /** Title of the confirmation dialog shown before submitting a form that asks for it. */
+    confirmTitle: string;
+};
+/** Texts of the tables (`Table`, `ViewTable`, `ListPage`). */
+export type TableMessages = {
+    actions: string;
+    view: string;
+    edit: string;
+    delete: string;
+    deleteConfirm: string;
+    deleteSuccess: string;
+    noRecords: string;
+    recordsPerPage: string;
+    pagination: (range: PaginationRange) => string;
+    /** Title of the card that holds the table of a list page, built from the plural name of the records. */
+    listTitle: (pluralName: string) => string;
+};
+/** Tooltips of the buttons that edit a table row in place. */
+export type RowEditMessages = {
+    edit: string;
+    confirm: string;
+    cancel: string;
+};
+/** Texts of the `SelectField`. */
+export type SelectMessages = {
+    /** Placeholder built from the field label, when the field has no placeholder of its own. */
+    placeholder: (label: string) => string;
+    /** Text shown when no option matches the search, built from the field label. */
+    nothingFound: (label: string) => string;
+};
+/** Texts of the `Layout` header and side menu. */
+export type LayoutMessages = {
+    userMenu: string;
+    userMenuTitle: string;
+    enableDarkTheme: string;
+    enableLightTheme: string;
+    collapseNavigation: string;
+    expandNavigation: string;
+};
+/** Texts of the print pages (`PrintPage`). */
+export type PrintMessages = {
+    pdfTipTitle: string;
+    pdfTip: string;
+    printButton: string;
+};
+/** Texts of the stats cards (`StatsCard`, `StatsGrid`). */
+export type StatsMessages = {
+    comparedToLastMonth: string;
+};
+/** Texts of the exported files (Excel and CSV) and of the export button. */
+export type ExportMessages = {
+    button: string;
+    /** Message shown when the export fails, built from the format name (e.g. "Excel (.xlsx)"). */
+    failed: (formatLabel: string) => string;
+    /** Date and time the data was generated, shown below the title (e.g. "Generated on 10/20/2026 at 2:30 PM"). */
+    generatedAt: (date: Date) => string;
+    /** Footer that tells which system generated the data. */
+    footer: (systemName: string) => string;
+    /**
+     * Page number in the footer of the printed spreadsheet, with the Excel header/footer codes `&P` (page) and `&N`
+     * (total pages).
+     */
+    excelPageNumber: string;
+    /** Text of a cell whose value could not be computed. */
+    invalidCell: string;
+    /** File name used when the document name has no valid character. */
+    defaultFileName: string;
+    /** Sheet name used when the sheet has no valid name, built from its position (starting at 1). */
+    defaultSheetName: (position: number) => string;
+};
+/** Texts of the charts. */
+export type ChartMessages = {
+    /** Name of each chart type, shown in a chart type selector. */
+    types: Record<ChartTypeId, string>;
+    /** Title of the button that saves the chart as an image. */
+    saveAsImage: string;
+    /** Subtitle of the donut chart with the formatted sum of the slices. */
+    total: (formattedTotal: string) => string;
+};
+/** Messages of the HTTP client errors. */
+export type HttpMessages = {
+    /** The backend answered with an error, but without a message. */
+    unknownError: string;
+    /** The request was sent, but there was no answer (e.g. backend down or timeout). */
+    noResponse: string;
+    /** The request was not even sent and Axios gave no reason. */
+    requestFailed: string;
+};
+/**
+ * Every text the library shows to users, grouped by component. Each locale is an object of this type
+ * (`messages/ptBR.ts`, `messages/enUS.ts`), so a missing translation is a compile error.
+ */
+export type KitMessages = {
+    common: CommonMessages;
+    form: FormMessages;
+    table: TableMessages;
+    rowEdit: RowEditMessages;
+    select: SelectMessages;
+    layout: LayoutMessages;
+    print: PrintMessages;
+    stats: StatsMessages;
+    export: ExportMessages;
+    chart: ChartMessages;
+    http: HttpMessages;
+};
+/** Partial {@link KitMessages}, used by an app to override some texts of a locale. */
+export type KitMessagesOverride = {
+    [Section in keyof KitMessages]?: Partial<KitMessages[Section]>;
+};

package/dist/i18n/KitMessages.js

@@ -0,0 +1 @@
+"use client";

package/dist/i18n/messages/enUS.d.ts

@@ -0,0 +1,3 @@
+import { KitMessages } from '../KitMessages';
+/** American English texts, the default locale. */
+export declare const enUS: KitMessages;