inspector-ng 0.0.6 → 0.0.7

package/README.md

@@ -56,6 +56,46 @@ That's it. Press **`M`** in your browser to open the inspector toolbar. No furth
 
 ## Configuration
 
+### Developer checkpoints
+
+Checkpoints save the current Angular Router URL plus state you explicitly register. They do **not** record or replay HTTP requests.
+
+```ts
+import { ApplicationConfig } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import {
+  createBehaviorSubjectCheckpointAdapter,
+  InspectorCheckpointRegistry,
+  provideInspectorCheckpoints,
+} from 'inspector-ng';
+
+export const appConfig: ApplicationConfig = {
+  providers: [provideInspectorCheckpoints()],
+};
+```
+
+Register serializable state from an application service or component:
+
+```ts
+const application = new BehaviorSubject({ customerName: '', amount: 0 });
+const unregister = checkpointRegistry.register(
+  createBehaviorSubjectCheckpointAdapter('workflow:application', application),
+);
+```
+
+Open the inspector and use the checkpoint button to save, restore, rename, or delete snapshots. Checkpoints use `localStorage`; when the browser quota is reached, the oldest checkpoint is removed to make room. Do not register sensitive values.
+
+For Native Federation, the shell owns `provideInspectorCheckpoints()`. Remotes receive the shell's `InspectorCheckpointRegistry` and register namespaced adapters such as `workflow:application`. The shell should register a remote loader for each scope so remotes are loaded before state is restored:
+
+```ts
+checkpointRegistry.registerRemoteScope('workflow', async () => {
+  const remote = await loadRemoteModule('workflow', './CheckpointAdapters');
+  remote.registerInspectorCheckpointAdapters(checkpointRegistry);
+});
+```
+
+Repeated remote adapter registration is safe, so a bridge may run before every restore. Share `inspector-ng` as a Native Federation singleton in both shell and remotes.
+
 ### Inputs
 
 | Input | Type | Default | Description |

package/esm2022/lib/checkpoints.mjs

@@ -0,0 +1,267 @@
+import { Injectable, Inject, PLATFORM_ID, computed, signal } from '@angular/core';
+import { isPlatformBrowser } from '@angular/common';
+import { Router } from '@angular/router';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+const STORAGE_KEY = 'inspector-checkpoints-v1';
+export class InspectorCheckpointRegistry {
+    constructor(platformId, router) {
+        this.router = router;
+        this.checkpoints = signal([]);
+        this.isBusy = signal(false);
+        this.error = signal(null);
+        this.warning = signal(null);
+        this.totalBytes = computed(() => this.checkpoints().reduce((total, checkpoint) => total + checkpoint.sizeBytes, 0));
+        this.adapters = new Map();
+        this.remoteLoaders = new Map();
+        this.isCheckpoint = (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.url === 'string' &&
+                typeof checkpoint.createdAt === 'string' && Array.isArray(checkpoint.scopes) &&
+                !!checkpoint.state && typeof checkpoint.state === 'object' && typeof checkpoint.sizeBytes === 'number';
+        };
+        this.isBrowser = isPlatformBrowser(platformId);
+        this.hydrate();
+    }
+    register(adapter) {
+        if (!adapter.id.includes(':')) {
+            throw new Error('Checkpoint adapter IDs must be namespaced (for example, workflow:application).');
+        }
+        if (this.adapters.has(adapter.id)) {
+            // Remote bridge loaders can run more than once across checkpoint restores.
+            // Treat repeated registration as idempotent so a loaded remote stays usable.
+            return () => undefined;
+        }
+        this.adapters.set(adapter.id, adapter);
+        return () => this.adapters.delete(adapter.id);
+    }
+    registerRemoteScope(scope, loader) {
+        this.remoteLoaders.set(scope, loader);
+        return () => this.remoteLoaders.delete(scope);
+    }
+    async save(name) {
+        this.error.set(null);
+        if (!this.isBrowser) {
+            this.error.set('Checkpoints are only available in a browser.');
+            return null;
+        }
+        this.isBusy.set(true);
+        try {
+            const state = {};
+            for (const adapter of this.adapters.values()) {
+                state[adapter.id] = this.cloneValue(await adapter.capture(), adapter.id);
+            }
+            const createdAt = new Date().toISOString();
+            const checkpoint = {
+                version: 1,
+                id: this.createId(),
+                name: name?.trim() || this.nextAutomaticName(this.routePath(this.router.url)),
+                url: this.router.url,
+                createdAt,
+                scopes: this.getScopes(Object.keys(state)),
+                state,
+                sizeBytes: 0,
+            };
+            checkpoint.sizeBytes = this.sizeOf(checkpoint);
+            this.persistWithEviction([checkpoint, ...this.checkpoints()]);
+            return this.checkpoints().find((item) => item.id === checkpoint.id) ?? null;
+        }
+        catch (error) {
+            this.error.set(this.messageFor(error, 'Unable to save checkpoint.'));
+            return null;
+        }
+        finally {
+            this.isBusy.set(false);
+        }
+    }
+    async restore(id) {
+        const checkpoint = this.checkpoints().find((item) => item.id === id);
+        this.error.set(null);
+        this.warning.set(null);
+        if (!checkpoint) {
+            this.error.set('Checkpoint not found.');
+            return false;
+        }
+        this.isBusy.set(true);
+        try {
+            for (const scope of checkpoint.scopes) {
+                const loader = this.remoteLoaders.get(scope);
+                if (loader) {
+                    await loader();
+                }
+            }
+            const missing = [];
+            for (const [adapterId, value] of Object.entries(checkpoint.state)) {
+                const adapter = this.adapters.get(adapterId);
+                if (!adapter) {
+                    missing.push(adapterId);
+                    continue;
+                }
+                await adapter.restore(this.cloneValue(value, adapterId));
+            }
+            if (missing.length) {
+                this.warning.set(`Skipped ${missing.length} unavailable adapter${missing.length === 1 ? '' : 's'}: ${missing.join(', ')}.`);
+            }
+            await this.router.navigateByUrl(checkpoint.url);
+            return true;
+        }
+        catch (error) {
+            this.error.set(this.messageFor(error, 'Unable to restore checkpoint.'));
+            return false;
+        }
+        finally {
+            this.isBusy.set(false);
+        }
+    }
+    rename(id, name) {
+        const nextName = name.trim();
+        if (!nextName) {
+            this.error.set('A checkpoint name is required.');
+            return;
+        }
+        this.error.set(null);
+        const next = this.checkpoints().map((checkpoint) => checkpoint.id === id ? { ...checkpoint, name: nextName } : checkpoint);
+        this.persistWithEviction(next);
+    }
+    delete(id) {
+        this.error.set(null);
+        this.persistWithEviction(this.checkpoints().filter((checkpoint) => checkpoint.id !== id));
+    }
+    hydrate() {
+        if (!this.isBrowser) {
+            return;
+        }
+        try {
+            const raw = window.localStorage.getItem(STORAGE_KEY);
+            if (!raw)
+                return;
+            const parsed = JSON.parse(raw);
+            if (!Array.isArray(parsed))
+                return;
+            const checkpoints = parsed.filter(this.isCheckpoint);
+            const normalized = this.normalizeLegacyNames(checkpoints);
+            const sorted = normalized.checkpoints.sort((a, b) => b.createdAt.localeCompare(a.createdAt) || b.id.localeCompare(a.id));
+            this.checkpoints.set(sorted);
+            if (normalized.changed) {
+                window.localStorage.setItem(STORAGE_KEY, JSON.stringify(sorted));
+            }
+        }
+        catch {
+            this.warning.set('Saved checkpoints could not be read and were ignored.');
+        }
+    }
+    persistWithEviction(checkpoints) {
+        if (!this.isBrowser)
+            return;
+        let candidate = checkpoints;
+        while (true) {
+            try {
+                window.localStorage.setItem(STORAGE_KEY, JSON.stringify(candidate));
+                this.checkpoints.set(candidate);
+                return;
+            }
+            catch (error) {
+                if (!this.isQuotaError(error) || candidate.length === 0) {
+                    throw error;
+                }
+                candidate = candidate.slice(0, -1);
+                this.warning.set('Storage was full; the oldest checkpoint was removed.');
+            }
+        }
+    }
+    cloneValue(value, adapterId) {
+        try {
+            const serialized = JSON.stringify(value);
+            if (serialized === undefined)
+                throw new Error('undefined values are not supported');
+            return JSON.parse(serialized);
+        }
+        catch {
+            throw new Error(`Adapter "${adapterId}" returned a value that cannot be JSON serialized.`);
+        }
+    }
+    getScopes(adapterIds) {
+        return [...new Set(adapterIds.map((id) => id.split(':', 1)[0]))];
+    }
+    routePath(url) {
+        return url.split(/[?#]/, 1)[0] || '/';
+    }
+    nextAutomaticName(route, usedNames = new Set(this.checkpoints().map(({ name }) => name))) {
+        if (!usedNames.has(route))
+            return route;
+        for (let suffix = 2;; suffix += 1) {
+            const candidate = `${route} ${suffix}`;
+            if (!usedNames.has(candidate))
+                return candidate;
+        }
+    }
+    normalizeLegacyNames(checkpoints) {
+        const legacyIds = new Set(checkpoints.filter((checkpoint) => this.isLegacyAutomaticName(checkpoint)).map(({ id }) => id));
+        if (!legacyIds.size)
+            return { checkpoints, changed: false };
+        const usedNames = new Set(checkpoints.filter(({ id }) => !legacyIds.has(id)).map(({ name }) => name));
+        const names = new Map();
+        const oldestFirst = checkpoints
+            .filter(({ id }) => legacyIds.has(id))
+            .sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id));
+        for (const checkpoint of oldestFirst) {
+            const name = this.nextAutomaticName(this.routePath(checkpoint.url), usedNames);
+            names.set(checkpoint.id, name);
+            usedNames.add(name);
+        }
+        return {
+            checkpoints: checkpoints.map((checkpoint) => names.has(checkpoint.id) ? { ...checkpoint, name: names.get(checkpoint.id) } : checkpoint),
+            changed: true,
+        };
+    }
+    isLegacyAutomaticName(checkpoint) {
+        const route = this.routePath(checkpoint.url);
+        const prefix = `${route} · `;
+        if (!checkpoint.name.startsWith(prefix))
+            return false;
+        const timestamp = checkpoint.name.slice(prefix.length);
+        if (timestamp === new Date(checkpoint.createdAt).toLocaleString())
+            return true;
+        const parsedTimestamp = Date.parse(timestamp);
+        const createdTimestamp = Date.parse(checkpoint.createdAt);
+        return Number.isFinite(parsedTimestamp) && Number.isFinite(createdTimestamp) &&
+            Math.abs(parsedTimestamp - createdTimestamp) < 1000;
+    }
+    createId() {
+        return `checkpoint-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    }
+    sizeOf(checkpoint) {
+        return new Blob([JSON.stringify(checkpoint)]).size;
+    }
+    isQuotaError(error) {
+        return error instanceof DOMException && (error.name === 'QuotaExceededError' || error.name === 'NS_ERROR_DOM_QUOTA_REACHED');
+    }
+    messageFor(error, fallback) {
+        return error instanceof Error ? error.message : fallback;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: InspectorCheckpointRegistry, deps: [{ token: PLATFORM_ID }, { token: Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: InspectorCheckpointRegistry }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: InspectorCheckpointRegistry, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }, { type: i1.Router, decorators: [{
+                    type: Inject,
+                    args: [Router]
+                }] }] });
+export function provideInspectorCheckpoints() {
+    return [InspectorCheckpointRegistry];
+}
+export function createBehaviorSubjectCheckpointAdapter(id, subject) {
+    return {
+        id,
+        capture: () => subject.value,
+        restore: (value) => subject.next(value),
+    };
+}
+//# 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 { Injectable, Inject, PLATFORM_ID, Provider, computed, signal } from '@angular/core';\nimport { isPlatformBrowser } from '@angular/common';\nimport { Router } from '@angular/router';\nimport { BehaviorSubject } from 'rxjs';\n\nexport type InspectorCheckpointValue =\n  | string\n  | number\n  | boolean\n  | null\n  | InspectorCheckpointValue[]\n  | { [key: string]: InspectorCheckpointValue };\n\nexport interface InspectorCheckpointAdapter {\n  id: string;\n  capture(): InspectorCheckpointValue | Promise<InspectorCheckpointValue>;\n  restore(value: InspectorCheckpointValue): void | Promise<void>;\n}\n\nexport interface InspectorCheckpoint {\n  version: 1;\n  id: string;\n  name: string;\n  url: string;\n  createdAt: string;\n  scopes: string[];\n  state: Record<string, InspectorCheckpointValue>;\n  sizeBytes: number;\n}\n\nexport type InspectorCheckpointRemoteLoader = () => void | Promise<void>;\n\nconst STORAGE_KEY = 'inspector-checkpoints-v1';\n\n@Injectable()\nexport class InspectorCheckpointRegistry {\n  readonly checkpoints = signal<InspectorCheckpoint[]>([]);\n  readonly isBusy = signal(false);\n  readonly error = signal<string | null>(null);\n  readonly warning = signal<string | null>(null);\n  readonly totalBytes = computed(() =>\n    this.checkpoints().reduce((total, checkpoint) => total + checkpoint.sizeBytes, 0),\n  );\n\n  private readonly adapters = new Map<string, InspectorCheckpointAdapter>();\n  private readonly remoteLoaders = new Map<string, InspectorCheckpointRemoteLoader>();\n  private readonly isBrowser: boolean;\n\n  constructor(\n    @Inject(PLATFORM_ID) platformId: object,\n    @Inject(Router) private readonly router: Router,\n  ) {\n    this.isBrowser = isPlatformBrowser(platformId);\n    this.hydrate();\n  }\n\n  register(adapter: InspectorCheckpointAdapter): () => void {\n    if (!adapter.id.includes(':')) {\n      throw new Error('Checkpoint adapter IDs must be namespaced (for example, workflow:application).');\n    }\n    if (this.adapters.has(adapter.id)) {\n      // Remote bridge loaders can run more than once across checkpoint restores.\n      // Treat repeated registration as idempotent so a loaded remote stays usable.\n      return () => undefined;\n    }\n    this.adapters.set(adapter.id, adapter);\n    return () => this.adapters.delete(adapter.id);\n  }\n\n  registerRemoteScope(scope: string, loader: InspectorCheckpointRemoteLoader): () => void {\n    this.remoteLoaders.set(scope, loader);\n    return () => this.remoteLoaders.delete(scope);\n  }\n\n  async save(name?: string): Promise<InspectorCheckpoint | null> {\n    this.error.set(null);\n    if (!this.isBrowser) {\n      this.error.set('Checkpoints are only available in a browser.');\n      return null;\n    }\n\n    this.isBusy.set(true);\n    try {\n      const state: Record<string, InspectorCheckpointValue> = {};\n      for (const adapter of this.adapters.values()) {\n        state[adapter.id] = this.cloneValue(await adapter.capture(), adapter.id);\n      }\n      const createdAt = new Date().toISOString();\n      const checkpoint: InspectorCheckpoint = {\n        version: 1,\n        id: this.createId(),\n        name: name?.trim() || this.nextAutomaticName(this.routePath(this.router.url)),\n        url: this.router.url,\n        createdAt,\n        scopes: this.getScopes(Object.keys(state)),\n        state,\n        sizeBytes: 0,\n      };\n      checkpoint.sizeBytes = this.sizeOf(checkpoint);\n      this.persistWithEviction([checkpoint, ...this.checkpoints()]);\n      return this.checkpoints().find((item) => item.id === checkpoint.id) ?? null;\n    } catch (error) {\n      this.error.set(this.messageFor(error, 'Unable to save checkpoint.'));\n      return null;\n    } finally {\n      this.isBusy.set(false);\n    }\n  }\n\n  async restore(id: string): Promise<boolean> {\n    const checkpoint = this.checkpoints().find((item) => item.id === id);\n    this.error.set(null);\n    this.warning.set(null);\n    if (!checkpoint) {\n      this.error.set('Checkpoint not found.');\n      return false;\n    }\n\n    this.isBusy.set(true);\n    try {\n      for (const scope of checkpoint.scopes) {\n        const loader = this.remoteLoaders.get(scope);\n        if (loader) {\n          await loader();\n        }\n      }\n\n      const missing: string[] = [];\n      for (const [adapterId, value] of Object.entries(checkpoint.state)) {\n        const adapter = this.adapters.get(adapterId);\n        if (!adapter) {\n          missing.push(adapterId);\n          continue;\n        }\n        await adapter.restore(this.cloneValue(value, adapterId));\n      }\n      if (missing.length) {\n        this.warning.set(`Skipped ${missing.length} unavailable adapter${missing.length === 1 ? '' : 's'}: ${missing.join(', ')}.`);\n      }\n      await this.router.navigateByUrl(checkpoint.url);\n      return true;\n    } catch (error) {\n      this.error.set(this.messageFor(error, 'Unable to restore checkpoint.'));\n      return false;\n    } finally {\n      this.isBusy.set(false);\n    }\n  }\n\n  rename(id: string, name: string): void {\n    const nextName = name.trim();\n    if (!nextName) {\n      this.error.set('A checkpoint name is required.');\n      return;\n    }\n    this.error.set(null);\n    const next = this.checkpoints().map((checkpoint) =>\n      checkpoint.id === id ? { ...checkpoint, name: nextName } : checkpoint,\n    );\n    this.persistWithEviction(next);\n  }\n\n  delete(id: string): void {\n    this.error.set(null);\n    this.persistWithEviction(this.checkpoints().filter((checkpoint) => checkpoint.id !== id));\n  }\n\n  private hydrate(): void {\n    if (!this.isBrowser) {\n      return;\n    }\n    try {\n      const raw = window.localStorage.getItem(STORAGE_KEY);\n      if (!raw) return;\n      const parsed = JSON.parse(raw) as unknown;\n      if (!Array.isArray(parsed)) return;\n      const checkpoints = parsed.filter(this.isCheckpoint);\n      const normalized = this.normalizeLegacyNames(checkpoints);\n      const sorted = normalized.checkpoints.sort((a, b) =>\n        b.createdAt.localeCompare(a.createdAt) || b.id.localeCompare(a.id)\n      );\n      this.checkpoints.set(sorted);\n      if (normalized.changed) {\n        window.localStorage.setItem(STORAGE_KEY, JSON.stringify(sorted));\n      }\n    } catch {\n      this.warning.set('Saved checkpoints could not be read and were ignored.');\n    }\n  }\n\n  private persistWithEviction(checkpoints: InspectorCheckpoint[]): void {\n    if (!this.isBrowser) return;\n    let candidate = checkpoints;\n    while (true) {\n      try {\n        window.localStorage.setItem(STORAGE_KEY, JSON.stringify(candidate));\n        this.checkpoints.set(candidate);\n        return;\n      } catch (error) {\n        if (!this.isQuotaError(error) || candidate.length === 0) {\n          throw error;\n        }\n        candidate = candidate.slice(0, -1);\n        this.warning.set('Storage was full; the oldest checkpoint was removed.');\n      }\n    }\n  }\n\n  private cloneValue(value: unknown, adapterId: string): InspectorCheckpointValue {\n    try {\n      const serialized = JSON.stringify(value);\n      if (serialized === undefined) throw new Error('undefined values are not supported');\n      return JSON.parse(serialized) as InspectorCheckpointValue;\n    } catch {\n      throw new Error(`Adapter \"${adapterId}\" returned a value that cannot be JSON serialized.`);\n    }\n  }\n\n  private getScopes(adapterIds: string[]): string[] {\n    return [...new Set(adapterIds.map((id) => id.split(':', 1)[0]))];\n  }\n\n  private routePath(url: string): string {\n    return url.split(/[?#]/, 1)[0] || '/';\n  }\n\n  private nextAutomaticName(route: string, usedNames = new Set(this.checkpoints().map(({ name }) => name))): string {\n    if (!usedNames.has(route)) return route;\n    for (let suffix = 2; ; suffix += 1) {\n      const candidate = `${route} ${suffix}`;\n      if (!usedNames.has(candidate)) return candidate;\n    }\n  }\n\n  private normalizeLegacyNames(checkpoints: InspectorCheckpoint[]): {\n    checkpoints: InspectorCheckpoint[];\n    changed: boolean;\n  } {\n    const legacyIds = new Set(\n      checkpoints.filter((checkpoint) => this.isLegacyAutomaticName(checkpoint)).map(({ id }) => id),\n    );\n    if (!legacyIds.size) return { checkpoints, changed: false };\n\n    const usedNames = new Set(\n      checkpoints.filter(({ id }) => !legacyIds.has(id)).map(({ name }) => name),\n    );\n    const names = new Map<string, string>();\n    const oldestFirst = checkpoints\n      .filter(({ id }) => legacyIds.has(id))\n      .sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id));\n\n    for (const checkpoint of oldestFirst) {\n      const name = this.nextAutomaticName(this.routePath(checkpoint.url), usedNames);\n      names.set(checkpoint.id, name);\n      usedNames.add(name);\n    }\n\n    return {\n      checkpoints: checkpoints.map((checkpoint) =>\n        names.has(checkpoint.id) ? { ...checkpoint, name: names.get(checkpoint.id)! } : checkpoint\n      ),\n      changed: true,\n    };\n  }\n\n  private isLegacyAutomaticName(checkpoint: InspectorCheckpoint): boolean {\n    const route = this.routePath(checkpoint.url);\n    const prefix = `${route} · `;\n    if (!checkpoint.name.startsWith(prefix)) return false;\n    const timestamp = checkpoint.name.slice(prefix.length);\n    if (timestamp === new Date(checkpoint.createdAt).toLocaleString()) return true;\n\n    const parsedTimestamp = Date.parse(timestamp);\n    const createdTimestamp = Date.parse(checkpoint.createdAt);\n    return Number.isFinite(parsedTimestamp) && Number.isFinite(createdTimestamp) &&\n      Math.abs(parsedTimestamp - createdTimestamp) < 1000;\n  }\n\n  private createId(): string {\n    return `checkpoint-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;\n  }\n\n  private sizeOf(checkpoint: InspectorCheckpoint): number {\n    return new Blob([JSON.stringify(checkpoint)]).size;\n  }\n\n  private isQuotaError(error: unknown): boolean {\n    return error instanceof DOMException && (\n      error.name === 'QuotaExceededError' || error.name === 'NS_ERROR_DOM_QUOTA_REACHED'\n    );\n  }\n\n  private messageFor(error: unknown, fallback: string): string {\n    return error instanceof Error ? error.message : fallback;\n  }\n\n  private isCheckpoint = (value: unknown): value is InspectorCheckpoint => {\n    if (!value || typeof value !== 'object') return false;\n    const checkpoint = value as Partial<InspectorCheckpoint>;\n    return checkpoint.version === 1 && typeof checkpoint.id === 'string' &&\n      typeof checkpoint.name === 'string' && typeof checkpoint.url === 'string' &&\n      typeof checkpoint.createdAt === 'string' && Array.isArray(checkpoint.scopes) &&\n      !!checkpoint.state && typeof checkpoint.state === 'object' && typeof checkpoint.sizeBytes === 'number';\n  };\n}\n\nexport function provideInspectorCheckpoints(): Provider[] {\n  return [InspectorCheckpointRegistry];\n}\n\nexport function createBehaviorSubjectCheckpointAdapter<T>(\n  id: string,\n  subject: BehaviorSubject<T>,\n): InspectorCheckpointAdapter {\n  return {\n    id,\n    capture: () => subject.value as unknown as InspectorCheckpointValue,\n    restore: (value) => subject.next(value as T),\n  };\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