cic-kit 0.0.8 → 0.0.9

package/README.md

@@ -2,29 +2,9 @@
 
 `cic-kit` è un piccolo kit di componenti e stili per **Vue 3**, pensato per essere riutilizzato tra più progetti.
 
-Attualmente esporta:
-- ✅ un componente Vue (`BtnCmp`)
-- ✅ uno stylesheet (`style.css`) con utility, font e override
-- ❌ **non** include Bootstrap o Vue Router internamente (usa quelli del progetto consumer)
-
----
-
-## Installazione
-
-```bash
-npm install cic-kit
-```
-
-> Il progetto che usa `cic-kit` deve avere già installati:
-> - `vue`
-> - `vue-router`
-> - `bootstrap`
-
----
-
 ## Peer Dependencies
 
-Questo pacchetto **non porta con sé** queste dipendenze, ma usa quelle del progetto consumer:
+Il progetto che usa `cic-kit` deve avere già installati:
 
 ```json
 {
@@ -34,29 +14,53 @@ Questo pacchetto **non porta con sé** queste dipendenze, ma usa quelle del prog
 }
 ```
 
-Questa è una scelta intenzionale per evitare duplicazioni e conflitti di stile.
-
 ---
 
-## Utilizzo
+## Installazione
 
-### Import dello stile
+dopo aver installato le peer Dependencies
 
-Nel file di bootstrap dell’app (es. `main.ts`):
+```bash
+npm install cic-kit
+```
 
-```ts
-import "bootstrap/dist/css/bootstrap.css";
-import "cic-kit/style.css";
+poi importa lo style su un scss con
+
+```scss
+@use "cic-kit/style";
 ```
 
-> `style.css` include:
+❌ **non** include Bootstrap internamente bisogna importarlo prima con `@use "bootstrap/scss/bootstrap"`;
+
+## Style
+
+> `_style.scss` include:
+>
+> - regolre di reset
 > - font custom (Material Symbols, emoji, ecc.)
-> - utility CSS
 > - override delle classi Bootstrap
+> - utility CSS
 
----
+## Componenti
+
+Tra i componenti ci sono file di utility .ts e componenti .vue che possono utilizzare store globali basati su reactive() per controllarli
+
+#### BtnCmp
+
+Button Bootstrap con varianti, icona, loading e navigazione router.
 
-### Uso del componente
+| prop       | default  | type                                                                                            | utilizzo                    |
+| ---------- | -------- | ----------------------------------------------------------------------------------------------- | --------------------------- |
+| `variant`  | `solid`  | `"solid" \| "outline" \| "ghost" \| "link"`                                                     | stile del bottone           |
+| `color`    | `dark`   | `"primary" \| "secondary" \| "success" \| "danger" \| "warning" \| "info" \| "light" \| "dark"` | cambia colore Bootstrap     |
+| `size`     | —        | `"sm" \| "lg"`                                                                                  | dimensione Bootstrap        |
+| `block`    | `false`  | `boolean`                                                                                       | full width (`w-100`)        |
+| `disabled` | `false`  | `boolean`                                                                                       | disabilita click            |
+| `type`     | `button` | `"button" \| "submit" \| "reset"`                                                               | tipo HTML button            |
+| `to`       | —        | `RouteLocationRaw`                                                                              | naviga con `router.push`    |
+| `loading`  | `false`  | `boolean`                                                                                       | mostra spinner e disabilita |
+| `icon`     | —        | `string`                                                                                        | icona Material Symbols      |
+| `share`    | —        | `ShareLink`                                                                                     | condivide link al click     |
 
 ```vue
 <script setup lang="ts">
@@ -64,50 +68,6 @@ import { BtnCmp } from "cic-kit";
 </script>
 
 <template>
-  <BtnCmp />
+  <BtnCmp color="primary">Salva</BtnCmp>
 </template>
 ```
-
-Il componente utilizza `vue-router`, quindi l’app deve avere un router configurato.
-
----
-
-## Font e asset
-
-I font sono inclusi nello stylesheet del pacchetto.
-Durante la build possono essere:
-- **inlined** (base64 nel CSS), oppure
-- **copiati come asset** (a seconda della configurazione di build)
-
-In entrambi i casi **non è richiesta alcuna configurazione aggiuntiva** nel progetto consumer.
-
----
-
-## Filosofia del pacchetto
-
-- 🧩 Componenti piccoli e riutilizzabili
-- 🎨 Stili centralizzati e condivisi
-- 📦 Nessuna dipendenza “hardcoded”
-- 🔌 Massima integrazione con il progetto consumer
-
----
-
-## Sviluppo
-
-Il pacchetto è pensato per essere usato insieme a un progetto di test/sandbox separato.
-
-Build della libreria:
-
-```bash
-npm run build
-```
-
-Prima della pubblicazione è consigliato testare il pacchetto con:
-
-```bash
-npm pack
-```
-
-e installare il `.tgz` in un progetto Vue reale.
-
----

package/dist/cic-kit.css

@@ -1 +1 @@
-.spinner-border[data-v-1fbd412d]{vertical-align:middle}.btn-ms-link[data-v-1fbd412d]{background-color:transparent!important;border:none;color:var(--bs-btn-color)!important}.btn-ms-link[data-v-1fbd412d]:hover{text-decoration:underline}.hideAfter[data-v-1fbd412d]:after{display:none}
+.spinner-border[data-v-2280ac85]{vertical-align:middle}.btn-ms-link[data-v-2280ac85]{background-color:transparent!important;border:none;color:var(--bs-btn-color)!important}.btn-ms-link[data-v-2280ac85]:hover{text-decoration:underline}.hideAfter[data-v-2280ac85]:after{display:none}.toast-wrapper[data-v-821bd999]{position:fixed;bottom:20px;right:20px;display:flex;flex-direction:column;gap:6px;z-index:999999}.toast-card[data-v-821bd999]{width:330px;min-height:80px;border-radius:8px;padding:10px 12px;background-color:#fff;box-shadow:0 8px 24px #00000026;display:flex;align-items:center;justify-content:center;gap:12px;cursor:default;transition:all .3s ease,transform .3s ease;overflow:hidden;opacity:1}.toast-card .icon-container[data-v-821bd999]{width:35px;height:35px;display:flex;justify-content:center;align-items:center;border-radius:50%;flex-shrink:0;transition:all .3s ease}.toast-card .message-text[data-v-821bd999]{font-size:17px;font-weight:700}.toast-card .sub-text[data-v-821bd999]{color:#555;font-size:14px}.toast-card .cross-icon[data-v-821bd999]{width:18px;height:18px;color:#555;cursor:pointer;flex-shrink:0}.toast-card[data-v-821bd999]:not(.expanded){min-height:40px;max-height:40px;padding-top:6px;padding-bottom:6px;opacity:.7}.toast-card:not(.expanded) .icon-container[data-v-821bd999]{width:18px;height:18px}.toast-card:not(.expanded) .message-text[data-v-821bd999]{font-size:14px}.toast-card:not(.expanded) .sub-content[data-v-821bd999]{display:none}.toast-card:not(.expanded) .cross-icon[data-v-821bd999]{width:14px;height:14px}.toast-fade-enter-from[data-v-821bd999],.toast-fade-leave-to[data-v-821bd999]{opacity:0;transform:translateY(20px)}.toast-fade-enter-active[data-v-821bd999],.toast-fade-leave-active[data-v-821bd999]{transition:all .3s ease}.message-text-container[data-v-821bd999]{flex-grow:1}.toast-card.info[data-v-821bd999]{border-right:5px solid var(--bs-info)}.toast-card.info .icon-container[data-v-821bd999]{color:var(--bs-info)}.toast-card.success[data-v-821bd999]{border-right:5px solid var(--bs-success)}.toast-card.success .icon-container[data-v-821bd999]{color:var(--bs-success)}.toast-card.warning[data-v-821bd999]{border-right:5px solid var(--bs-warning)}.toast-card.warning .icon-container[data-v-821bd999]{color:var(--bs-warning)}.toast-card.error[data-v-821bd999]{border-right:5px solid var(--bs-danger)}.toast-card.error .icon-container[data-v-821bd999]{color:var(--bs-danger)}.toast-card.primary[data-v-821bd999]{border-right:5px solid var(--bs-primary)}.toast-card.primary .icon-container[data-v-821bd999]{color:var(--bs-primary)}.toast-card.secondary[data-v-821bd999]{border-right:5px solid var(--bs-secondary)}.toast-card.secondary .icon-container[data-v-821bd999]{color:var(--bs-secondary)}.prefix-width[data-v-d70bf135]{width:60px}

package/dist/cmp/Btn/shareLink.d.ts

@@ -0,0 +1,6 @@
+export interface ShareLink {
+    url: string;
+    text?: string;
+    title?: string;
+}
+export declare function shareLink({ url, text, title }: ShareLink): Promise<void>;

package/dist/cmp/Btn/typeBtn.d.ts

@@ -0,0 +1,3 @@
+export type BtnVariant = "solid" | "outline" | "ghost" | "link";
+export type BtnColor = "primary" | "secondary" | "success" | "danger" | "warning" | "info" | "light" | "dark";
+export type IconGoogle = "search" | "home" | "menu" | "close" | "settings" | "send" | "add" | "remove" | "delete" | "star" | "star_half" | "arrow_forward_ios" | "arrow_back_ios" | "logout" | "more_vert" | "favorite" | "login" | "radio_button_unchecked" | "radio_button_checked" | "bolt" | "block" | "sync" | "share" | "ios_share" | "upload" | "alternate_email" | "account_circle" | "manage_accounts" | "visibility" | "visibility_off" | "language" | "support" | "mail" | "call" | "notifications" | "link" | "person_search" | "edit" | "photo_camera" | "image" | "circle" | "payments" | "credit_card" | "database" | "shopping_bag" | "account_balance" | "savings" | "qr_code" | "euro" | "wallet" | "payment_arrow_down" | "location_on" | "map" | "fastfood";

package/dist/cmp/cicKitStore.d.ts

@@ -0,0 +1,5 @@
+export declare const cicKitStore: {
+    isDev: boolean;
+    debugMod: boolean;
+    debugFirestore: boolean | string | string[];
+};

package/dist/cmp/clone/clone.d.ts

@@ -0,0 +1 @@
+export declare function clone<U>(o: U): U;

package/dist/cmp/firebase/FirestoreModel.d.ts

@@ -0,0 +1,81 @@
+import { DocumentReference, Timestamp } from 'firebase/firestore';
+type FirestoreStore_delete = {
+    delete: (id: string, opts?: Omit<OptionFireModel, 'touchUpdate'>) => Promise<void>;
+};
+export declare function fireDebugLog(collectionPath: string, icons: string, type: string, ...args: unknown[]): void;
+export type Timestampble = {
+    createdAt: Timestamp;
+    updatedAt: Timestamp;
+    deleteAt: Timestamp | null;
+};
+export type OptionFireModel = {
+    offlineAllow?: boolean;
+    touchUpdate?: boolean;
+    localSet?: boolean;
+};
+export declare const optionFireModelDefault: OptionFireModel;
+export declare abstract class FirestoreModel<T extends {
+    id: string;
+}> {
+    id: string;
+    createdAt: Timestamp;
+    updatedAt: Timestamp;
+    deleteAt: Timestamp | null;
+    protected constructor(data: T & Partial<Timestampble>);
+    static collectionName?: string;
+    private debugLog;
+    /**
+     * Facoltativo: i model figli possono override-are questo metodo
+     * per fornire la path dinamica di collezione (es. subcollection).
+     * Esempio: "debits/{parentId}/transitions"
+     */
+    protected getCollectionPath?(): string;
+    protected localStorageKey?(): string;
+    /**
+     * Ritorna la DocumentReference calcolando:
+     * - se il model ha getCollectionPath(): la usa
+     * - altrimenti usa la static collectionName.
+     */
+    get ref(): DocumentReference;
+    abstract toData(): T;
+    /**
+     * GET singolo documento.
+     */
+    static get<U extends FirestoreModel<T>, T extends {
+        id: string;
+    }>(this: {
+        new (data: T): U;
+        collectionName?: string;
+    }, id: string, opts?: {
+        collectionPath?: string;
+        localSet?: boolean;
+    }): Promise<U | undefined>;
+    static cleanDataAAA(data: any): {
+        [k: string]: any;
+    };
+    private static isPlainObject;
+    /**
+     * Rimuove ricorsivamente gli `undefined` annidati (Firestore non li supporta).
+     * NON trasforma null in deleteField: quello lo fai a top-level.
+     */
+    static stripUndefinedDeep(value: any): any;
+    static cleanData(data: any): {
+        [k: string]: any;
+    };
+    onGetBeforeStoreSet<U extends FirestoreModel<T>>(instance: U): Promise<U>;
+    save({ offlineAllow, touchUpdate, localSet }?: OptionFireModel): Promise<void>;
+    update(data: Partial<Omit<T, 'id'>>, { offlineAllow, touchUpdate, localSet }?: OptionFireModel): Promise<void>;
+    delete(store: FirestoreStore_delete, opts?: Omit<OptionFireModel, 'touchUpdate'>): Promise<void>;
+    deleteJustOnline_NotLocalStore({ offlineAllow, localSet }?: Omit<OptionFireModel, 'touchUpdate'>): Promise<void>;
+    get isDeleted(): boolean;
+    timestampbleProps(): Timestampble;
+    touchUpdated(): Timestamp;
+    softDelete(optionFireModel?: OptionFireModel): Promise<void>;
+    /** 🔄 Ripristina dal cestino (se supportato) */
+    restore(optionFireModel?: OptionFireModel): Promise<void>;
+    /** Ritorna true se il model espone una chiave valido per il salvataggio su LocalStorage */
+    canLocalSave(localSet?: boolean): boolean;
+    /** Salva/aggiorna questo documento nel LocalStorage, sotto l’oggetto indicizzato per id */
+    localSet(_delete?: boolean): void;
+}
+export {};

package/dist/cmp/firebase/FirestoreStore.d.ts

@@ -0,0 +1,116 @@
+import { type QueryConstraint, type FieldPath, type OrderByDirection, type DocumentChange, type DocumentData } from 'firebase/firestore';
+import { FirestoreModel } from './FirestoreModel';
+import { type OptionFireModel } from './FirestoreModel';
+import type { Reactive } from 'vue';
+export interface GetProps {
+    ids?: string[];
+    lastByCreate?: number;
+    lastByUpdate?: number;
+    query?: QueryConstraint | QueryConstraint[];
+    limit?: number;
+    orderBy?: {
+        fieldPath: string | FieldPath;
+        directionStr?: OrderByDirection;
+    };
+    forceLocalSet?: boolean;
+    localSet?: boolean;
+}
+type Ctor<M, D> = {
+    new (data: D): M;
+    collectionName?: string;
+};
+export type FirestoreStoreReactive<M extends FirestoreModel<D>, D extends {
+    id: string;
+}> = Reactive<FirestoreStore<M, D>>;
+export type AnyFirestoreStoreReactive = FirestoreStoreReactive<FirestoreModel<{
+    id: string;
+}>, {
+    id: string;
+}>;
+export declare class FirestoreStore<M extends FirestoreModel<D>, D extends {
+    id: string;
+}> {
+    protected readonly ModelInstnce: Ctor<M, D>;
+    protected makeModel(id: string, data: Omit<D, 'id'>): M;
+    /** Se presente, verrà usata al posto di ModelInstnce.collectionName */
+    protected readonly _collectionPath?: string;
+    private debugLog;
+    items: Record<string, M>;
+    snapshotFnStop: (() => void) | null;
+    isFirstRun: boolean;
+    prevStartQuery: string | null;
+    get live(): boolean;
+    get ref(): import("@firebase/firestore").CollectionReference<DocumentData, DocumentData>;
+    constructor(ModelInstnce: Ctor<M, D>, opts?: {
+        collectionPath?: string;
+    });
+    /** Path effettiva della collezione di questo store */
+    protected get collectionPath(): string;
+    get name(): string;
+    get itemsActive(): Record<string, M>;
+    get itemsDeleted(): Record<string, M>;
+    get itemsArray(): M[];
+    /** 🔎 Solo elementi NON cancellati (m.deleteAt === null) */
+    get itemsActiveArray(): M[];
+    /** 🧺 Solo elementi cancellati (cestino) */
+    get itemsDeletedArray(): M[];
+    get isEmpty(): boolean;
+    /** 🔎 Versione array: NON cancellati */
+    get isActiveEmpty(): boolean;
+    /** 🧺 Versione array: cancellati */
+    get isDeletedEmpty(): boolean;
+    get localStorageKey(): any;
+    /**
+     * 📅 Restituisce un array ordinato per timestamp scelto.
+     * @param option 'createdAt' | 'updatedAt' | 'deleteAt'
+     * @returns Array ordinato in ordine discendente (più recente prima)
+     */
+    itemsArrayOrderedBy(option: 'createdAt' | 'updatedAt' | 'deleteAt', deleted?: boolean): M[];
+    findItemsById(id: string | false | null | undefined): M;
+    get(opts?: GetProps): Promise<Record<string, M>>;
+    /**
+   * Legge doc per ids usando `documentId() in (...)`
+   * Firestore: max 10 elementi per `in` ma gestito fa chiamate a grruppi da 10
+   */
+    getIds(ids: string[]): Promise<{
+        foundIds: string[] | false;
+        notFoundIds: string[] | false;
+    }>;
+    localGet(): void;
+    /**
+    * 🔴 Avvia il listening realtime (onSnapshot) sulla collection gestita dallo store.
+    *
+    * Questo metodo mette lo store in modalità "live", mantenendo sincronizzati
+    * gli `items` locali con Firestore in tempo reale.
+    *
+    * ⚠️ Non modifica la logica esistente di `get()`:
+    * - `start()` serve solo per l'ascolto realtime
+    * - `get()` resta una fetch one-shot
+    *
+    */
+    start(opts?: GetProps): Promise<void>;
+    onStartFirstRun(snapDocs: DocumentChange<DocumentData, DocumentData>[], forceLocalSet?: boolean): void;
+    stop(): void;
+    add(data: Omit<D, 'id'>, options?: Omit<OptionFireModel, 'touchUpdate'>): Promise<M>;
+    add(data: Omit<D, 'id'> & {
+        id?: string;
+    }, options?: Omit<OptionFireModel, 'touchUpdate'>): Promise<M>;
+    delete(id: string, opts?: Omit<OptionFireModel, 'touchUpdate'>): Promise<void>;
+    findByUid(uid: string): M;
+    /**
+     * Legge un singolo documento da Firestore e aggiorna items[id].
+     * Ritorna l'istanza oppure undefined se non esiste.
+     */
+    getOne(id: string, options?: OptionFireModel): Promise<M | undefined>;
+    /**
+     * Ritorna l'istanza se già presente nello store, altrimenti la carica da Firestore.
+     */
+    ensureOne(id: string): Promise<M | undefined>;
+    /** 🧹 Svuota completamente il LocalStorage associato al Model gestito dallo store */
+    localClear(): void;
+}
+export declare function validateQueryGetOpts(opts: GetProps & {
+    ids?: string[];
+}): boolean;
+export declare function buildConstraintsFromGetProps(opts: GetProps, alredyCheck?: boolean): QueryConstraint[] | false;
+export {};

package/dist/cmp/firebase/firebase.d.ts

@@ -0,0 +1,27 @@
+import { type FirebaseApp } from "firebase/app";
+import { getAnalytics } from "firebase/analytics";
+import { getAuth, GoogleAuthProvider, signInWithPopup } from 'firebase/auth';
+import { getFirestore } from 'firebase/firestore';
+import { getStorage } from "firebase/storage";
+import { getFunctions } from "firebase/functions";
+import { getMessaging } from "firebase/messaging";
+export interface FirebaseConfig {
+    apiKey: string;
+    authDomain: string;
+    projectId: string;
+    storageBucket: string;
+    messagingSenderId: string;
+    appId: string;
+    measurementId?: string;
+    databaseURL?: string;
+}
+export declare let auth: ReturnType<typeof getAuth>;
+export declare let provider: GoogleAuthProvider;
+export declare let analytics: ReturnType<typeof getAnalytics>;
+export declare let db: ReturnType<typeof getFirestore>;
+export declare let storage: ReturnType<typeof getStorage>;
+export declare let functions: ReturnType<typeof getFunctions>;
+export declare let messaging: ReturnType<typeof getMessaging>;
+export declare function setupFirebase(firebaseConfig: FirebaseConfig): FirebaseApp;
+export declare function ensureFirebase(): void;
+export { signInWithPopup };

package/dist/cmp/firebase/middlewareCatchCall.d.ts

@@ -0,0 +1 @@
+export declare function middlewareCatchCall(error: any, showToast?: boolean): void;

package/dist/cmp/firebase/useStoreWatch.d.ts

@@ -0,0 +1,9 @@
+import type { AnyFirestoreStoreReactive, GetProps } from './FirestoreStore';
+type StoreWatchItem = {
+    store: AnyFirestoreStoreReactive;
+    getOpts?: GetProps;
+    getAuthOpts?: GetProps;
+    checkLogin?: boolean;
+};
+export declare function useStoreWatch(stores: readonly StoreWatchItem[]): void;
+export {};

package/dist/cmp/form-validator/FormValidator.d.ts

@@ -0,0 +1,88 @@
+import { type ComputedRef, type Ref } from 'vue';
+export type RuleFn<V> = (value: V) => string | null;
+export type Schema<T> = {
+    [K in keyof T]?: RuleFn<T[K]>[];
+};
+type ErrorsOf<T> = {
+    [K in keyof T]: string | null;
+};
+type TouchedOf<T> = {
+    [K in keyof T]: boolean;
+};
+export interface FormValidatorOptions<T extends Record<string, any>> {
+    id?: string;
+    initialValues: T;
+    validator?: Schema<T>;
+    onSubmit?: (values: Readonly<T>, touchedValues: Partial<T>, touched: Readonly<TouchedOf<T>>) => void | Promise<void>;
+    onInvalid?: (errors: Readonly<ErrorsOf<T>>) => void;
+    /** Validazione on change (default: true per tutti) */
+    validateOnChange?: boolean | Partial<Record<keyof T, boolean>>;
+    /** Validazione on change (default: true per tutti) */
+    touchOnChange?: boolean | Partial<Record<keyof T, boolean>>;
+    syncWith?: Ref<Partial<T> | null | undefined> | (() => Partial<T> | null | undefined);
+    submitOnChange?: boolean | number;
+    syncPreference?: 'local' | 'db';
+    effects?: Partial<Record<keyof T, (value: T[keyof T], fv: FormValidator<T>) => void>>;
+    onAnyChange?: (key: keyof T, value: T[keyof T], fv: FormValidator<T>) => void;
+}
+export declare class FormValidator<T extends Record<string, any>> {
+    readonly id: string;
+    readonly values: T;
+    readonly errors: ErrorsOf<T>;
+    readonly touched: TouchedOf<T>;
+    private _initial;
+    private readonly schema;
+    private readonly _onSubmit?;
+    private readonly _onInvalid?;
+    private readonly _validateOnChangeMap;
+    private readonly _touchOnChangeMap;
+    private readonly _stopWatch?;
+    private _fieldCache;
+    private _allFields?;
+    private _submitOnChange?;
+    private _suspendAutoSubmit;
+    private _debouncedSubmit?;
+    private _syncPreference;
+    private readonly _effects?;
+    private readonly _onAnyChange?;
+    private _makeDebouncedSubmit;
+    constructor(options: FormValidatorOptions<T>);
+    constructor(initial: T, schema?: Schema<T>);
+    touch<K extends keyof T>(key: K): void;
+    touchAll(): void;
+    field<K extends keyof T>(key: K): ComputedRef<T[K]>;
+    fields(): {
+        [K in keyof T]: ComputedRef<T[K]>;
+    };
+    set<K extends keyof T>(key: K, value: T[K], validateNow?: boolean): void;
+    validateField<K extends keyof T>(key: K): boolean;
+    validateAll(): boolean;
+    fill(model: Partial<T>, options?: {
+        validate: boolean;
+    }): void;
+    reset({ keepTouched }?: {
+        keepTouched?: boolean;
+    }): void;
+    resetWithInitialValues(initialValues: T): void;
+    bindField<K extends keyof T>(key: K, forceValidateOnChange?: boolean): ComputedRef<T[K]>;
+    showError<K extends keyof T>(key: K): string | null;
+    hasError(k: keyof T): boolean;
+    getFieldId<K extends keyof T>(key: K): string;
+    getFieldIdError<K extends keyof T>(key: K): string;
+    getFieldProps<K extends keyof T>(key: K): {
+        id: string;
+        'aria-invalid': boolean;
+        'aria-describedby': string;
+        class: {
+            'is-invalid': boolean;
+        };
+    };
+    get isValid(): boolean;
+    get isDirty(): boolean;
+    get touchedValues(): Partial<T>;
+    dispose(): void;
+    /** Handler pronto per il form: @submit.prevent="fv.submit" */
+    submit: () => Promise<void>;
+    setSyncPreference(pref: 'local' | 'db'): void;
+}
+export {};

package/dist/cmp/form-validator/InputValueParser.d.ts

@@ -0,0 +1,25 @@
+import { Timestamp } from 'firebase/firestore';
+/** Timestamp | Date → 'YYYY-MM-DD' (input type="date") */
+export declare function timestampInputDate(v: Timestamp | Date | null | undefined): string;
+/** Timestamp | Date → 'HH:mm' (input type="time") */
+export declare function timestampInputTime(v: Timestamp | Date | null | undefined): string;
+/** Timestamp | Date → 'YYYY-MM-DDTHH:mm' (input type="datetime-local") */
+export declare function timestampInputDateTimeLocal(v: Timestamp | Date | null | undefined): string;
+/** 'YYYY-MM-DD' → Date (locale) */
+export declare function inputDateToDate(date: string): Date | null;
+/** 'YYYY-MM-DD' + 'HH:mm' → Timestamp */
+export declare function inputDateTimeToTimestamp(date: string, time?: string): Timestamp | null;
+/** Qualsiasi valore → stringa sicura per input text */
+export declare function valueToInputString(v: unknown, fallback?: string): string;
+/** Qualsiasi valore → number | '' (input type="number") */
+export declare function valueToInputNumber(v: unknown): number | '';
+/** Qualsiasi valore → boolean (input type="checkbox") */
+export declare function valueToInputBoolean(v: unknown): boolean;
+/** Garantisce sempre un array di stringhe (select multiple, tag, ecc.) */
+export declare function valueToStringArray(v: unknown): string[];
+/** Normalizza value per <select> (evita undefined) */
+export declare function valueToSelect<T extends string>(v: unknown, allowed?: readonly T[]): T | '';
+/** Timestamp | Date → locale string breve */
+export declare function timestampToLocale(v: Timestamp | Date | null | undefined, locale?: any): string;
+/** Stringa vuota → placeholder visivo */
+export declare function emptyToDash(v: unknown): string;

package/dist/cmp/form-validator/Validator.d.ts

@@ -0,0 +1,28 @@
+import type { RuleFn } from "./FormValidator";
+export declare const required: (msg?: string) => RuleFn<any>;
+export declare const email: (msg?: string) => RuleFn<string>;
+export declare const dateISO: (msg?: string) => RuleFn<string>;
+export declare const url: (msg?: string) => RuleFn<string>;
+export declare const oneOf: <V extends string>(choices: readonly V[], msg?: string) => RuleFn<V | undefined>;
+export declare const requiredTrue: (msg?: string) => RuleFn<boolean>;
+/** Deve essere un numero valido */
+export declare const isNumber: (msg?: string) => RuleFn<any>;
+/** Numero minimo (incluso) */
+export declare const minNumber: (min: number, msg?: string) => RuleFn<number | string>;
+/** Numero massimo (incluso) */
+export declare const maxNumber: (max: number, msg?: string) => RuleFn<number | string>;
+/** Lunghezza minima stringa */
+export declare const minLength: (min: number, msg?: string) => RuleFn<string>;
+/** Lunghezza massima stringa */
+export declare const maxLength: (max: number, msg?: string) => RuleFn<string>;
+export declare const password: (msg?: string) => RuleFn<string>;
+/** Password con lunghezza minima */
+export declare const passwordWithMin: (min: number, msg?: string) => RuleFn<string>;
+/** Conferma password: deve coincidere con la password originale */
+export declare const passwordRetype: (getOriginal: () => string | null | undefined, msg?: string) => RuleFn<string>;
+/** Deve essere dopo (>=) una data di riferimento */
+export declare const dateAfter: (getMin: () => string | Date | null | undefined, msg?: string) => RuleFn<string>;
+/** Deve essere prima (<=) di una data di riferimento */
+export declare const dateBefore: (getMax: () => string | Date | null | undefined, msg?: string) => RuleFn<string>;
+/** Deve essere compresa tra due date (inclusi) */
+export declare const dateBetween: (getMin: () => string | Date | null | undefined, getMax: () => string | Date | null | undefined, msg?: string) => RuleFn<string>;

package/dist/cmp/input/Gender/Gender.d.ts

@@ -0,0 +1 @@
+export type Gender = '' | 'm' | 'f' | 'o';

package/dist/cmp/input/PhoneNumber/PhoneNumber.d.ts

@@ -0,0 +1,2 @@
+export type PhoneNumber = [prefix: string, number: string];
+export declare const phoneNumberFromString: (phoneNumber: string, defaultPrefix?: string) => PhoneNumber;

package/dist/cmp/localStorage/LS.d.ts

@@ -0,0 +1,32 @@
+export declare const LS: {
+    defaultKey: {
+        isDev: string;
+        debugMod: string;
+        currentUser: string;
+    };
+    /** Lettura con gestione errori, valore  */
+    getStr(key: string): string | undefined;
+    /** Lettura con gestione errori, valore  */
+    getParsed(key: string): any;
+    /** Scrittura sicura con serializzazione JSON */
+    set(key: string, value: any): any;
+    /** Aggiorna un valore esistente */
+    update(key: string, data: any): any;
+    /** Aggiunge uno o più elementi a un array salvato in localStorage */
+    push(key: string, ...items: any[]): any;
+    /** Rimozione sicura */
+    remove(key: string): void;
+    /** Alias compatibile (ma corretto) */
+    delete(key: string): void;
+    /** Verifica se una chiave esiste */
+    has(key: string): boolean;
+    /** Elenca tutte le chiavi conosciute (solo quelle definite in LocalStorageKey) */
+    keys(): string[];
+    /**
+    * Svuota il localStorage tranne le chiavi indicate
+    * @param exclude una chiave o un array di chiavi da preservare
+    */
+    clear(exclude?: string | string[]): void;
+    /** Migra il valore da una chiave a un’altra */
+    migrate(oldKey: string, newKey: string): void;
+};

package/dist/cmp/network/network.d.ts

@@ -0,0 +1,3 @@
+export declare const MSG_IS_OFFLINE = "Sei offline: cancello in locale, sincronizzo quando torni online.";
+export declare function isBrowserOnline(): boolean;
+export declare function isBrowserOffline(): boolean;

package/dist/cmp/notification/pushMsg.d.ts

@@ -0,0 +1,18 @@
+import type { User } from '../../models/User';
+export type PushMsgContent = NotificationOptions & {
+    title: string;
+};
+export interface PushMsg {
+    reg: ServiceWorkerRegistration | undefined;
+    VAPID_PUBLIC_KEY: string | undefined;
+    isNotificationSupported: boolean;
+    permission: NotificationPermission;
+    needToAskPermission: boolean;
+    askPermission(currentUser: User): Promise<NotificationPermission>;
+    send(currentUser: User, content: string | PushMsgContent): Promise<void>;
+    sendTo(uid: string, content: string | PushMsgContent): Promise<boolean>;
+    getCurrentFcmToken(): Promise<string | null>;
+    registerFcmToken(currentUser: User): Promise<string | null>;
+    removeThisDeviceToken(currentUser: User): Promise<boolean>;
+}
+export declare const pushMsg: PushMsg;

package/dist/cmp/timestamp/parseTimestamp.d.ts

@@ -0,0 +1,8 @@
+import { Timestamp } from "firebase/firestore";
+export declare function reviveTimestamp(json: {
+    seconds: number;
+    nanoseconds: number;
+    type?: string;
+} | Timestamp): Timestamp;
+export declare function reviveTimestampsDeep(value: any): any;
+export declare const serializeTimestamp: (value: any) => any;