nurseitaly-components 0.0.13 → 0.0.15

package/dist/basic/CheckboxGroupField/CheckboxGroupField.d.ts

@@ -0,0 +1,14 @@
+import { FieldValues, UseFormReturn } from 'react-hook-form';
+import type { SelectItem } from '../SelectField/SelectField';
+import '../CheckboxField/style.scss';
+import './style.scss';
+type CheckboxGroupFieldProps<TFieldValues extends FieldValues = FieldValues, TContext = any, TTransformedValues = TFieldValues> = {
+    attr: string;
+    createdForm: UseFormReturn<TFieldValues, TContext, TTransformedValues>;
+    options: SelectItem[];
+    disabled?: boolean;
+    className?: string;
+    onChange?: (attr: string, value: Array<string | number>) => void;
+};
+export default function CheckboxGroupField<TFieldValues extends FieldValues = FieldValues, TContext = any, TTransformedValues = TFieldValues>({ attr, createdForm, options, disabled, className, onChange, }: CheckboxGroupFieldProps<TFieldValues, TContext, TTransformedValues>): import("react").JSX.Element;
+export {};

package/dist/basic/CheckboxGroupField/CheckboxGroupField.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Checkbox, FormControlLabel } from '@mui/material';
+import cx from 'classnames';
+import { Controller, } from 'react-hook-form';
+import '../CheckboxField/style.scss';
+import './style.scss';
+function toValueList(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value;
+}
+export default function CheckboxGroupField({ attr, createdForm, options = [], disabled = false, className, onChange, }) {
+    const fieldName = attr;
+    const { control } = createdForm;
+    return (_jsx(Controller, { name: fieldName, control: control, render: ({ field }) => {
+            const selected = toValueList(field.value);
+            const toggle = (optionValue, checked) => {
+                const next = checked
+                    ? selected.includes(optionValue)
+                        ? selected
+                        : [...selected, optionValue]
+                    : selected.filter((v) => v !== optionValue);
+                field.onChange(next);
+                onChange?.(attr, next);
+            };
+            return (_jsx("div", { className: cx('ds-checkbox-group', className), children: options.map((option) => (_jsx(FormControlLabel, { className: "ds-checkbox", disabled: disabled, control: _jsx(Checkbox, { checked: selected.includes(option.value), onChange: (e) => toggle(option.value, e.target.checked), onBlur: field.onBlur, inputRef: field.ref }), label: option.label }, String(option.value)))) }));
+        } }));
+}

package/dist/basic/CheckboxGroupField/index.d.ts

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

package/dist/basic/CheckboxGroupField/index.js

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

package/dist/basic/CheckboxGroupField/style.scss

@@ -0,0 +1,5 @@
+.ds-checkbox-group {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}

package/dist/basic/index.d.ts

@@ -3,6 +3,7 @@ export { default as Badge } from './Badge';
 export { default as Button } from './Button';
 export type { ButtonDSColors, ButtonDSModes, ButtonDSPositions, ButtonDSSizes, } from './Button/Button';
 export { default as CheckboxField } from './CheckboxField';
+export { default as CheckboxGroupField } from './CheckboxGroupField';
 export { default as DatePickerField } from './DatePickerField';
 export { default as DropdownButton } from './DropdownButton';
 export { default as DropdownList } from './DropdownList';

package/dist/basic/index.js

@@ -4,6 +4,7 @@ export { default as Avatar } from './Avatar';
 export { default as Badge } from './Badge';
 export { default as Button } from './Button';
 export { default as CheckboxField } from './CheckboxField';
+export { default as CheckboxGroupField } from './CheckboxGroupField';
 export { default as DatePickerField } from './DatePickerField';
 export { default as DropdownButton } from './DropdownButton';
 export { default as DropdownList } from './DropdownList';

package/dist/common/AppForm/AppForm.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { AsyncSelectField, CheckboxField, DatePickerField, SelectField, SelectMultipleField, SwitchField, TextField, } from "../../basic";
+import { AsyncSelectField, CheckboxField, CheckboxGroupField, DatePickerField, SelectField, SelectMultipleField, SwitchField, TextField, } from "../../basic";
 import FormColorField from "./FormColorField";
 import { getFieldFlexStyle, groupFieldsIntoRows } from "./groupFieldsIntoRows";
 import "./style.scss";
@@ -47,6 +47,10 @@ export default function AppForm({ fields, form, prefix, onChangeFunctions = {},
             return (_jsx(SelectField, { ...selectProps, allowEmpty: field.allowEmpty }, name));
         }
         if (field.type === "check") {
+            if (field.multiple) {
+                const checkOptions = getOptions(field.attr) || field.options || [];
+                return (_jsx(CheckboxGroupField, { attr: name, createdForm: form, options: checkOptions, disabled: field.disabled, onChange: (_attr, value) => handleChange?.(value) }, name));
+            }
             return (_jsx(CheckboxField, { attr: name, label: field.name, createdForm: form, disabled: field.disabled }, name));
         }
         if (field.type === "switch") {

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

@@ -0,0 +1,15 @@
+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;
+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,21 @@
+export function isServerError(status) {
+    return status !== undefined && status >= 500 && status < 600;
+}
+export function markApiErrorHandled(error) {
+    error.apiErrorHandled = true;
+}
+export function isHandledApiError(reason) {
+    if (!reason || typeof reason !== 'object')
+        return false;
+    const error = reason;
+    if (error.apiErrorHandled || error.authErrorHandled)
+        return true;
+    const status = error.response?.status;
+    if (!error.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,13 @@
+import type { AxiosInstance } from 'axios';
+export type AuthErrorHandling = 'toast' | 'redirect' | 'none';
+export type ApplyAuthErrorHandlingOptions = {
+    authErrorHandling?: AuthErrorHandling;
+    authStatuses?: Array<401 | 403>;
+    redirect?: {
+        on401?: string;
+        on403?: string;
+    };
+    onBeforeRedirect?: (status: 401 | 403) => void;
+    skipAuthHandlingInStorybook?: boolean;
+};
+export declare function applyAuthErrorHandling(api: AxiosInstance, options: ApplyAuthErrorHandlingOptions): AxiosInstance;

package/dist/configs/api/applyAuthErrorHandling.js

@@ -0,0 +1,70 @@
+import { markApiErrorHandled } from './apiHandledError';
+import CookieStorage from '../CookieStorage';
+import { messageAction, loggedAction } from '../sessionTypes';
+import { getCommonDispatch } from '../commonDispatch';
+import { getErrorMessageValue } from '../useMessageUtils';
+import i18n from 'i18next';
+function isStorybook() {
+    return (typeof window !== 'undefined' &&
+        (window.location.port === '6006' ||
+            Boolean(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()?.(loggedAction(undefined));
+    }
+    const value = getErrorMessageValue({
+        err: { response: { status } },
+        t: i18n.t.bind(i18n),
+    });
+    getCommonDispatch()?.(messageAction({ value, 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;
+}
+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,9 @@
+import { AxiosInstance, InternalAxiosRequestConfig } from 'axios';
+export type ServerErrorHandling = 'toast' | 'none';
+export type CreateApiClientOptions = {
+    baseURL: string;
+    attachJwt?: boolean;
+    serverErrorHandling?: ServerErrorHandling;
+    augmentRequest?: (config: InternalAxiosRequestConfig) => InternalAxiosRequestConfig;
+};
+export declare function createApiClient(options: CreateApiClientOptions): AxiosInstance;

package/dist/configs/api/createApiClient.js

@@ -0,0 +1,51 @@
+import axios from 'axios';
+import CookieStorage from '../CookieStorage';
+import { dispatchServerApiError } from './dispatchApiError';
+import { isServerError, markApiErrorHandled } from './apiHandledError';
+const DEFAULT_HEADERS = {
+    'Cache-Control': 'no-cache, no-store, must-revalidate',
+    Pragma: 'no-cache',
+    'Content-Type': 'application/json',
+    Accept: 'application/json',
+};
+function toHandledServerErrorResponse(error) {
+    return {
+        data: null,
+        status: error.response?.status ?? 500,
+        statusText: error.response?.statusText ?? 'Internal Server Error',
+        headers: error.response?.headers ?? {},
+        config: error.config,
+    };
+}
+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) {
+                config.headers.Authorization = `Bearer ${token}`;
+            }
+        }
+        return augmentRequest ? augmentRequest(config) : config;
+    });
+    return api;
+}

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

@@ -0,0 +1,10 @@
+import type { TFunction } from 'i18next';
+export declare function dispatchApiError({ err, t, key, }: {
+    err: unknown;
+    t?: TFunction;
+    key?: string;
+}): void;
+export declare function dispatchServerApiError({ err, t, }: {
+    err: unknown;
+    t?: TFunction;
+}): void;

package/dist/configs/api/dispatchApiError.js

@@ -0,0 +1,16 @@
+import i18n from 'i18next';
+import { getErrorMessageValue } from '../useMessageUtils';
+import { messageAction } from '../sessionTypes';
+import { getCommonDispatch } from '../commonDispatch';
+export function dispatchApiError({ err, t, key, }) {
+    const translate = t ?? i18n.t.bind(i18n);
+    const value = getErrorMessageValue({ err, t: translate, key });
+    getCommonDispatch()?.(messageAction({ value, type: 'error' }));
+}
+export function dispatchServerApiError({ err, t, }) {
+    dispatchApiError({
+        err,
+        t,
+        key: 'common',
+    });
+}

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

@@ -0,0 +1,16 @@
+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 default api;

package/dist/configs/api/index.js

@@ -0,0 +1,16 @@
+import { applyAuthErrorHandling } from './applyAuthErrorHandling';
+import { createApiClient } from './createApiClient';
+const platformApiBase = import.meta.env.VITE_APP_PLATFORM_API;
+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 default api;

package/dist/configs/api.d.ts

@@ -1,10 +1,2 @@
-/** 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;
+export * from './api/index';
+export { default } from './api/index';

package/dist/configs/api.js

@@ -1,52 +1,2 @@
-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;
+export * from './api/index';
+export { default } from './api/index';

package/dist/configs/index.d.ts

@@ -1,5 +1,6 @@
 export { default as CommonContext, CommonProvider } from './CommonContext';
 export { default as CommonDispatchBridge } from './CommonDispatchBridge';
+export * from './api/index';
 export { getCommonDispatch, registerCommonDispatch, } from './commonDispatch';
 export { default as CookieStorage } from './CookieStorage';
 export { commonLocalization, commonResources, featureResources, mergeResources, } from './Localization';

package/dist/configs/index.js

@@ -1,5 +1,6 @@
 export { default as CommonContext, CommonProvider } from './CommonContext';
 export { default as CommonDispatchBridge } from './CommonDispatchBridge';
+export * from './api/index';
 export { getCommonDispatch, registerCommonDispatch, } from './commonDispatch';
 export { default as CookieStorage } from './CookieStorage';
 export { commonLocalization, commonResources, featureResources, mergeResources, } from './Localization';

package/dist/styles/main.scss

@@ -79,11 +79,9 @@ body {
   display: flex !important;
 }
 
-.tablet-only {
-  display: none !important;
-}
-
-.mobile-only {
+.tablet-only,
+.mobile-only,
+.desktop-never {
   display: none !important;
 }
 
@@ -94,7 +92,8 @@ body {
     display: none !important;
   }
 
-  .tablet-only {
+  .tablet-only,
+  .desktop-never {
     display: flex !important;
   }
 }
@@ -106,7 +105,8 @@ body {
     display: none !important;
   }
 
-  .mobile-only {
+  .mobile-only,
+  .desktop-never {
     display: flex !important;
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nurseitaly-components",
   "private": false,
-  "version": "0.0.13",
+  "version": "0.0.15",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {

package/dist/basic/Dummy/Dummy.d.ts

@@ -1,9 +0,0 @@
-import './styles.scss';
-export declare const DummyModes: readonly ["white", "blue"];
-type DummyModes = (typeof DummyModes)[number];
-export type Props = {
-    className?: string;
-    mode?: DummyModes;
-};
-export default function Dummy({ className, mode }: Props): import("react").JSX.Element;
-export {};

package/dist/basic/Dummy/Dummy.js

@@ -1,8 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import cx from 'classnames';
-import './styles.scss';
-export const DummyModes = ['white', 'blue'];
-export default function Dummy({ className, mode = 'blue' }) {
-    const getClassNames = cx('ds-dummy', className, mode);
-    return _jsx("div", { className: getClassNames, children: "aaaa" });
-}

package/dist/basic/Dummy/index.d.ts

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

package/dist/basic/Dummy/index.js

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

package/dist/basic/Dummy/styles.scss

@@ -1,4 +0,0 @@
-.ds-dummy {
-  display: flex;
-  align-items: center;
-}