nurseitaly-components 0.0.1

package/dist/functions/DateUtils.d.ts

@@ -0,0 +1,15 @@
+import { format } from 'date-fns';
+declare function extractDateFromMongoId(id: string, time?: boolean): string;
+declare const DateUtils: {
+    millis: () => number;
+    formatDate: (date: Date | null, fmt: string) => string;
+    format: typeof format;
+    parseISOString: (s: string) => Date;
+    isValidDate: (date: Date) => boolean;
+    parseDate: (dateStr: string, formatStr: string, referenceDate?: Date) => Date;
+    addSecondsToDate: (date: Date, seconds: number) => Date;
+    parseTime: (time: number) => string;
+    extractDateFromMongoId: typeof extractDateFromMongoId;
+    formatDateTime: (isoDateStr: string, outputFormat: string) => string;
+};
+export default DateUtils;

package/dist/functions/DateUtils.js

@@ -0,0 +1,52 @@
+import { addSeconds, format, isValid, parse, parseISO, } from 'date-fns';
+import { format as formatTz } from 'date-fns-tz';
+const millis = () => new Date().getTime();
+const formatDateTime = (isoDateStr, outputFormat) => {
+    if (!isoDateStr)
+        return '';
+    try {
+        const parsedDate = parseISO(isoDateStr);
+        return formatTz(parsedDate, outputFormat);
+    }
+    catch (error) {
+        console.error('Invalid date or format:', error);
+        return '';
+    }
+};
+const formatDate = (date, fmt) => {
+    if (!date)
+        return '';
+    return formatTz(date, fmt);
+};
+const parseISOString = (s) => parseISO(s);
+const isValidDate = (date) => isValid(date);
+const parseDate = (dateStr, formatStr, referenceDate) => parse(dateStr, formatStr, referenceDate ?? new Date());
+const addSecondsToDate = (date, seconds) => addSeconds(date, seconds);
+const parseTime = (time) => {
+    if (time == null || time <= 0)
+        return '00:00:00.000';
+    return new Date(time * 1000).toISOString().slice(11, 23);
+};
+function extractDateFromMongoId(id, time) {
+    const DATE_PATTERN = 'yyyy-MM-dd';
+    const TIME_PATTERN = 'HH:mm:ss';
+    const hexTimestamp = id.substring(0, 8);
+    const timestampInMilliseconds = parseInt(hexTimestamp, 16) * 1000;
+    const dtf = time ? `${DATE_PATTERN} ${TIME_PATTERN}` : DATE_PATTERN;
+    const date = addSeconds(new Date(0), timestampInMilliseconds / 1000);
+    const formattedDate = formatTz(date, dtf);
+    return formattedDate;
+}
+const DateUtils = {
+    millis,
+    formatDate,
+    format,
+    parseISOString,
+    isValidDate,
+    parseDate,
+    addSecondsToDate,
+    parseTime,
+    extractDateFromMongoId,
+    formatDateTime,
+};
+export default DateUtils;

package/dist/functions/FilterUtils.d.ts

@@ -0,0 +1,13 @@
+import { FieldValues, UseFormReturn } from 'react-hook-form';
+export type DefaultOption = {
+    label: string;
+    value: any;
+};
+declare const FilterUtils: {
+    apply: <T extends FieldValues, TContext = any, TTransformedValues = T>(form: UseFormReturn<T, TContext, TTransformedValues>, setFilter: (f: any) => void, onClose: () => void, emptyPageable: any) => void;
+    clear: <T extends FieldValues, TContext = any, TTransformedValues = T>(form: UseFormReturn<T, TContext, TTransformedValues>, setFilter: (f: any) => void, onClose: () => void, clearValues: any) => void;
+    isSelected: (filter: any) => boolean;
+    reset: <T extends FieldValues, TContext = any, TTransformedValues = T>(form: UseFormReturn<T, TContext, TTransformedValues>, setFilter: (p: any) => void, clearValues: any) => void;
+    enter: <T extends FieldValues, TContext = any, TTransformedValues = T>(form: UseFormReturn<T, TContext, TTransformedValues>, setFilter: (f: any) => void, event: React.KeyboardEvent<HTMLDivElement>, onClose: () => void, emptyPageable: any) => void;
+};
+export default FilterUtils;

package/dist/functions/FilterUtils.js

@@ -0,0 +1,56 @@
+import DateUtils from './DateUtils';
+const enter = (form, setFilter, event, onClose, emptyPageable) => {
+    // 'keypress' event misbehaves on mobile so we track 'Enter' key via 'keydown' event
+    if (event.key === 'Enter') {
+        event.preventDefault();
+        event.stopPropagation();
+        apply(form, setFilter, onClose, emptyPageable);
+    }
+};
+const apply = (form, setFilter, onClose, emptyPageable) => {
+    setFilter({ ...form.getValues(), ...emptyPageable });
+    onClose();
+};
+const clear = (form, setFilter, onClose, clearValues) => {
+    reset(form, setFilter, clearValues);
+    onClose();
+};
+const reset = (form, setFilter, clearValues) => {
+    form.reset(clearValues);
+    setFilter({
+        ...clearValues,
+        seed: DateUtils.millis(),
+    });
+};
+const isSelected = (filter) => {
+    const clone = JSON.parse(JSON.stringify(filter));
+    delete clone.page;
+    delete clone.size;
+    delete clone.sort;
+    delete clone.seed;
+    return !isObjectEmpty(clone);
+};
+const isObjectEmpty = (filter) => {
+    if (!filter || Object.keys(filter).length === 0)
+        return true;
+    let empty = false;
+    Object.keys(filter).forEach((key) => {
+        if (Array.isArray(filter[key])) {
+            if (filter[key].length === 0)
+                empty = true;
+        }
+        else {
+            if (!filter[key])
+                empty = true;
+        }
+    });
+    return empty;
+};
+const FilterUtils = {
+    apply,
+    clear,
+    isSelected,
+    reset,
+    enter,
+};
+export default FilterUtils;

package/dist/functions/FormUtils.d.ts

@@ -0,0 +1,13 @@
+import { TFunction } from 'i18next';
+import { SelectItem } from '../basic/SelectField/SelectField';
+import { AppFormField } from '../common/AppForm/AppFormField';
+declare const FormUtils: {
+    convertEnum: (values: Record<string, string>, t?: TFunction, prefix?: string) => SelectItem[];
+    convertList: (values: any, labelAttr: string, valueAttr: string) => SelectItem[];
+    convertStringArray: (values: string[]) => SelectItem[];
+    booleanOptions: (t: TFunction) => SelectItem[];
+    convertMap: (values: Record<string, any> | undefined) => SelectItem[];
+    sortByLabel: (items: SelectItem[]) => SelectItem[];
+    filterFieldsByUserRole: (fields: AppFormField[], hasRole: (role: string) => boolean) => AppFormField[];
+};
+export default FormUtils;

package/dist/functions/FormUtils.js

@@ -0,0 +1,58 @@
+const filterFieldsByUserRole = (fields, hasRole) => fields.filter((field) => !field.role || hasRole(field.role));
+const convertEnum = (values, t, prefix) => {
+    if (!t)
+        return Object.entries(values).map(([key, label]) => ({
+            value: key,
+            label,
+        }));
+    return Object.entries(values).map(([key, label]) => ({
+        value: key,
+        label: t(`${prefix ? `${prefix}:` : ''}${label}`),
+    }));
+};
+const sortByLabel = (items) => {
+    return [...items].sort((a, b) => a.label.localeCompare(b.label));
+};
+const convertList = (values, labelAttr, valueAttr) => {
+    if (!values)
+        return [];
+    let fields = [];
+    values.map((value) => {
+        fields = [...fields, { label: value[labelAttr], value: value[valueAttr] }];
+    });
+    return fields;
+};
+const convertMap = (values) => {
+    if (!values)
+        return [];
+    let fields = [];
+    Object.keys(values).map((key) => {
+        fields = [...fields, { label: values[key], value: key }];
+    });
+    return fields;
+};
+const convertStringArray = (values) => {
+    if (!values)
+        return [];
+    let fields = [];
+    values.map((value) => {
+        fields = [...fields, { label: value, value }];
+    });
+    return fields;
+};
+const booleanOptions = (t) => {
+    return [
+        { label: t('message:generic.option.true'), value: 'true' },
+        { label: t('message:generic.option.false'), value: 'false' },
+    ];
+};
+const FormUtils = {
+    convertEnum,
+    convertList,
+    convertStringArray,
+    booleanOptions,
+    convertMap,
+    sortByLabel,
+    filterFieldsByUserRole,
+};
+export default FormUtils;

package/dist/functions/ImageUtils.d.ts

@@ -0,0 +1,5 @@
+declare const ImageUtils: {
+    display: (url: string, person?: boolean) => string;
+    getPlaceHolder: (person?: boolean) => string;
+};
+export default ImageUtils;

package/dist/functions/ImageUtils.js

@@ -0,0 +1,13 @@
+import placeholder from './placeholder-image.png';
+import placeholderPerson from './placeholder-person.png';
+const display = (url, person) => {
+    if (url && url !== '')
+        return url;
+    return person ? placeholderPerson : placeholder;
+};
+const getPlaceHolder = (person) => person ? placeholderPerson : placeholder;
+const ImageUtils = {
+    display,
+    getPlaceHolder,
+};
+export default ImageUtils;

package/dist/functions/SecurityUtils.d.ts

@@ -0,0 +1,6 @@
+import { User } from '../configs/sessionTypes';
+declare const SecurityUtils: {
+    hasAccess: (uid: string, roles: string[], mode: "lexicon" | "corpus" | "parser") => boolean;
+    parseJwt: (token: string) => User;
+};
+export default SecurityUtils;

package/dist/functions/SecurityUtils.js

@@ -0,0 +1,28 @@
+import CookieStorage from '../configs/CookieStorage';
+import { UserStatus } from '../configs/sessionTypes';
+const hasAccess = (uid, roles, mode) => {
+    const token = CookieStorage.getJwtToken();
+    if (!token)
+        return false;
+    const logged = parseJwt(token);
+    if (logged.status && logged.status === UserStatus.SUPER)
+        return true;
+    return roles.some((role) => logged.permissions.includes(`ROLE_${role}_${mode.toUpperCase()}_${uid}`));
+};
+const parseJwt = (token) => {
+    const base64Url = token.split('.')[1];
+    const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
+    const payload = decodeURIComponent(window
+        .atob(base64)
+        .split('')
+        .map(function (c) {
+        return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
+    })
+        .join(''));
+    return JSON.parse(payload);
+};
+const SecurityUtils = {
+    hasAccess,
+    parseJwt,
+};
+export default SecurityUtils;

package/dist/functions/UsabilityUtils.d.ts

@@ -0,0 +1,10 @@
+declare const UsabilityUtils: {
+    attachCloseToEscape: (handleClose: () => void) => () => void;
+    executeOnEnter: (event: React.KeyboardEvent<HTMLDivElement>, fn: () => void) => void;
+    isMobile: () => boolean;
+    goToAnchor: (anchorId: string, e?: any) => void;
+    attachEnter: (event: React.KeyboardEvent<HTMLInputElement>, handleEnter: () => void) => void;
+    copy: (text: string, callback?: () => void) => void;
+    limitText: (text: string, limit: number) => string;
+};
+export default UsabilityUtils;

package/dist/functions/UsabilityUtils.js

@@ -0,0 +1,47 @@
+const copy = (text, callback) => {
+    navigator.clipboard.writeText(text).then(() => {
+        callback && callback();
+    });
+};
+const attachEnter = (event, handleEnter) => {
+    // 'keypress' event misbehaves on mobile so we track 'Enter' key via 'keydown' event
+    if (event.key === 'Enter') {
+        event.preventDefault();
+        event.stopPropagation();
+        handleEnter();
+    }
+};
+const goToAnchor = (anchorId, e) => {
+    e && e.preventDefault();
+    const anchorElement = document.getElementById(anchorId);
+    if (anchorElement) {
+        anchorElement.scrollIntoView({ behavior: 'smooth' });
+    }
+};
+const attachCloseToEscape = (handleClose) => {
+    const closeOnEscape = (e) => {
+        if (e.keyCode === 27)
+            handleClose();
+    };
+    window.addEventListener('keydown', closeOnEscape);
+    return () => window.removeEventListener('keydown', closeOnEscape);
+};
+const executeOnEnter = (event, fn) => {
+    if (event.key === 'Enter') {
+        event.preventDefault();
+        event.stopPropagation();
+        fn();
+    }
+};
+const isMobile = () => window.innerWidth < 768;
+const limitText = (text, limit) => text && text.length > limit ? text.slice(0, limit) + '...' : text;
+const UsabilityUtils = {
+    attachCloseToEscape,
+    executeOnEnter,
+    isMobile,
+    goToAnchor,
+    attachEnter,
+    copy,
+    limitText,
+};
+export default UsabilityUtils;

package/dist/functions/index.d.ts

@@ -0,0 +1,6 @@
+export { default as DateUtils } from './DateUtils';
+export { default as FilterUtils } from './FilterUtils';
+export { default as FormUtils } from './FormUtils';
+export { default as ImageUtils } from './ImageUtils';
+export { default as SecurityUtils } from './SecurityUtils';
+export { default as UsabilityUtils } from './UsabilityUtils';

package/dist/functions/index.js

@@ -0,0 +1,6 @@
+export { default as DateUtils } from './DateUtils';
+export { default as FilterUtils } from './FilterUtils';
+export { default as FormUtils } from './FormUtils';
+export { default as ImageUtils } from './ImageUtils';
+export { default as SecurityUtils } from './SecurityUtils';
+export { default as UsabilityUtils } from './UsabilityUtils';

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './basic';
+export * from './common';
+export * from './configs';
+export * from './functions';
+export * from './vendor';

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from './basic';
+export * from './common';
+export * from './configs';
+export * from './functions';
+export * from './vendor';

package/dist/styles/base/_borders.scss

@@ -0,0 +1,30 @@
+// borders, dividers and border radius
+
+:root {
+  --border-0: 0px;
+  --border-050: 0.5px;
+  --border-100: 1px;
+  --border-150: 1.5px;
+  --border-200: 2px;
+  --border-250: 2.5px;
+  --border-300: 3px;
+  --border-400: 4px;
+  --border-500: 5px;
+  --border-600: 6px;
+  --border-700: 7px;
+  --border-800: 8px;
+
+  --radius-0: 0px;
+  --radius-050: 2px;
+  --radius-100: 4px;
+  --radius-200: 8px;
+  --radius-300: 12px;
+  --radius-400: 16px;
+  --radius-500: 20px;
+  --radius-600: 24px;
+  --radius-700: 28px;
+  --radius-800: 32px;
+  --radius-900: 36px;
+  --radius-1000: 40px;
+  --radius-full: 999px;
+}

package/dist/styles/base/_colors.scss

@@ -0,0 +1,100 @@
+// colors, tonal scales for accent, neutral and semantic
+
+:root {
+  --accent-0: #000000;
+  --accent-10: #142e57;
+  --accent-100: #ffffff;
+  --accent-20: #194c8f;
+  --accent-30: #185abd;
+  --accent-40: #146ce1;
+  --accent-50: #1c83f4;
+  --accent-60: #32a2ff;
+  --accent-70: #59bfff;
+  --accent-80: #8ed8ff;
+  --accent-90: #bce6ff;
+  --accent-95: #d9f0ff;
+  --accent-99: #eef9ff;
+  --high-contrast-blue: #6bfdff;
+  --high-contrast-dark: #000000;
+  --high-contrast-green: #7bff57;
+  --high-contrast-light: #ffffff;
+  --high-contrast-yellow: #fff81f;
+  --neutral-dark-0: #ffffff;
+  --neutral-dark-10: #f6f7f9;
+  --neutral-dark-100: #000000;
+  --neutral-dark-20: #ebeef3;
+  --neutral-dark-30: #d3d9e4;
+  --neutral-dark-40: #acb9cd;
+  --neutral-dark-50: #7f94b1;
+  --neutral-dark-60: #5f7698;
+  --neutral-dark-70: #4b5f7e;
+  --neutral-dark-80: #42526e;
+  --neutral-dark-90: #364256;
+  --neutral-dark-95: #30394a;
+  --neutral-dark-99: #202531;
+  --neutral-light-0: #000000;
+  --neutral-light-10: #141415;
+  --neutral-light-100: #ffffff;
+  --neutral-light-20: #252627;
+  --neutral-light-30: #434447;
+  --neutral-light-40: #5c5e61;
+  --neutral-light-50: #707276;
+  --neutral-light-60: #9d9fa2;
+  --neutral-light-70: #bebfc1;
+  --neutral-light-80: #cbcccd;
+  --neutral-light-90: #eaeaeb;
+  --neutral-light-95: #f7f7f8;
+  --neutral-light-99: #f9fafb;
+  --semantic-danger-0: #000000;
+  --semantic-danger-10: #44060c;
+  --semantic-danger-100: #ffffff;
+  --semantic-danger-20: #7e1015;
+  --semantic-danger-30: #9d0f16;
+  --semantic-danger-40: #c6080a;
+  --semantic-danger-50: #ef1207;
+  --semantic-danger-60: #fe3820;
+  --semantic-danger-70: #ff5638;
+  --semantic-danger-80: #ff8f71;
+  --semantic-danger-90: #ffbda8;
+  --semantic-danger-95: #ffe0d4;
+  --semantic-danger-99: #fff2ed;
+  --semantic-info-0: #000000;
+  --semantic-info-10: #440055;
+  --semantic-info-100: #ffffff;
+  --semantic-info-20: #68127d;
+  --semantic-info-30: #7c0e9a;
+  --semantic-info-40: #950fbc;
+  --semantic-info-50: #b720e9;
+  --semantic-info-60: #c837fe;
+  --semantic-info-70: #dc6dff;
+  --semantic-info-80: #e8a4ff;
+  --semantic-info-90: #f1ccff;
+  --semantic-info-95: #f8e6ff;
+  --semantic-info-99: #f8e6ff;
+  --semantic-success-0: #000000;
+  --semantic-success-10: #182c07;
+  --semantic-success-100: #ffffff;
+  --semantic-success-20: #335017;
+  --semantic-success-30: #3b5e16;
+  --semantic-success-40: #477714;
+  --semantic-success-50: #5c9c14;
+  --semantic-success-60: #70b51c;
+  --semantic-success-70: #98de3d;
+  --semantic-success-80: #b5ec6a;
+  --semantic-success-90: #d3f5a1;
+  --semantic-success-95: #e9facd;
+  --semantic-success-99: #f6fde8;
+  --semantic-warning-0: #000000;
+  --semantic-warning-10: #461702;
+  --semantic-warning-100: #ffffff;
+  --semantic-warning-20: #7a310d;
+  --semantic-warning-30: #943a0c;
+  --semantic-warning-40: #b74c06;
+  --semantic-warning-50: #dd6f02;
+  --semantic-warning-60: #f99607;
+  --semantic-warning-70: #ffb920;
+  --semantic-warning-80: #ffc938;
+  --semantic-warning-90: #ffe388;
+  --semantic-warning-95: #fff2c6;
+  --semantic-warning-99: #fffaeb;
+}