ngrx-entity-crud 19.2.5 → 19.4.0-beta.10

package/README.md

@@ -4,7 +4,7 @@ Commands for code generation:
  - `store`: Generates a feature set containing an `entity`, `actions`, `reducer`, ... file.
  - `section`: Generates a new Angular CRUD page containing an `list`, `detail`, `search`, ... file.
  - `auth`: Generates a boilerplate for authentication implementation containing an `store section` and `components` file.
- - `auth0`: Generates Auth0 implementation containing an `store section` and `components` file.
+ - `lazy-report`: Scans the project and reports which stores are good candidates to become lazy.
 
 # How to use it?
 To create your first project, follow this [guide](https://github.com/jucasoft/ngrx-entity-crud-prime-ng-boilerplate).
@@ -49,8 +49,28 @@ Store type:
   - Enum: `"CRUD-PLURAL", "CRUD-SINGULAR", "CRUD+GRAPHQL", "BASE"`
   - Default: `false`
 
+Store registration strategy:
+  - `eager`: the store is declared in the application `RootStoreModule` (historical behavior); reducers/effects are loaded at startup.
+  - `lazy`: the store is **not** registered in the root; the view feature module is responsible for importing `<Clazz>StoreModule`, so reducers/effects are loaded only when the section is opened.
+
+- `--registration`
+  - Type: `string`
+  - Enum: `"eager", "lazy"`
+  - Optional. If omitted, the schematic asks interactively. In non-interactive runs (CI/scripts) it falls back to `eager`, so existing pipelines keep working unchanged.
+
+> **Lazy mode notes**
+> - With `--registration=lazy` nothing registers the store automatically: you must import `<Clazz>StoreModule` in the feature module generated for the view (e.g. `coin.module.ts`).
+> - The generated slice is declared as **optional** in `root-store/state.ts`, because it does not exist in the runtime state until the section is loaded.
+> - `root-store/selectors.ts` exposes the global loading/error selectors (`selectIsLoading`, `selectError`, `selectLoadingNames`) in a **store-agnostic** way: they scan the root state using the `EntityCrudBaseState` convention (every CRUD slice exposes `isLoading`/`error` at the top level), so lazily-registered stores contribute to the global loading/error state without coupling the root to any specific domain.
+
 #### Examples
 
+```sh
+ng generate ngrx-entity-crud:store --name=coin --clazz=Coin --type=CRUD-PLURAL --registration=lazy
+```
+With `--registration=lazy` the store is not added to `RootStoreModule`; remember to import `CoinStoreModule` in the view feature module.
+
+
 ```sh
 ng generate ngrx-entity-crud:store --name=coin --clazz=Coin --type=CRUD-PLURAL
 ```
@@ -242,50 +262,196 @@ UPDATE src/app/root-store/__clazz@dasherize__.state.ts (184 bytes)
 UPDATE src/app/root-store/root-store.module.ts (1051 bytes)
 ```
 
-## auth0
+## lazy-report
 
 ---
 
 ### Overview
 
-Generates a boilerplate for authentication implementation containing an `store section` and `components` file.
+Read-only analysis command. It scans the project and produces a report that maps each store to
+the sections that use it, then suggests which stores are good candidates to be registered as
+**lazy** (see the `--registration` option of the `store` command). Nothing is modified except the
+generated report file: you decide what to convert.
+
+How a store is classified:
+- **candidato lazy**: used by exactly one section, and that section is on a lazy route (`loadChildren`).
+- **multi-sezione**: used by more than one section (evaluate a shared lazy module).
+- **tieni eager (usato dalla shell)**: referenced by the app shell (`core/`, `main/components`, `app.component`) — must stay eager.
+- **sezione non lazy-routed**: its only section is loaded eagerly, so going lazy gives little benefit.
+- **infra (eager)**: infrastructure store (e.g. `router-store`), excluded from candidates.
+- **orfano**: not referenced by any section.
+
+The scan is static and relies on the naming convention (`XxxStoreActions/Selectors/State/Module`).
+Paths are read from `ngrx-entity-crud.conf.json` when present, otherwise defaults are used
+(`src/app/root-store`, `src/app/main/views`, `src/app`).
 
 ### Command
 
 ```sh
-ng generate ngrx-entity-crud:auth0
+ng generate ngrx-entity-crud:lazy-report [options]
 ```
 
+### Options
+
+Report file to write (relative to the workspace root); empty string = console only.
+- `--output`
+  - Type: `string`
+  - Default: `lazy-report.md`
+
+Format of the written report.
+- `--format`
+  - Type: `string`
+  - Enum: `"md", "json"`
+  - Default: `md`
+
+Infrastructure stores excluded from lazy candidates (folder names).
+- `--infra-stores`
+  - Type: `string[]`
+  - Default: `["router-store"]`
+
+Include detected persistence providers (localStorage/IndexedDB) from `package.json` in the report.
+- `--storage`
+  - Type: `boolean`
+  - Default: `true`
+
+The JSON report (`--format=json`) also includes a top-level `generatedAt` (ISO timestamp, for
+staleness detection) and, per store, the structured booleans `lazyRoute` and `isLazyCandidate`
+(so tools can correlate without parsing the textual `verdict`). When `--storage` is enabled it
+adds a `storage` object `{ providers, source }`. The `{ paths, stores }` shape is unchanged
+(additive, backward-compatible).
+
 #### Examples
 
 ```sh
-ng generate ngrx-entity-crud:auth0
+ng generate ngrx-entity-crud:lazy-report
+ng generate ngrx-entity-crud:lazy-report --format=json --output=lazy-report.json
+ng generate ngrx-entity-crud:lazy-report --output=        # solo console
 ```
 
-#### Files generated/changed by the “:auth0” command
+Example output (excerpt):
+
+```md
+| store | clazz | type | sezioni | n | lazy route | shell | verdetto |
+|---|---|---|---|---|---|---|---|
+| coin-store | Coin | CRUD-PLURAL | coin | 1 | si | no | candidato lazy |
+| currency-store | Currency | CRUD-PLURAL | coin, invoice | 2 | si | no | multi-sezione (2) -> valuta modulo condiviso |
+| menu-store | Menu | CRUD-PLURAL | - | 0 | - | si | tieni eager (usato dalla shell) |
+```
+
+## dashboard
+
+---
+
+### Overview
+
+Scaffolds a **project dashboard** view with three runtime summaries: localStorage usage,
+IndexedDB usage (agnostic to the persistence library you use), and NgRx stores + lazy-loading
+candidates. The generated module hosts `<nec-dashboard>`, the standalone component exported by the
+secondary entry-point `ngrx-entity-crud/devtools`; all the diagnostic logic lives in the library
+(versioned and tested), not in generated code.
+
+`<nec-dashboard>` is built on **PrimeNG** components (`p-card`, `p-table`, `p-tag`, `p-tree`, the
+`pButton` directive), so the `ngrx-entity-crud/devtools` entry-point requires `primeng` and
+`primeicons` in your app (declared as **optional** peerDependencies — the core entry-point does
+not need them). The component uses the `pButton` severity *classes* and the `success`/`info`/
+`danger` tag severities, an idiom compatible with PrimeNG 16 (the consumer baseline) through the
+later majors.
+
+By default it also generates `src/assets/lazy-report.json` (reusing `lazy-report --format=json`),
+which the dashboard reads at runtime to correlate the loaded/lazy state of each store.
+
+The dashboard can run in **production**: by default it shows only keys, sizes and counts — never
+raw values. Value reveal is opt-in (`[allowRevealValues]="true"`) and always masks sensitive
+patterns (token/JWT/email/secret); keys that look sensitive are flagged.
+
+### Command
 
 ```sh
-CREATE src/app/root-store/auth-store/__clazz@dasherize__.actions.ts (776 bytes)
-CREATE src/app/root-store/auth-store/auth-store.module.ts (1044 bytes)
-CREATE src/app/root-store/auth-store/auth.guard.ts (1359 bytes)
-CREATE src/app/root-store/auth-store/authentication.service.ts (675 bytes)
-CREATE src/app/root-store/auth-store/conf.ts (75 bytes)
-CREATE src/app/root-store/auth-store/__clazz@dasherize__.effects.ts (1754 bytes)
-CREATE src/app/root-store/auth-store/index.d.ts (271 bytes)
-CREATE src/app/root-store/auth-store/index.ts (271 bytes)
-CREATE src/app/root-store/auth-store/login.component.ts (2117 bytes)
-CREATE src/app/root-store/auth-store/__clazz@dasherize__.names.ts (47 bytes)
-CREATE src/app/root-store/auth-store/profile.ts (224 bytes)
-CREATE src/app/root-store/auth-store/__clazz@dasherize__.reducer.ts (475 bytes)
-CREATE src/app/root-store/auth-store/__clazz@dasherize__.selectors.ts (699 bytes)
-CREATE src/app/root-store/auth-store/__clazz@dasherize__.state.ts (192 bytes)
+ng generate ngrx-entity-crud:dashboard [options]
+```
 
-UPDATE src/app/root-store/index.ts (309 bytes)
-UPDATE src/app/root-store/index.d.ts (309 bytes)
-UPDATE src/app/root-store/__clazz@dasherize__.state.ts (184 bytes)
-UPDATE src/app/root-store/root-store.module.ts (1051 bytes)
+### Options
+
+Feature name (drives the lazy route and the generated file names).
+- `--clazz`
+  - Type: `string`
+  - Default: `Dashboard`
+
+Generate the lazy-report JSON read by the dashboard.
+- `--include-lazy-report`
+  - Type: `boolean`
+  - Default: `true`
+
+Path of the generated lazy-report JSON.
+- `--lazy-report-output`
+  - Type: `string`
+  - Default: `src/assets/lazy-report.json`
+
+The name of the project.
+- `--project`
+  - Type: `string`
+
+#### Using the standalone component directly
+
+If you prefer not to scaffold, import the component from the secondary entry-point and mount it
+anywhere (e.g. behind a dev-only route):
+
+```ts
+import { NecDashboardComponent } from 'ngrx-entity-crud/devtools';
+
+@Component({
+  standalone: true,
+  imports: [NecDashboardComponent],
+  template: `<nec-dashboard
+    lazyReportUrl="assets/lazy-report.json"
+    [idbDatabaseNames]="['NgRxStateStore']"
+    [allowRevealValues]="false"
+    [pollingMs]="0"
+    (sliceReset)="onSliceReset($event)"></nec-dashboard>`,
+})
+export class DevPanelComponent {
+  onSliceReset(sliceKey: string): void {
+    // reactivity hook: a CRUD slice has just been reset to its initial state
+  }
+}
 ```
 
+Inputs: `blacklist` / `whitelist` (`string[]`, filter store slices), `lazyReportUrl`
+(default `assets/lazy-report.json`; empty string disables the static correlation),
+`idbDatabaseNames` (`string[]`, DB names to inspect where `indexedDB.databases()` is unsupported —
+Firefox / older Safari), `pollingMs` (`number`, auto-refresh; `0` = manual), `allowRevealValues`
+(`boolean`, opt-in masked value reveal — gates both localStorage values and IndexedDB record
+values), `idbEntryLimit` (`number`, default `50`, max records read per object store in the
+IndexedDB tree).
+
+Outputs: `sliceReset` (`EventEmitter<string>`) emits the slice key whenever a full `Reset` is
+dispatched (including via the global **Azzera tutte** button).
+
+Notes:
+- The **Store NgRx** panel exposes per-row actions: **reset** dispatches the library's `Reset`
+  action (`[key] Reset`), restoring the slice to its `initialState` (empty entities, selection,
+  criteria and responses); **reset responses** dispatches the lighter `ResetResponses`
+  (`[key] Reset Response`). A toolbar **Azzera tutte** button resets every listed slice at once.
+  All three are destructive and require an inline two-step confirmation before dispatching.
+  Because the slice key in the root state matches the action name by convention (the `store`
+  schematic feeds the same `Names.NAME` to both `StoreModule.forFeature` and `createCrudActions`),
+  the dashboard can target the right action from the slice key alone — no per-domain wiring needed.
+  After a reset the dashboard refreshes its counts; if you persist the NgRx state (e.g. to
+  IndexedDB), your persistence layer will write back the emptied state, clearing the local data.
+- The **Store NgRx** panel has a toggle button: by default it lists every mounted slice, but
+  **Mostra solo le slice con dati** filters down to slices that actually hold data (entities for
+  `plural`, an `item` for `singular`, or cached responses).
+- IndexedDB is introspected **agnostically** via native APIs (`indexedDB.databases()` + `count()`),
+  with an optional `NEC_IDB_ADAPTER` injection token for custom providers. Byte sizes per
+  record/store are not measurable; only record counts and the aggregate origin quota
+  (`navigator.storage.estimate()`) are shown. The panel renders a PrimeNG `p-tree` (database →
+  object store → record): expanding an object store **lazily** reads up to `idbEntryLimit` records
+  and lists their keys; with `[allowRevealValues]="true"` each record can be expanded further to
+  show its value (serialized to JSON and masked for sensitive patterns).
+- `<nec-dashboard>` is a standalone component that imports PrimeNG modules and uses the classic
+  structural directives (`*ngIf`/`*ngFor`), so it stays compatible with Angular 16+ consumers; the
+  core entry-point keeps the wider peer range and has no PrimeNG dependency.
+
 ## Running unit tests
 Run `ng test` to execute the unit tests via [Karma](https://karma-runner.github.io).
 

package/devtools/agnostic-selectors.d.ts

@@ -0,0 +1,32 @@
+import { MemoizedSelector } from '@ngrx/store';
+/**
+ * Versione FACTORY (parametrizzabile) dei selettori agnostici di loading/error che il
+ * template `ng-add` installa in `root-store/selectors.ts`.
+ *
+ * Il template resta invariato (retro-compatibilità): qui la logica è IDENTICA ma con
+ * `rootSelector`/`blacklist`/`whitelist` resi parametri invece che costanti hardcoded, così
+ * è riutilizzabile dal pacchetto npm (entry-point `ngrx-entity-crud/devtools`).
+ *
+ * Scandisce lo stato sfruttando la convenzione `EntityCrudBaseState`: ogni slice CRUD espone
+ * `isLoading: boolean` ed `error: string | null` al livello top.
+ */
+export interface AgnosticLoadingSelectorsOptions {
+    /** Selettore della radice da scandire (default: l'intero stato root). */
+    rootSelector?: (state: any) => Record<string, any>;
+    /** Chiavi di slice da escludere dallo scan. */
+    blacklist?: ReadonlyArray<string>;
+    /** Se valorizzata, considera SOLO queste chiavi (precede la blacklist). */
+    whitelist?: ReadonlyArray<string>;
+}
+export interface AgnosticLoadingSelectors {
+    /** Nomi delle slice attualmente in caricamento (`isLoading === true`). */
+    selectLoadingNames: MemoizedSelector<any, string[]>;
+    /** `true` se almeno una slice CRUD è in caricamento. */
+    selectIsLoading: MemoizedSelector<any, boolean>;
+    /** Elenco degli errori non vuoti presenti nelle slice CRUD. */
+    selectErrors: MemoizedSelector<any, string[]>;
+    /** Concatenazione degli errori non vuoti (stringa vuota se non ce ne sono). */
+    selectError: MemoizedSelector<any, string>;
+}
+export declare function createAgnosticLoadingSelectors(options?: AgnosticLoadingSelectorsOptions): AgnosticLoadingSelectors;
+//# sourceMappingURL=agnostic-selectors.d.ts.map

package/devtools/agnostic-selectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agnostic-selectors.d.ts","sourceRoot":"","sources":["../../../libs/ngrx-entity-crud/devtools/agnostic-selectors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,gBAAgB,EAAC,MAAM,aAAa,CAAC;AAE7D;;;;;;;;;;GAUG;AACH,MAAM,WAAW,+BAA+B;IAC9C,yEAAyE;IACzE,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACnD,+CAA+C;IAC/C,SAAS,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAClC,2EAA2E;IAC3E,SAAS,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACnC;AAED,MAAM,WAAW,wBAAwB;IACvC,0EAA0E;IAC1E,kBAAkB,EAAE,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,CAAC,CAAC;IACpD,wDAAwD;IACxD,eAAe,EAAE,gBAAgB,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IAChD,+DAA+D;IAC/D,YAAY,EAAE,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,CAAC,CAAC;IAC9C,+EAA+E;IAC/E,WAAW,EAAE,gBAAgB,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;CAC5C;AAOD,wBAAgB,8BAA8B,CAC5C,OAAO,GAAE,+BAAoC,GAC5C,wBAAwB,CAoC1B"}

package/devtools/idb-adapter.token.d.ts

@@ -0,0 +1,11 @@
+import { InjectionToken } from '@angular/core';
+import { NecIdbAdapter } from './models';
+/**
+ * Adapter IndexedDB OPZIONALE, agnostico rispetto alla libreria di persistenza.
+ *
+ * Fornendolo, il `NecIndexedDbProbeService` lo usa con priorità per enumerare i database
+ * (utile quando la libreria del consumer nasconde i nomi DB o su browser senza
+ * `indexedDB.databases()`, es. Firefox). Quando NON fornito, il probe usa solo le API native.
+ */
+export declare const NEC_IDB_ADAPTER: InjectionToken<NecIdbAdapter>;
+//# sourceMappingURL=idb-adapter.token.d.ts.map

package/devtools/idb-adapter.token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"idb-adapter.token.d.ts","sourceRoot":"","sources":["../../../libs/ngrx-entity-crud/devtools/idb-adapter.token.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,cAAc,EAAC,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAC,aAAa,EAAC,MAAM,UAAU,CAAC;AAEvC;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,+BAAuD,CAAC"}

package/devtools/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="ngrx-entity-crud/devtools" />
+export * from './public-api';
+//# sourceMappingURL=ngrx-entity-crud-devtools.d.ts.map

package/devtools/mask.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Utility di privacy per la dashboard: poiché può girare anche in PRODUZIONE, i valori non
+ * vengono mai mostrati di default e — quando il consumer abilita esplicitamente il reveal —
+ * vengono comunque mascherati i pattern sensibili (token/JWT/email/segreti).
+ */
+/** `true` se il nome chiave suggerisce un contenuto sensibile (token, password, ecc.). */
+export declare function looksSensitiveKey(key: string): boolean;
+/** Redige nel testo i pattern sensibili comuni (JWT, email, token/hex lunghi). */
+export declare function redactSensitive(value: string): string;
+/**
+ * Valore "sicuro da mostrare": se la chiave è sensibile, nasconde tutto (mostra solo la
+ * lunghezza); altrimenti redige i pattern sensibili e tronca a `maxLength`.
+ */
+export declare function maskValue(key: string, value: string, maxLength?: number): string;
+//# sourceMappingURL=mask.d.ts.map

package/devtools/mask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mask.d.ts","sourceRoot":"","sources":["../../../libs/ngrx-entity-crud/devtools/mask.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,0FAA0F;AAC1F,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED,kFAAkF;AAClF,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAMrD;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,SAAM,GAAG,MAAM,CAS7E"}

package/devtools/models.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Modelli dei report prodotti dai probe della dashboard (`ngrx-entity-crud/devtools`).
+ *
+ * Sono volutamente indipendenti dai tipi del main entry-point: i probe leggono lo stato
+ * per CONVENZIONE (vedi `EntityCrudBaseState` in `src/lib/models.ts`), non per tipo, così
+ * il sotto-modulo `devtools` resta autonomo e agnostico rispetto alla persistenza usata.
+ */
+export interface NecStorageEntry {
+    key: string;
+    /** Byte verso la quota (UTF-16): `(key.length + value.length) * 2`. Metrica primaria. */
+    bytesUtf16: number;
+    /** Byte della serializzazione UTF-8 (`TextEncoder`/`Blob`). Metrica secondaria. */
+    bytesUtf8: number;
+}
+export interface NecStorageReport {
+    available: boolean;
+    type: 'local' | 'session';
+    entries: NecStorageEntry[];
+    count: number;
+    totalBytesUtf16: number;
+    totalBytesUtf8: number;
+}
+/** Stima quota AGGREGATA per-origine (localStorage + IndexedDB + Cache), non scorporabile. */
+export interface NecQuotaEstimate {
+    available: boolean;
+    usage?: number;
+    quota?: number;
+    /** Non-standard (solo Chromium): byte per area. Assente su Firefox/Safari. */
+    usageDetails?: Record<string, number>;
+}
+export interface NecIdbStoreReport {
+    name: string;
+    /** Numero record (`objectStore.count()`); `null` se non determinabile. */
+    count: number | null;
+}
+export interface NecIdbDbReport {
+    name: string;
+    version: number | null;
+    stores: NecIdbStoreReport[];
+    note?: string;
+}
+export interface NecIdbReport {
+    available: boolean;
+    /** `false` se non è stato possibile elencare i database (es. Firefox senza nomi forniti). */
+    enumerable: boolean;
+    /** Nome dell'adapter usato: `'native'`, il nome di un `NecIdbAdapter`, o `null`. */
+    adapter: string | null;
+    databases: NecIdbDbReport[];
+    note?: string;
+}
+/** Un record di un object store IndexedDB, letto ON-DEMAND per la vista ad albero. */
+export interface NecIdbEntry {
+    /** Chiave primaria del record, serializzata a stringa. */
+    key: string;
+    /** Valore grezzo del record; la dashboard lo serializza/maschera prima di mostrarlo. */
+    value: unknown;
+}
+/** Risultato della lettura on-demand dei record di un object store (vista ad albero). */
+export interface NecIdbStoreEntries {
+    db: string;
+    store: string;
+    entries: NecIdbEntry[];
+    /** Conteggio totale dei record (`count()`); `null` se non determinabile. */
+    total: number | null;
+    /** `true` se `entries` è troncato rispetto a `total` (raggiunto il `limit`). */
+    truncated: boolean;
+    note?: string;
+}
+/**
+ * Punto di estensione agnostico: il consumer può fornire un adapter esplicito (via
+ * `NEC_IDB_ADAPTER`) per conteggi accurati quando la sua libreria di persistenza nasconde
+ * i nomi DB. Quando assente, il probe usa solo le API native.
+ */
+export interface NecIdbAdapter {
+    name: string;
+    isAvailable(): boolean;
+    listDatabases(): Promise<NecIdbDbReport[]>;
+}
+export type NecSliceKind = 'plural' | 'singular' | 'unknown';
+export interface NecStoreSlice {
+    key: string;
+    kind: NecSliceKind;
+    isLoading: boolean;
+    isLoaded: boolean;
+    error: string | null;
+    /** Numero entità (solo slice `plural`). */
+    entityCount?: number;
+    responsesCount: number;
+    /** `true` se la slice contiene dati: entità (`plural`), item (`singular`) o response. */
+    hasData: boolean;
+}
+export type NecRuntimeStatus = 'loaded' | 'lazy-not-loaded' | 'unknown';
+export interface NecLazyEntry {
+    name: string;
+    clazz?: string;
+    type?: string;
+    verdict?: string;
+    isLazyCandidate: boolean;
+    lazyRoute?: boolean;
+    sections: string[];
+    usedByShell: boolean;
+    runtimeStatus: NecRuntimeStatus;
+}
+export interface NecStoreReport {
+    slices: NecStoreSlice[];
+    loadingNames: string[];
+    errors: string[];
+    /** Presente solo se è stato fornito un `lazyReportUrl` e il fetch è riuscito. */
+    lazy?: NecLazyEntry[];
+    /** Timestamp ISO di generazione del `lazy-report.json` (per segnalare snapshot stantii). */
+    lazyReportGeneratedAt?: string;
+}
+//# sourceMappingURL=models.d.ts.map

package/devtools/models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../../libs/ngrx-entity-crud/devtools/models.ts"],"names":[],"mappings":"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"}

package/devtools/nec-dashboard.component.d.ts

@@ -0,0 +1,103 @@
+import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { TreeNode } from 'primeng/api';
+import { NecIdbReport, NecQuotaEstimate, NecStorageReport, NecStoreReport } from './models';
+import * as i0 from "@angular/core";
+/**
+ * `<nec-dashboard>` — dashboard di gestione progetto plug-and-play.
+ *
+ * Standalone, OnPush, costruita sui componenti **PrimeNG** (`p-card`, `p-table`, `p-tag`,
+ * `p-tree`, direttiva `pButton`): richiede quindi `primeng` + `primeicons` nell'app consumer
+ * (peerDependencies opzionali del solo entry-point `devtools`). Quattro pannelli: quota
+ * origine, localStorage, IndexedDB (agnostico, con `p-tree` espandibile e lazy-load dei
+ * record), store NgRx + sezioni lazy. Per privacy mostra di default SOLO chiavi/dimensioni/
+ * conteggi; i valori (localStorage e record IndexedDB) sono rivelabili solo con
+ * `allowRevealValues` e comunque mascherati. Refresh manuale di default; polling opt-in via
+ * `pollingMs`. Usabile anche in produzione.
+ *
+ * I pulsanti usano la direttiva `pButton` con le **classi** severity (`p-button-danger`,
+ * `-text`, `-sm`) e i tag solo le severity `success`/`info`/`danger`: questo idioma è
+ * compatibile sia con PrimeNG 16 (target dell'app consumer) sia con le major successive.
+ * Il template usa le direttive strutturali classiche (`*ngIf`/`*ngFor`) anziché il
+ * control-flow `@if`/`@for`, per restare compatibile con Angular 16+.
+ */
+export declare class NecDashboardComponent implements OnInit, OnDestroy {
+    private readonly localStorageProbe;
+    private readonly indexedDbProbe;
+    private readonly storeProbe;
+    /** Chiavi di slice da escludere dallo scan dello store. */
+    blacklist: string[];
+    /** Se valorizzata, considera SOLO queste chiavi di slice (precede la blacklist). */
+    whitelist: string[];
+    /** URL del report statico (`lazy-report --format=json`); `null`/'' per disattivarlo. */
+    lazyReportUrl: string | null;
+    /** Nomi DB IndexedDB da ispezionare dove `databases()` non è supportato (es. Firefox). */
+    idbDatabaseNames: string[];
+    /** Intervallo di auto-refresh in ms; 0 = solo manuale (default). */
+    pollingMs: number;
+    /** Abilita il reveal opt-in dei valori localStorage e dei record IndexedDB (sempre mascherati). Default: false. */
+    allowRevealValues: boolean;
+    /** Numero massimo di record letti per object store nella vista ad albero IndexedDB. Default: 50. */
+    idbEntryLimit: number;
+    /** Emesso (con la slice key) a ogni `Reset` completo dispacciato, incluso l'azzera-tutte. */
+    sliceReset: EventEmitter<string>;
+    readonly busy: import("@angular/core").WritableSignal<boolean>;
+    readonly lastUpdated: import("@angular/core").WritableSignal<string>;
+    readonly storage: import("@angular/core").WritableSignal<NecStorageReport>;
+    readonly quota: import("@angular/core").WritableSignal<NecQuotaEstimate>;
+    readonly idb: import("@angular/core").WritableSignal<NecIdbReport>;
+    readonly storeReport: import("@angular/core").WritableSignal<NecStoreReport>;
+    readonly revealed: import("@angular/core").WritableSignal<Record<string, string>>;
+    /** Slice in attesa di conferma per il `Reset` completo (conferma a due step). */
+    readonly pendingResetKey: import("@angular/core").WritableSignal<string>;
+    /** Slice in attesa di conferma per il `ResetResponses`. */
+    readonly pendingResponsesKey: import("@angular/core").WritableSignal<string>;
+    /** `true` quando è in attesa di conferma l'azzeramento globale di tutte le slice. */
+    readonly pendingResetAll: import("@angular/core").WritableSignal<boolean>;
+    /** `true` per mostrare solo le slice che contengono dati (filtro del pannello Store NgRx). */
+    readonly onlyWithData: import("@angular/core").WritableSignal<boolean>;
+    /** Slice visibili in base al filtro `onlyWithData`. */
+    readonly visibleSlices: import("@angular/core").Signal<import("./models").NecStoreSlice[]>;
+    /** Nodi `p-tree` della vista IndexedDB (DB → object store; i record sono lazy-load). */
+    readonly idbTreeNodes: import("@angular/core").WritableSignal<TreeNode<any>[]>;
+    /** `true` mentre `p-tree` sta caricando i record di un object store espanso. */
+    readonly idbLoading: import("@angular/core").WritableSignal<boolean>;
+    private timer;
+    /** Un refresh richiesto mentre un altro è già in corso: viene ri-eseguito al termine. */
+    private pendingRefresh;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    refresh(): Promise<void>;
+    /** Reveal opt-in di un valore localStorage, sempre passato per `maskValue` (privacy). */
+    reveal(key: string): void;
+    /** Alterna fra "tutte le slice" e "solo le slice con dati". */
+    toggleOnlyWithData(): void;
+    /** Costruisce i nodi DB → object store dal report; i record restano vuoti (lazy-load). */
+    private buildIdbTree;
+    /** Lazy-load: alla prima espansione di un object store ne legge i record e ne crea i nodi. */
+    onNodeExpand(event: {
+        node: TreeNode;
+    }): Promise<void>;
+    /** Trasforma i record letti in nodi `record` (più nodi `note` per store vuoto/troncato). */
+    private buildRecordNodes;
+    /** Serializza e maschera (privacy) il valore grezzo di un record IndexedDB per la UI. */
+    formatIdbValue(value: unknown): string;
+    /** Step 1: chiede conferma per il `Reset` completo della slice. */
+    requestReset(key: string): void;
+    /** Step 1: chiede conferma per il `ResetResponses` della slice. */
+    requestResetResponses(key: string): void;
+    /** Step 1: chiede conferma per l'azzeramento globale di tutte le slice. */
+    requestResetAll(): void;
+    /** Annulla qualsiasi conferma pendente (reset/responses/azzera-tutte). */
+    cancelPending(): void;
+    /** Step 2: dispaccia il `Reset` della slice, emette `sliceReset` e ricarica i conteggi. */
+    confirmReset(key: string): void;
+    /** Step 2: dispaccia il `ResetResponses` della slice e ricarica i conteggi. */
+    confirmResetResponses(key: string): void;
+    /** Step 2: dispaccia il `Reset` su tutte le slice elencate, emettendo `sliceReset` per ciascuna. */
+    confirmResetAll(): void;
+    isSensitive(key: string): boolean;
+    formatBytes(n: number | undefined | null): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NecDashboardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NecDashboardComponent, "nec-dashboard", never, { "blacklist": { "alias": "blacklist"; "required": false; }; "whitelist": { "alias": "whitelist"; "required": false; }; "lazyReportUrl": { "alias": "lazyReportUrl"; "required": false; }; "idbDatabaseNames": { "alias": "idbDatabaseNames"; "required": false; }; "pollingMs": { "alias": "pollingMs"; "required": false; }; "allowRevealValues": { "alias": "allowRevealValues"; "required": false; }; "idbEntryLimit": { "alias": "idbEntryLimit"; "required": false; }; }, { "sliceReset": "sliceReset"; }, never, never, true, never>;
+}
+//# sourceMappingURL=nec-dashboard.component.d.ts.map

package/devtools/nec-dashboard.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nec-dashboard.component.d.ts","sourceRoot":"","sources":["../../../libs/ngrx-entity-crud/devtools/nec-dashboard.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,YAAY,EAGZ,SAAS,EACT,MAAM,EAGP,MAAM,eAAe,CAAC;AAOvB,OAAO,EAAC,QAAQ,EAAC,MAAM,aAAa,CAAC;AACrC,OAAO,EAAC,YAAY,EAAsB,gBAAgB,EAAE,gBAAgB,EAAE,cAAc,EAAC,MAAM,UAAU,CAAC;;AAM9G;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAmTa,qBAAsB,YAAW,MAAM,EAAE,SAAS;IAC7D,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAuC;IACzE,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAoC;IACnE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgC;IAE3D,2DAA2D;IAClD,SAAS,EAAE,MAAM,EAAE,CAAM;IAClC,oFAAoF;IAC3E,SAAS,EAAE,MAAM,EAAE,CAAM;IAClC,wFAAwF;IAC/E,aAAa,EAAE,MAAM,GAAG,IAAI,CAA6B;IAClE,0FAA0F;IACjF,gBAAgB,EAAE,MAAM,EAAE,CAAM;IACzC,oEAAoE;IAC3D,SAAS,SAAK;IACvB,mHAAmH;IAC1G,iBAAiB,UAAS;IACnC,oGAAoG;IAC3F,aAAa,SAAM;IAE5B,6FAA6F;IACnF,UAAU,uBAA8B;IAElD,QAAQ,CAAC,IAAI,kDAAiB;IAC9B,QAAQ,CAAC,WAAW,iDAA+B;IACnD,QAAQ,CAAC,OAAO,2DAAyC;IACzD,QAAQ,CAAC,KAAK,2DAAyC;IACvD,QAAQ,CAAC,GAAG,uDAAqC;IACjD,QAAQ,CAAC,WAAW,yDAAuC;IAC3D,QAAQ,CAAC,QAAQ,iEAAsC;IACvD,iFAAiF;IACjF,QAAQ,CAAC,eAAe,iDAA+B;IACvD,2DAA2D;IAC3D,QAAQ,CAAC,mBAAmB,iDAA+B;IAC3D,qFAAqF;IACrF,QAAQ,CAAC,eAAe,kDAAiB;IAEzC,8FAA8F;IAC9F,QAAQ,CAAC,YAAY,kDAAiB;IACtC,uDAAuD;IACvD,QAAQ,CAAC,aAAa,qEAGnB;IAEH,wFAAwF;IACxF,QAAQ,CAAC,YAAY,0DAA0B;IAC/C,gFAAgF;IAChF,QAAQ,CAAC,UAAU,kDAAiB;IAEpC,OAAO,CAAC,KAAK,CAA+C;IAC5D,yFAAyF;IACzF,OAAO,CAAC,cAAc,CAAS;IAE/B,QAAQ,IAAI,IAAI;IAOhB,WAAW,IAAI,IAAI;IAOb,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAkC9B,yFAAyF;IACzF,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAOzB,+DAA+D;IAC/D,kBAAkB,IAAI,IAAI;IAM1B,0FAA0F;IAC1F,OAAO,CAAC,YAAY;IAsBpB,8FAA8F;IACxF,YAAY,CAAC,KAAK,EAAE;QAAC,IAAI,EAAE,QAAQ,CAAA;KAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAmB1D,4FAA4F;IAC5F,OAAO,CAAC,gBAAgB;IA0BxB,yFAAyF;IACzF,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM;IAUtC,mEAAmE;IACnE,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAM/B,mEAAmE;IACnE,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAMxC,2EAA2E;IAC3E,eAAe,IAAI,IAAI;IAMvB,0EAA0E;IAC1E,aAAa,IAAI,IAAI;IAMrB,2FAA2F;IAC3F,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAO/B,+EAA+E;IAC/E,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAMxC,oGAAoG;IACpG,eAAe,IAAI,IAAI;IAUvB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIjC,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,MAAM;yCAhQtC,qBAAqB;2CAArB,qBAAqB;CA4QjC"}

package/devtools/ngrx-entity-crud-devtools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ngrx-entity-crud-devtools.d.ts","sourceRoot":"","sources":["../../../libs/ngrx-entity-crud/devtools/ngrx-entity-crud-devtools.ts"],"names":[],"mappings":"AAAA;;GAEG;;AAEH,cAAc,cAAc,CAAC"}

package/devtools/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/ngrx-entity-crud-devtools.mjs"
+}

package/devtools/probes/nec-indexeddb-probe.service.d.ts

@@ -0,0 +1,35 @@
+import { NecIdbAdapter, NecIdbReport, NecIdbStoreEntries } from '../models';
+import * as i0 from "@angular/core";
+/**
+ * Riepilogo IndexedDB AGNOSTICO rispetto alla libreria di persistenza.
+ *
+ * Priorità reale: (1) `NEC_IDB_ADAPTER` esplicito, (2) API native
+ * (`indexedDB.databases()` + `open()` + `count()`). NESSUN import di librerie di
+ * persistenza. Mostra il numero di record per object store; i byte per-store NON sono
+ * misurabili e non vengono promessi (solo la quota aggregata, altrove).
+ */
+export declare class NecIndexedDbProbeService {
+    private readonly adapter;
+    constructor(adapter: NecIdbAdapter | null);
+    /**
+     * @param fallbackDatabaseNames nomi DB da ispezionare quando `indexedDB.databases()` non
+     *   è supportato (Firefox / Safari vecchi). Passa qui i nomi noti della tua persistenza.
+     * @param openTimeoutMs timeout per ogni `open()` (default 3000ms).
+     */
+    read(fallbackDatabaseNames?: string[], openTimeoutMs?: number): Promise<NecIdbReport>;
+    private listDatabaseNames;
+    private inspectDatabase;
+    /**
+     * Legge ON-DEMAND i record di un object store, per la vista ad albero della dashboard.
+     *
+     * Usa un cursore e si ferma a `limit` record (default 50) per non caricare in memoria interi
+     * store enormi; `truncated` segnala se ci sono altri record oltre il limite. Restituisce i
+     * valori GREZZI: la serializzazione/mascheratura per la privacy spetta alla dashboard.
+     */
+    readStoreEntries(dbName: string, storeName: string, limit?: number, openTimeoutMs?: number): Promise<NecIdbStoreEntries>;
+    /** Serializza una `IDBValidKey` (stringa/numero/Date/array) in stringa per la UI. */
+    private stringifyKey;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NecIndexedDbProbeService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NecIndexedDbProbeService>;
+}
+//# sourceMappingURL=nec-indexeddb-probe.service.d.ts.map

package/devtools/probes/nec-indexeddb-probe.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nec-indexeddb-probe.service.d.ts","sourceRoot":"","sources":["../../../../libs/ngrx-entity-crud/devtools/probes/nec-indexeddb-probe.service.ts"],"names":[],"mappings":"AACA,OAAO,EACL,aAAa,EAGb,YAAY,EACZ,kBAAkB,EAEnB,MAAM,WAAW,CAAC;;AAGnB;;;;;;;GAOG;AACH,qBACa,wBAAwB;IACc,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,aAAa,GAAG,IAAI;IAE/F;;;;OAIG;IACG,IAAI,CAAC,qBAAqB,GAAE,MAAM,EAAO,EAAE,aAAa,SAAO,GAAG,OAAO,CAAC,YAAY,CAAC;YA2C/E,iBAAiB;IAkB/B,OAAO,CAAC,eAAe;IAsGvB;;;;;;OAMG;IACG,gBAAgB,CACpB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,KAAK,SAAK,EACV,aAAa,SAAO,GACnB,OAAO,CAAC,kBAAkB,CAAC;IAqH9B,qFAAqF;IACrF,OAAO,CAAC,YAAY;yCA7ST,wBAAwB;6CAAxB,wBAAwB;CAuTpC"}

package/devtools/probes/nec-local-storage-probe.service.d.ts

@@ -0,0 +1,27 @@
+import { NecQuotaEstimate, NecStorageReport } from '../models';
+import * as i0 from "@angular/core";
+/**
+ * Riepilogo di `localStorage` / `sessionStorage`.
+ *
+ * Sincrono per la lettura delle chiavi. NON espone i valori: solo chiavi e dimensioni
+ * (privacy). La metrica primaria verso la quota è UTF-16 `(key.length + value.length) * 2`,
+ * perché è ciò che conta verso il limite ~5-10MB; la metrica UTF-8 è secondaria.
+ */
+export declare class NecLocalStorageProbeService {
+    read(type?: 'local' | 'session'): NecStorageReport;
+    /**
+     * Legge ON-DEMAND il valore grezzo di una singola chiave (per il reveal esplicito in UI).
+     * Non viene mai incluso nel report: la dashboard lo richiede solo su azione dell'utente e lo
+     * maschera tramite `maskValue`.
+     */
+    readValue(key: string, type?: 'local' | 'session'): string | null;
+    /**
+     * Stima quota AGGREGATA per-origine (include anche IndexedDB e Cache): NON è scorporabile
+     * per area. Può essere assente (Safari/contesto non sicuro) o arrotondata (anti-fingerprint).
+     */
+    estimate(): Promise<NecQuotaEstimate>;
+    private utf8Bytes;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NecLocalStorageProbeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NecLocalStorageProbeService>;
+}
+//# sourceMappingURL=nec-local-storage-probe.service.d.ts.map