inspector-ng 0.0.6 → 0.0.9

package/README.md

@@ -11,9 +11,11 @@ Inspired by [ibelick](https://github.com/ibelick)'s original design.
 ## Installation
 
 ```bash
-npm install inspector-ng
+npm install inspector-ng@0.0.8 @ngrx/store@^17.2.0
 ```
 
+For a complete new-project walkthrough with copy-paste Store, Router, Redux DevTools, state, local-package, and troubleshooting examples, see the [setup guide](https://github.com/destx0/inspector/blob/main/SETUP_GUIDE.md).
+
 ## Getting Started
 
 ### Step 1: Import the component
@@ -56,6 +58,28 @@ That's it. Press **`M`** in your browser to open the inspector toolbar. No furth
 
 ## Configuration
 
+### Developer checkpoints
+
+Add `@ngrx/store` and provide a single root Store before `provideInspectorCheckpoints()`:
+
+```ts
+import { ApplicationConfig } from '@angular/core';
+import { provideRouter } from '@angular/router';
+import { provideStore } from '@ngrx/store';
+import { provideInspectorCheckpoints } from 'inspector-ng';
+import { routes } from './app.routes';
+
+export const appConfig: ApplicationConfig = {
+  providers: [provideRouter(routes), provideStore(), provideInspectorCheckpoints()],
+};
+```
+
+Use the compact toolbar button to save the current JSON-serializable NgRx root state immediately. Use `Ctrl/Cmd+Shift+P` to open the fuzzy checkpoint finder. `F2` renames the selected record and `Delete` opens inline confirmation.
+
+Records are stored per origin in IndexedDB database `inspector-ng`, object store `checkpoints`. This needs no browser permission prompt and does not map to a visible or fixed OS path. Nothing is evicted automatically. Existing `inspector-checkpoints-v1` localStorage records are deliberately ignored.
+
+A checkpoint contains the root Store value and current route. Restore dispatches `[Inspector Checkpoints] Restore`, then navigates through Angular Router to the saved route, so NgRx Store DevTools records the state change normally. It does not restore action history, component-local state, HTTP activity, or backend state. Native Redux DevTools Import/Export files remain separate and cannot be searched from the Inspector command bar.
+
 ### Inputs
 
 | Input | Type | Default | Description |
@@ -89,6 +113,7 @@ That's it. Press **`M`** in your browser to open the inspector toolbar. No furth
 | `Ctrl/Cmd + Z` | Undo last guide change |
 | `Ctrl/Cmd + Shift + Z` | Redo guide change |
 | `Backspace` / `Delete` | Delete the selected guide |
+| `Ctrl/Cmd + Shift + P` | Search and restore checkpoints when configured |
 
 ## Features
 
@@ -108,6 +133,8 @@ That's it. Press **`M`** in your browser to open the inspector toolbar. No furth
 |---|---|
 | `@angular/core` | `^17.3.0` |
 | `@angular/common` | `^17.3.0` |
+| `@angular/router` | `^17.3.0` |
+| `@ngrx/store` | `^17.2.0` (peer dependency used only for checkpoints) |
 
 Built as a standalone component with signal-based reactivity and `OnPush` change detection.
 

package/esm2022/lib/checkpoint-search.mjs

@@ -0,0 +1,50 @@
+export function fuzzyCheckpoints(checkpoints, query) {
+    const normalizedQuery = normalize(query.trim());
+    if (!normalizedQuery)
+        return [...checkpoints].sort(newestFirst);
+    return checkpoints
+        .map((checkpoint) => {
+        const score = fuzzyScore(checkpoint.name, normalizedQuery);
+        return score === null ? null : { checkpoint, score };
+    })
+        .filter((item) => item !== null)
+        .sort((a, b) => b.score - a.score || newestFirst(a.checkpoint, b.checkpoint))
+        .map(({ checkpoint }) => checkpoint);
+}
+export function fuzzyScore(value, normalizedQuery) {
+    const candidate = normalize(value);
+    if (candidate === normalizedQuery)
+        return 10_000;
+    if (candidate.startsWith(normalizedQuery))
+        return 8_000 - candidate.length;
+    const substringIndex = candidate.indexOf(normalizedQuery);
+    if (substringIndex >= 0)
+        return 6_000 - substringIndex * 10 - candidate.length;
+    let queryIndex = 0;
+    let firstIndex = -1;
+    let lastIndex = -1;
+    let gapPenalty = 0;
+    for (let index = 0; index < candidate.length && queryIndex < normalizedQuery.length; index += 1) {
+        if (candidate[index] !== normalizedQuery[queryIndex])
+            continue;
+        if (firstIndex < 0)
+            firstIndex = index;
+        if (lastIndex >= 0)
+            gapPenalty += index - lastIndex - 1;
+        lastIndex = index;
+        queryIndex += 1;
+    }
+    if (queryIndex !== normalizedQuery.length)
+        return null;
+    return 4_000 - firstIndex * 10 - gapPenalty * 20 - candidate.length;
+}
+function normalize(value) {
+    return value
+        .normalize('NFKD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLocaleLowerCase();
+}
+function newestFirst(a, b) {
+    return b.createdAt.localeCompare(a.createdAt) || b.id.localeCompare(a.id);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/checkpoints.mjs

@@ -0,0 +1,323 @@
+import { Inject, Injectable, InjectionToken, Optional, PLATFORM_ID, makeEnvironmentProviders, signal, } from '@angular/core';
+import { isPlatformBrowser } from '@angular/common';
+import { Router } from '@angular/router';
+import { META_REDUCERS, Store, } from '@ngrx/store';
+import { firstValueFrom, take } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@angular/router";
+const RESTORE_CHECKPOINT = '[Inspector Checkpoints] Restore';
+const DATABASE_NAME = 'inspector-ng';
+const DATABASE_VERSION = 1;
+const STORE_NAME = 'checkpoints';
+export const INSPECTOR_CHECKPOINT_REPOSITORY = new InjectionToken('INSPECTOR_CHECKPOINT_REPOSITORY');
+export function inspectorCheckpointMetaReducer(reducer) {
+    return (state, action) => {
+        if (action.type === RESTORE_CHECKPOINT) {
+            return action.state;
+        }
+        return reducer(state, action);
+    };
+}
+export class InspectorCheckpointRepository {
+}
+export class IndexedDbCheckpointRepository extends InspectorCheckpointRepository {
+    constructor(platformId) {
+        super();
+        this.platformId = platformId;
+        this.databasePromise = null;
+    }
+    async list() {
+        const database = await this.database();
+        const values = await this.request(database.transaction(STORE_NAME, 'readonly').objectStore(STORE_NAME).getAll());
+        return values
+            .filter(isCheckpointRecord)
+            .sort(newestFirst);
+    }
+    async put(checkpoint) {
+        const database = await this.database();
+        await this.transactionComplete(database, 'readwrite', (store) => store.put(checkpoint));
+    }
+    async delete(id) {
+        const database = await this.database();
+        await this.transactionComplete(database, 'readwrite', (store) => store.delete(id));
+    }
+    database() {
+        if (!isPlatformBrowser(this.platformId) || typeof indexedDB === 'undefined') {
+            return Promise.reject(new Error('Checkpoints are only available in a browser with IndexedDB.'));
+        }
+        if (this.databasePromise)
+            return this.databasePromise;
+        this.databasePromise = new Promise((resolve, reject) => {
+            const request = indexedDB.open(DATABASE_NAME, DATABASE_VERSION);
+            request.onupgradeneeded = () => {
+                const database = request.result;
+                if (database.objectStoreNames.contains(STORE_NAME))
+                    return;
+                const store = database.createObjectStore(STORE_NAME, { keyPath: 'id' });
+                store.createIndex('createdAt', 'createdAt');
+            };
+            request.onsuccess = () => resolve(request.result);
+            request.onerror = () => reject(request.error ?? new Error('IndexedDB could not be opened.'));
+            request.onblocked = () => reject(new Error('IndexedDB is blocked by another open tab.'));
+        });
+        return this.databasePromise;
+    }
+    request(request) {
+        return new Promise((resolve, reject) => {
+            request.onsuccess = () => resolve(request.result);
+            request.onerror = () => reject(request.error ?? new Error('IndexedDB request failed.'));
+        });
+    }
+    transactionComplete(database, mode, operation) {
+        return new Promise((resolve, reject) => {
+            const transaction = database.transaction(STORE_NAME, mode);
+            transaction.oncomplete = () => resolve();
+            transaction.onerror = () => reject(transaction.error ?? new Error('IndexedDB transaction failed.'));
+            transaction.onabort = () => reject(transaction.error ?? new Error('IndexedDB transaction was aborted.'));
+            operation(transaction.objectStore(STORE_NAME));
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IndexedDbCheckpointRepository, deps: [{ token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IndexedDbCheckpointRepository }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IndexedDbCheckpointRepository, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }] });
+export class InspectorCheckpointService {
+    constructor(repository, store, router, platformId) {
+        this.repository = repository;
+        this.store = store;
+        this.router = router;
+        this.platformId = platformId;
+        this.checkpoints = signal([]);
+        this.loading = signal(false);
+        this.busy = signal(false);
+        this.error = signal(null);
+    }
+    async load() {
+        this.error.set(null);
+        this.loading.set(true);
+        try {
+            this.checkpoints.set((await this.repository.list()).sort(newestFirst));
+        }
+        catch (error) {
+            this.error.set(this.messageFor(error, 'Saved checkpoints could not be loaded. Try reloading the page.'));
+        }
+        finally {
+            this.loading.set(false);
+        }
+    }
+    async save() {
+        this.error.set(null);
+        if (!this.store) {
+            this.error.set(this.missingStoreMessage());
+            return null;
+        }
+        this.busy.set(true);
+        try {
+            const currentState = await firstValueFrom(this.store.pipe(take(1)));
+            const state = cloneJson(currentState);
+            const persisted = await this.repository.list();
+            const route = this.currentRoute();
+            const pathname = this.currentPathname();
+            const checkpoint = {
+                version: 1,
+                id: createCheckpointId(),
+                name: nextAutomaticName(pathname, persisted.map(({ name }) => name)),
+                route,
+                createdAt: new Date().toISOString(),
+                state,
+            };
+            await this.repository.put(checkpoint);
+            this.checkpoints.set([checkpoint, ...persisted].sort(newestFirst));
+            return checkpoint;
+        }
+        catch (error) {
+            this.error.set(this.storageMessage(error, 'The checkpoint could not be saved.'));
+            return null;
+        }
+        finally {
+            this.busy.set(false);
+        }
+    }
+    async restore(id) {
+        this.error.set(null);
+        if (!this.store) {
+            this.error.set(this.missingStoreMessage());
+            return false;
+        }
+        this.busy.set(true);
+        try {
+            const checkpoint = (await this.repository.list()).find((item) => item.id === id);
+            if (!checkpoint)
+                throw new Error('Checkpoint not found. It may have been deleted in another tab.');
+            const state = cloneJson(checkpoint.state, `“${checkpoint.name}” could not be decoded. Delete it and save a new checkpoint.`);
+            this.store.dispatch({ type: RESTORE_CHECKPOINT, state });
+            if (this.router && !await this.router.navigateByUrl(checkpoint.route)) {
+                throw new Error(`The state was restored, but navigation to “${checkpoint.route}” was cancelled.`);
+            }
+            return true;
+        }
+        catch (error) {
+            this.error.set(this.messageFor(error, 'The checkpoint could not be restored. Delete it and save a new one.'));
+            return false;
+        }
+        finally {
+            this.busy.set(false);
+        }
+    }
+    async rename(id, name) {
+        this.error.set(null);
+        const nextName = name.trim();
+        if (!nextName) {
+            this.error.set('Please enter a checkpoint name.');
+            return false;
+        }
+        this.busy.set(true);
+        try {
+            const checkpoints = await this.repository.list();
+            if (checkpoints.some((item) => item.id !== id && item.name.toLocaleLowerCase() === nextName.toLocaleLowerCase())) {
+                throw new Error(`A checkpoint named “${nextName}” already exists. Choose a different name.`);
+            }
+            const checkpoint = checkpoints.find((item) => item.id === id);
+            if (!checkpoint)
+                throw new Error('Checkpoint not found. It may have been deleted in another tab.');
+            await this.repository.put({ ...checkpoint, name: nextName });
+            this.checkpoints.set(checkpoints.map((item) => item.id === id ? { ...item, name: nextName } : item).sort(newestFirst));
+            return true;
+        }
+        catch (error) {
+            this.error.set(this.storageMessage(error, 'The checkpoint could not be renamed.'));
+            return false;
+        }
+        finally {
+            this.busy.set(false);
+        }
+    }
+    async delete(id) {
+        this.error.set(null);
+        this.busy.set(true);
+        try {
+            await this.repository.delete(id);
+            this.checkpoints.set(this.checkpoints().filter((item) => item.id !== id));
+            return true;
+        }
+        catch (error) {
+            this.error.set(this.storageMessage(error, 'The checkpoint could not be deleted.'));
+            return false;
+        }
+        finally {
+            this.busy.set(false);
+        }
+    }
+    clearError() {
+        this.error.set(null);
+    }
+    currentRoute() {
+        if (!isPlatformBrowser(this.platformId))
+            return '/';
+        return `${this.currentPathname()}${window.location.search}${window.location.hash}`;
+    }
+    currentPathname() {
+        if (!isPlatformBrowser(this.platformId))
+            return '/';
+        return window.location.pathname || '/';
+    }
+    missingStoreMessage() {
+        return 'The NgRx root store is unavailable. Check that provideInspectorCheckpoints() is registered after provideStore().';
+    }
+    storageMessage(error, fallback) {
+        if (isQuotaError(error)) {
+            return 'Browser storage is full. Delete old checkpoints, then try saving again.';
+        }
+        return this.messageFor(error, fallback);
+    }
+    messageFor(error, fallback) {
+        return error instanceof Error && error.message ? error.message : fallback;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: InspectorCheckpointService, deps: [{ token: INSPECTOR_CHECKPOINT_REPOSITORY }, { token: Store, optional: true }, { token: Router, optional: true }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: InspectorCheckpointService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: InspectorCheckpointService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: InspectorCheckpointRepository, decorators: [{
+                    type: Inject,
+                    args: [INSPECTOR_CHECKPOINT_REPOSITORY]
+                }] }, { type: i1.Store, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [Store]
+                }] }, { type: i2.Router, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [Router]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }] });
+export function provideInspectorCheckpoints() {
+    return makeEnvironmentProviders([
+        IndexedDbCheckpointRepository,
+        {
+            provide: INSPECTOR_CHECKPOINT_REPOSITORY,
+            useExisting: IndexedDbCheckpointRepository,
+        },
+        InspectorCheckpointService,
+        {
+            provide: META_REDUCERS,
+            multi: true,
+            useValue: inspectorCheckpointMetaReducer,
+        },
+    ]);
+}
+export function nextAutomaticName(route, names) {
+    const used = new Set(names.map((name) => name.toLocaleLowerCase()));
+    if (!used.has(route.toLocaleLowerCase()))
+        return route;
+    for (let suffix = 2;; suffix += 1) {
+        const candidate = `${route} ${suffix}`;
+        if (!used.has(candidate.toLocaleLowerCase()))
+            return candidate;
+    }
+}
+function cloneJson(value, failureMessage = 'The NgRx root state is not JSON-serializable. Remove circular or unsupported values and try again.') {
+    try {
+        const serialized = JSON.stringify(value);
+        if (serialized === undefined)
+            throw new Error();
+        return JSON.parse(serialized);
+    }
+    catch {
+        throw new Error(failureMessage);
+    }
+}
+function createCheckpointId() {
+    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+        return crypto.randomUUID();
+    }
+    return `checkpoint-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+function isQuotaError(error) {
+    return error instanceof DOMException && (error.name === 'QuotaExceededError' || error.name === 'NS_ERROR_DOM_QUOTA_REACHED');
+}
+function newestFirst(a, b) {
+    return b.createdAt.localeCompare(a.createdAt) || b.id.localeCompare(a.id);
+}
+function isCheckpointRecord(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const checkpoint = value;
+    return checkpoint.version === 1 &&
+        typeof checkpoint.id === 'string' &&
+        typeof checkpoint.name === 'string' &&
+        typeof checkpoint.route === 'string' &&
+        typeof checkpoint.createdAt === 'string' &&
+        'state' in checkpoint;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"checkpoints.js","sourceRoot":"","sources":["../../../../projects/inspector-ng/src/lib/checkpoints.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  EnvironmentProviders,\n  Inject,\n  Injectable,\n  InjectionToken,\n  Optional,\n  PLATFORM_ID,\n  makeEnvironmentProviders,\n  signal,\n} from '@angular/core';\nimport { isPlatformBrowser } from '@angular/common';\nimport { Router } from '@angular/router';\nimport {\n  Action,\n  ActionReducer,\n  META_REDUCERS,\n  Store,\n} from '@ngrx/store';\nimport { firstValueFrom, take } from 'rxjs';\n\nexport interface InspectorCheckpointRecord {\n  version: 1;\n  id: string;\n  name: string;\n  route: string;\n  createdAt: string;\n  state: unknown;\n}\n\ninterface RestoreCheckpointAction extends Action {\n  type: typeof RESTORE_CHECKPOINT;\n  state: unknown;\n}\n\nconst RESTORE_CHECKPOINT = '[Inspector Checkpoints] Restore';\nconst DATABASE_NAME = 'inspector-ng';\nconst DATABASE_VERSION = 1;\nconst STORE_NAME = 'checkpoints';\n\nexport const INSPECTOR_CHECKPOINT_REPOSITORY =\n  new InjectionToken<InspectorCheckpointRepository>('INSPECTOR_CHECKPOINT_REPOSITORY');\n\nexport function inspectorCheckpointMetaReducer<T>(\n  reducer: ActionReducer<T>,\n): ActionReducer<T> {\n  return (state, action) => {\n    if (action.type === RESTORE_CHECKPOINT) {\n      return (action as RestoreCheckpointAction).state as T;\n    }\n    return reducer(state, action);\n  };\n}\n\nexport abstract class InspectorCheckpointRepository {\n  abstract list(): Promise<InspectorCheckpointRecord[]>;\n  abstract put(checkpoint: InspectorCheckpointRecord): Promise<void>;\n  abstract delete(id: string): Promise<void>;\n}\n\n@Injectable()\nexport class IndexedDbCheckpointRepository extends InspectorCheckpointRepository {\n  private databasePromise: Promise<IDBDatabase> | null = null;\n\n  constructor(@Inject(PLATFORM_ID) private readonly platformId: object) {\n    super();\n  }\n\n  async list(): Promise<InspectorCheckpointRecord[]> {\n    const database = await this.database();\n    const values = await this.request<unknown[]>(\n      database.transaction(STORE_NAME, 'readonly').objectStore(STORE_NAME).getAll(),\n    );\n    return values\n      .filter(isCheckpointRecord)\n      .sort(newestFirst);\n  }\n\n  async put(checkpoint: InspectorCheckpointRecord): Promise<void> {\n    const database = await this.database();\n    await this.transactionComplete(database, 'readwrite', (store) => store.put(checkpoint));\n  }\n\n  async delete(id: string): Promise<void> {\n    const database = await this.database();\n    await this.transactionComplete(database, 'readwrite', (store) => store.delete(id));\n  }\n\n  private database(): Promise<IDBDatabase> {\n    if (!isPlatformBrowser(this.platformId) || typeof indexedDB === 'undefined') {\n      return Promise.reject(new Error('Checkpoints are only available in a browser with IndexedDB.'));\n    }\n    if (this.databasePromise) return this.databasePromise;\n\n    this.databasePromise = new Promise<IDBDatabase>((resolve, reject) => {\n      const request = indexedDB.open(DATABASE_NAME, DATABASE_VERSION);\n      request.onupgradeneeded = () => {\n        const database = request.result;\n        if (database.objectStoreNames.contains(STORE_NAME)) return;\n        const store = database.createObjectStore(STORE_NAME, { keyPath: 'id' });\n        store.createIndex('createdAt', 'createdAt');\n      };\n      request.onsuccess = () => resolve(request.result);\n      request.onerror = () => reject(request.error ?? new Error('IndexedDB could not be opened.'));\n      request.onblocked = () => reject(new Error('IndexedDB is blocked by another open tab.'));\n    });\n    return this.databasePromise;\n  }\n\n  private request<T>(request: IDBRequest<T>): Promise<T> {\n    return new Promise<T>((resolve, reject) => {\n      request.onsuccess = () => resolve(request.result);\n      request.onerror = () => reject(request.error ?? new Error('IndexedDB request failed.'));\n    });\n  }\n\n  private transactionComplete(\n    database: IDBDatabase,\n    mode: IDBTransactionMode,\n    operation: (store: IDBObjectStore) => IDBRequest,\n  ): Promise<void> {\n    return new Promise<void>((resolve, reject) => {\n      const transaction = database.transaction(STORE_NAME, mode);\n      transaction.oncomplete = () => resolve();\n      transaction.onerror = () => reject(transaction.error ?? new Error('IndexedDB transaction failed.'));\n      transaction.onabort = () => reject(transaction.error ?? new Error('IndexedDB transaction was aborted.'));\n      operation(transaction.objectStore(STORE_NAME));\n    });\n  }\n}\n\n@Injectable()\nexport class InspectorCheckpointService {\n  readonly checkpoints = signal<InspectorCheckpointRecord[]>([]);\n  readonly loading = signal(false);\n  readonly busy = signal(false);\n  readonly error = signal<string | null>(null);\n\n  constructor(\n    @Inject(INSPECTOR_CHECKPOINT_REPOSITORY)\n    private readonly repository: InspectorCheckpointRepository,\n    @Optional() @Inject(Store) private readonly store: Store | null,\n    @Optional() @Inject(Router) private readonly router: Router | null,\n    @Inject(PLATFORM_ID) private readonly platformId: object,\n  ) {}\n\n  async load(): Promise<void> {\n    this.error.set(null);\n    this.loading.set(true);\n    try {\n      this.checkpoints.set((await this.repository.list()).sort(newestFirst));\n    } catch (error) {\n      this.error.set(this.messageFor(error, 'Saved checkpoints could not be loaded. Try reloading the page.'));\n    } finally {\n      this.loading.set(false);\n    }\n  }\n\n  async save(): Promise<InspectorCheckpointRecord | null> {\n    this.error.set(null);\n    if (!this.store) {\n      this.error.set(this.missingStoreMessage());\n      return null;\n    }\n\n    this.busy.set(true);\n    try {\n      const currentState = await firstValueFrom(this.store.pipe(take(1)));\n      const state = cloneJson(currentState);\n      const persisted = await this.repository.list();\n      const route = this.currentRoute();\n      const pathname = this.currentPathname();\n      const checkpoint: InspectorCheckpointRecord = {\n        version: 1,\n        id: createCheckpointId(),\n        name: nextAutomaticName(pathname, persisted.map(({ name }) => name)),\n        route,\n        createdAt: new Date().toISOString(),\n        state,\n      };\n      await this.repository.put(checkpoint);\n      this.checkpoints.set([checkpoint, ...persisted].sort(newestFirst));\n      return checkpoint;\n    } catch (error) {\n      this.error.set(this.storageMessage(error, 'The checkpoint could not be saved.'));\n      return null;\n    } finally {\n      this.busy.set(false);\n    }\n  }\n\n  async restore(id: string): Promise<boolean> {\n    this.error.set(null);\n    if (!this.store) {\n      this.error.set(this.missingStoreMessage());\n      return false;\n    }\n    this.busy.set(true);\n    try {\n      const checkpoint = (await this.repository.list()).find((item) => item.id === id);\n      if (!checkpoint) throw new Error('Checkpoint not found. It may have been deleted in another tab.');\n      const state = cloneJson(\n        checkpoint.state,\n        `“${checkpoint.name}” could not be decoded. Delete it and save a new checkpoint.`,\n      );\n      this.store.dispatch({ type: RESTORE_CHECKPOINT, state } as RestoreCheckpointAction);\n      if (this.router && !await this.router.navigateByUrl(checkpoint.route)) {\n        throw new Error(`The state was restored, but navigation to “${checkpoint.route}” was cancelled.`);\n      }\n      return true;\n    } catch (error) {\n      this.error.set(this.messageFor(error, 'The checkpoint could not be restored. Delete it and save a new one.'));\n      return false;\n    } finally {\n      this.busy.set(false);\n    }\n  }\n\n  async rename(id: string, name: string): Promise<boolean> {\n    this.error.set(null);\n    const nextName = name.trim();\n    if (!nextName) {\n      this.error.set('Please enter a checkpoint name.');\n      return false;\n    }\n\n    this.busy.set(true);\n    try {\n      const checkpoints = await this.repository.list();\n      if (checkpoints.some((item) => item.id !== id && item.name.toLocaleLowerCase() === nextName.toLocaleLowerCase())) {\n        throw new Error(`A checkpoint named “${nextName}” already exists. Choose a different name.`);\n      }\n      const checkpoint = checkpoints.find((item) => item.id === id);\n      if (!checkpoint) throw new Error('Checkpoint not found. It may have been deleted in another tab.');\n      await this.repository.put({ ...checkpoint, name: nextName });\n      this.checkpoints.set(\n        checkpoints.map((item) => item.id === id ? { ...item, name: nextName } : item).sort(newestFirst),\n      );\n      return true;\n    } catch (error) {\n      this.error.set(this.storageMessage(error, 'The checkpoint could not be renamed.'));\n      return false;\n    } finally {\n      this.busy.set(false);\n    }\n  }\n\n  async delete(id: string): Promise<boolean> {\n    this.error.set(null);\n    this.busy.set(true);\n    try {\n      await this.repository.delete(id);\n      this.checkpoints.set(this.checkpoints().filter((item) => item.id !== id));\n      return true;\n    } catch (error) {\n      this.error.set(this.storageMessage(error, 'The checkpoint could not be deleted.'));\n      return false;\n    } finally {\n      this.busy.set(false);\n    }\n  }\n\n  clearError(): void {\n    this.error.set(null);\n  }\n\n  private currentRoute(): string {\n    if (!isPlatformBrowser(this.platformId)) return '/';\n    return `${this.currentPathname()}${window.location.search}${window.location.hash}`;\n  }\n\n  private currentPathname(): string {\n    if (!isPlatformBrowser(this.platformId)) return '/';\n    return window.location.pathname || '/';\n  }\n\n  private missingStoreMessage(): string {\n    return 'The NgRx root store is unavailable. Check that provideInspectorCheckpoints() is registered after provideStore().';\n  }\n\n  private storageMessage(error: unknown, fallback: string): string {\n    if (isQuotaError(error)) {\n      return 'Browser storage is full. Delete old checkpoints, then try saving again.';\n    }\n    return this.messageFor(error, fallback);\n  }\n\n  private messageFor(error: unknown, fallback: string): string {\n    return error instanceof Error && error.message ? error.message : fallback;\n  }\n}\n\nexport function provideInspectorCheckpoints(): EnvironmentProviders {\n  return makeEnvironmentProviders([\n    IndexedDbCheckpointRepository,\n    {\n      provide: INSPECTOR_CHECKPOINT_REPOSITORY,\n      useExisting: IndexedDbCheckpointRepository,\n    },\n    InspectorCheckpointService,\n    {\n      provide: META_REDUCERS,\n      multi: true,\n      useValue: inspectorCheckpointMetaReducer,\n    },\n  ]);\n}\n\nexport function nextAutomaticName(route: string, names: string[]): string {\n  const used = new Set(names.map((name) => name.toLocaleLowerCase()));\n  if (!used.has(route.toLocaleLowerCase())) return route;\n  for (let suffix = 2; ; suffix += 1) {\n    const candidate = `${route} ${suffix}`;\n    if (!used.has(candidate.toLocaleLowerCase())) return candidate;\n  }\n}\n\nfunction cloneJson(\n  value: unknown,\n  failureMessage = 'The NgRx root state is not JSON-serializable. Remove circular or unsupported values and try again.',\n): unknown {\n  try {\n    const serialized = JSON.stringify(value);\n    if (serialized === undefined) throw new Error();\n    return JSON.parse(serialized) as unknown;\n  } catch {\n    throw new Error(failureMessage);\n  }\n}\n\nfunction createCheckpointId(): string {\n  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {\n    return crypto.randomUUID();\n  }\n  return `checkpoint-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;\n}\n\nfunction isQuotaError(error: unknown): boolean {\n  return error instanceof DOMException && (\n    error.name === 'QuotaExceededError' || error.name === 'NS_ERROR_DOM_QUOTA_REACHED'\n  );\n}\n\nfunction newestFirst(a: InspectorCheckpointRecord, b: InspectorCheckpointRecord): number {\n  return b.createdAt.localeCompare(a.createdAt) || b.id.localeCompare(a.id);\n}\n\nfunction isCheckpointRecord(value: unknown): value is InspectorCheckpointRecord {\n  if (!value || typeof value !== 'object') return false;\n  const checkpoint = value as Partial<InspectorCheckpointRecord>;\n  return checkpoint.version === 1 &&\n    typeof checkpoint.id === 'string' &&\n    typeof checkpoint.name === 'string' &&\n    typeof checkpoint.route === 'string' &&\n    typeof checkpoint.createdAt === 'string' &&\n    'state' in checkpoint;\n}\n"]}

package/esm2022/lib/constants.mjs

@@ -1,5 +1,5 @@
 export const inspector_STORAGE_KEY = "inspector-state";
-export const inspector_STATE_VERSION = 1;
+export const inspector_STATE_VERSION = 2;
 export const GUIDE_SNAP_DISTANCE = 10;
 export const GUIDE_HITBOX_SIZE = 14;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvaW5zcGVjdG9yLW5nL3NyYy9saWIvY29uc3RhbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxNQUFNLHFCQUFxQixHQUFHLGlCQUFpQixDQUFDO0FBQ3ZELE1BQU0sQ0FBQyxNQUFNLHVCQUF1QixHQUFHLENBQUMsQ0FBQztBQUN6QyxNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRyxFQUFFLENBQUM7QUFDdEMsTUFBTSxDQUFDLE1BQU0saUJBQWlCLEdBQUcsRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IGluc3BlY3Rvcl9TVE9SQUdFX0tFWSA9IFwiaW5zcGVjdG9yLXN0YXRlXCI7XG5leHBvcnQgY29uc3QgaW5zcGVjdG9yX1NUQVRFX1ZFUlNJT04gPSAxO1xuZXhwb3J0IGNvbnN0IEdVSURFX1NOQVBfRElTVEFOQ0UgPSAxMDtcbmV4cG9ydCBjb25zdCBHVUlERV9ISVRCT1hfU0laRSA9IDE0O1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvaW5zcGVjdG9yLW5nL3NyYy9saWIvY29uc3RhbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxNQUFNLHFCQUFxQixHQUFHLGlCQUFpQixDQUFDO0FBQ3ZELE1BQU0sQ0FBQyxNQUFNLHVCQUF1QixHQUFHLENBQUMsQ0FBQztBQUN6QyxNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRyxFQUFFLENBQUM7QUFDdEMsTUFBTSxDQUFDLE1BQU0saUJBQWlCLEdBQUcsRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IGluc3BlY3Rvcl9TVE9SQUdFX0tFWSA9IFwiaW5zcGVjdG9yLXN0YXRlXCI7XG5leHBvcnQgY29uc3QgaW5zcGVjdG9yX1NUQVRFX1ZFUlNJT04gPSAyO1xuZXhwb3J0IGNvbnN0IEdVSURFX1NOQVBfRElTVEFOQ0UgPSAxMDtcbmV4cG9ydCBjb25zdCBHVUlERV9ISVRCT1hfU0laRSA9IDE0O1xuIl19