npm - @braidlabs/angular-router - Versions diffs - 0.1.1 - Mend

@braidlabs/angular-router 0.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/README.md +112 -0
package/fesm2022/braidlabs-angular-router.mjs +490 -0
package/fesm2022/braidlabs-angular-router.mjs.map +1 -0
package/package.json +39 -0
package/types/braidlabs-angular-router.d.ts +334 -0

package/README.md ADDED Viewed

@@ -0,0 +1,112 @@
+# `@braidlabs/angular-router`
+Chunk recovery for Angular applications.
+When a lazy chunk fails to load, it can mean a flaky network, a CDN edge miss, an offline device, a deleted route, or an origin serving a stale entry document. This library provides a recovery primitive that correctly classifies the failure and takes the right action without bricking the user's tab.
+## Quick Start
+Enable skew recovery in your application config:
+```ts
+import { provideSkewRecovery } from '@braidlabs/angular-router';
+// Generate BUILD_IDENTITY with @braidlabs/build
+import { BUILD_IDENTITY } from './generated/build-id';
+bootstrapApplication(App, {
+  providers: [
+    provideRouter(routes),
+    provideSkewRecovery({
+      identity: BUILD_IDENTITY,
+      manifestUrl: '/skew-manifest.json', // Allows detection of stale origins vs deleted routes
+    }),
+  ],
+});
+```
+Then, wrap your lazy imports with `lazy()`:
+```ts
+import { lazy } from '@braidlabs/angular-router';
+export const routes: Routes = [
+  {
+    path: 'admin',
+    // The id 'admin.routes' is used to cross-reference the manifest
+    loadChildren: lazy('admin.routes', () => import('./admin/routes'))
+  }
+];
+```
+## How It Works
+### 1. Pre-Classification Retry
+A transient network failure shouldn't cause a page reload. `lazy()` will automatically retry the dynamic import (default: 1 retry, 250ms backoff) before surfacing a `ChunkLoadFailure` to the router. This resolves CDN misses without the user ever noticing.
+### 2. Recovery Strategies
+If retries are exhausted, the failure is caught by the recovery service, which classifies it and executes the configured strategy (`onStaleChunk`):
+| Strategy | Behaviour |
+|---|---|
+| `'reload-at-target'` *(default)* | `location.assign(targetUrl)` — Hard navigates to the intended destination. This is crucial because Angular's default `deferred` URL update strategy leaves the address bar on the *previous* route upon failure. A plain `location.reload()` would discard the navigation intent. |
+| `'reload-in-place'` | `location.reload()` — Refreshes the current route, abandoning the navigation. |
+| `'redirect-to-fallback'` | Client-side redirect (default `/`); correct when a route was deleted in a new deployment. |
+| `'notify'` | Exposes the failure via the `SkewRecoveryService` signal to let the app handle it manually. |
+| `'ignore'` | Leaves the `NavigationError` to propagate untouched. |
+| `(ctx) => Action` | Custom application policy based on the `StaleChunkContext`. |
+### 3. Loop Prevention
+If the origin is serving a stale entry document (older than your current running client), reloading will fetch the exact same stale bundles and fail again, creating an infinite loop that bricks the tab.
+`@braidlabs/angular-router` prevents this by:
+1. Probing the `manifestUrl` to determine the origin's build timestamp.
+2. Refusing to automatically reload if the origin is older than the client.
+3. Keeping a hard limit on automatic recoveries per session (`maxRecoveries`, default 1).
+## Unsaved Work Protection
+Angular does not provide a way for libraries to introspect `CanDeactivate` guards. If an automatic reload happens while a user is midway through a form, data is lost.
+To prevent this, components can register unsaved work:
+```ts
+import { trackUnsavedWork } from '@braidlabs/angular-router';
+@Component({ ... })
+export class BulletinEditor {
+  form = new FormGroup({ ... });
+  constructor() {
+    // Automatically cleans up when the component is destroyed
+    trackUnsavedWork(() => this.form.dirty);
+  }
+}
+```
+If `respectUnsavedWork` is true (default), any pending skew recovery will downgrade its strategy to `'notify'` instead of automatically reloading the page.
+## Manual Recovery UI
+If a recovery degrades to `'notify'` (e.g. because of unsaved work or a loop detection), you can prompt the user to manually recover:
+```ts
+import { Component, inject } from '@angular/core';
+import { SkewRecoveryService } from '@braidlabs/angular-router';
+@Component({
+  template: `
+    @if (recovery.pending()) {
+      <div class="banner">
+        A new version is available.
+        <button (click)="recovery.recover()">Reload App</button>
+      </div>
+    }
+  `
+})
+export class AppLayout {
+  recovery = inject(SkewRecoveryService);
+}
+```

package/fesm2022/braidlabs-angular-router.mjs ADDED Viewed

@@ -0,0 +1,490 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, signal, Injectable, inject, DestroyRef, DOCUMENT, PLATFORM_ID, computed, makeEnvironmentProviders, provideEnvironmentInitializer } from '@angular/core';
+import { isSkewDisabled, createVersionProbe, moduleWasRemoved, setSkewDisabled } from '@braidlabs/skew';
+import { isPlatformBrowser } from '@angular/common';
+import { Router, NavigationError } from '@angular/router';
+const SKEW_RECOVERY_OPTIONS = new InjectionToken('SKEW_RECOVERY_OPTIONS');
+function resolveOptions(options) {
+    return {
+        ...options,
+        onStaleChunk: options.onStaleChunk ?? 'reload-at-target',
+        retryAttempts: options.retryAttempts ?? 1,
+        retryDelayMs: options.retryDelayMs ?? 250,
+        maxRecoveries: options.maxRecoveries ?? 1,
+        fallbackRoute: options.fallbackRoute ?? '/',
+        respectUnsavedWork: options.respectUnsavedWork ?? true,
+    };
+}
+/**
+ * Wrapping the dynamic import.
+ *
+ * Two problems are solved here, both before any Angular machinery is involved:
+ *
+ * 1. **Attribution.** By the time an import rejects, the runtime holds
+ *    `chunk-ABC123.js` — not `./admin/routes`. Without a logical id there is no
+ *    way to ask the new build's manifest whether that route still exists.
+ * 2. **Transience.** A flaky network, a CDN edge miss, and a genuinely purged
+ *    asset are indistinguishable from the error alone. A bounded retry resolves
+ *    the first two without inflicting a page reload on anyone.
+ *
+ * Retry is therefore a *precondition* to recovery, not one of the strategies.
+ */
+/** Defaults for `lazy()`, overridable globally by `provideSkewRecovery()`. */
+const lazyDefaults = {
+    retryAttempts: 1,
+    retryDelayMs: 250,
+};
+/** Restores defaults. Exposed for tests, which must not leak configuration. */
+function resetLazyDefaults() {
+    lazyDefaults.retryAttempts = 1;
+    lazyDefaults.retryDelayMs = 250;
+}
+/**
+ * Thrown when a lazy load fails after its retries are exhausted.
+ *
+ * Angular surfaces this through `NavigationError`, where the recovery service
+ * recognises it. Carrying the module id across that boundary is the whole
+ * reason this error type exists.
+ */
+class ChunkLoadFailure extends Error {
+    moduleId;
+    cause;
+    attempts;
+    name = 'ChunkLoadFailure';
+    constructor(moduleId, cause, attempts) {
+        super(`[skew] failed to load ${moduleId ? `"${moduleId}"` : 'a lazy chunk'} ` +
+            `after ${attempts} attempt${attempts === 1 ? '' : 's'}`);
+        this.moduleId = moduleId;
+        this.cause = cause;
+        this.attempts = attempts;
+    }
+}
+function isChunkLoadFailure(value) {
+    return value instanceof ChunkLoadFailure;
+}
+/**
+ * Heuristic for "this looks like a module that failed to load" rather than an
+ * error thrown *by* the module once it ran.
+ *
+ * Deliberately broad: bundlers and browsers disagree on the shape here
+ * (`ChunkLoadError`, a bare `TypeError`, a CSP violation), and a false positive
+ * costs one wasted retry while a false negative costs the user their session.
+ */
+function looksLikeChunkError(error) {
+    if (!error)
+        return false;
+    const name = error.name ?? '';
+    const message = error.message ?? '';
+    return (name === 'ChunkLoadError' ||
+        /loading (chunk|css chunk)/i.test(message) ||
+        /failed to fetch dynamically imported module/i.test(message) ||
+        /error loading dynamically imported module/i.test(message) ||
+        /importing a module script failed/i.test(message));
+}
+function lazy(moduleIdOrLoader, loaderOrOptions, maybeOptions) {
+    const hasId = typeof moduleIdOrLoader === 'string';
+    const moduleId = hasId ? moduleIdOrLoader : undefined;
+    const loader = (hasId ? loaderOrOptions : moduleIdOrLoader);
+    const options = (hasId ? maybeOptions : loaderOrOptions) ?? {};
+    if (typeof loader !== 'function') {
+        throw new TypeError('[skew] lazy() requires a loader function');
+    }
+    return async () => {
+        // Not public API — see `disabled.ts` in @braidlabs/skew. A bare dynamic import
+        // with no retry and no attribution: the rejection propagates exactly as the
+        // bundler produced it, and nothing downstream knows which module it was.
+        if (isSkewDisabled())
+            return loader();
+        const attempts = Math.max(0, options.retryAttempts ?? lazyDefaults.retryAttempts) + 1;
+        const delay = options.retryDelayMs ?? lazyDefaults.retryDelayMs;
+        let lastError;
+        for (let attempt = 1; attempt <= attempts; attempt++) {
+            try {
+                return await loader();
+            }
+            catch (error) {
+                lastError = error;
+                // An error thrown by module *evaluation* is a bug in the module, not a
+                // transport failure. Retrying it just runs the bug again.
+                if (!looksLikeChunkError(error))
+                    throw error;
+                if (attempt < attempts && delay > 0) {
+                    await new Promise((resolve) => setTimeout(resolve, delay * attempt));
+                }
+            }
+        }
+        throw new ChunkLoadFailure(moduleId, lastError, attempts);
+    };
+}
+/**
+ * Unsaved-work tracking.
+ *
+ * A hard reload destroys in-memory state, so recovery must know whether that
+ * matters. Angular already has a declaration for exactly this — `CanDeactivate`
+ * — but the router exposes no way to ask "would a guard block here?", so a
+ * library cannot reuse it.
+ *
+ * This registry is the workaround: components declare dirtiness explicitly and
+ * the recovery service consults it. If Angular ever exposes guard
+ * introspection, this whole file becomes deletable.
+ */
+class UnsavedWorkRegistry {
+    sources = signal([], /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "sources" }] : /* istanbul ignore next */ []));
+    /** Registers a predicate. Returns a disposer. */
+    register(isDirty) {
+        this.sources.update((current) => [...current, isDirty]);
+        return () => {
+            this.sources.update((current) => current.filter((entry) => entry !== isDirty));
+        };
+    }
+    /**
+     * True when any registered source reports unsaved work.
+     *
+     * A throwing predicate is treated as *clean* rather than dirty: a broken
+     * dirty-check should not permanently block recovery and strand the user.
+     */
+    isDirty() {
+        return this.sources().some((isDirty) => {
+            try {
+                return isDirty();
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    /** Count of registered sources. Diagnostics only. */
+    get size() {
+        return this.sources().length;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: UnsavedWorkRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: UnsavedWorkRegistry, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: UnsavedWorkRegistry, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+/**
+ * Declares that this component holds unsaved work, so automatic recovery will
+ * not discard it. Unregisters automatically on destroy.
+ *
+ * ```ts
+ * export class BulletinEditor {
+ *   protected readonly form = …;
+ *   constructor() {
+ *     trackUnsavedWork(() => this.form.dirty);
+ *   }
+ * }
+ * ```
+ *
+ * Must be called in an injection context.
+ */
+function trackUnsavedWork(isDirty) {
+    const registry = inject(UnsavedWorkRegistry);
+    const destroyRef = inject(DestroyRef);
+    const dispose = registry.register(isDirty);
+    destroyRef.onDestroy(dispose);
+}
+const LOOP_GUARD_KEY = 'skew:recoveries';
+/**
+ * Orchestrates recovery from a failed lazy load.
+ *
+ * Wiring is via router events rather than a global registry: `lazy()` throws a
+ * {@link ChunkLoadFailure}, Angular surfaces it as `NavigationError`, and this
+ * service recognises it there. That keeps `lazy()` dependency-free and usable
+ * in route definitions, which are evaluated long before DI exists.
+ *
+ * Zoneless-safe and SSR-safe: no `NgZone`, and every `location` /
+ * `sessionStorage` touch is guarded.
+ */
+class SkewRecoveryService {
+    options = inject(SKEW_RECOVERY_OPTIONS);
+    router = inject(Router);
+    document = inject(DOCUMENT);
+    unsavedWork = inject(UnsavedWorkRegistry);
+    isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
+    probe;
+    pendingSignal = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "pendingSignal" }] : /* istanbul ignore next */ []));
+    statusSignal = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "statusSignal" }] : /* istanbul ignore next */ []));
+    /** A recovery the application has been asked to complete itself. */
+    pending = this.pendingSignal.asReadonly();
+    /** Last known comparison against the origin. */
+    status = this.statusSignal.asReadonly();
+    /** True when a newer deployment is known to exist. */
+    updateAvailable = computed(() => this.statusSignal()?.kind === 'staleClient', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "updateAvailable" }] : /* istanbul ignore next */ []));
+    constructor() {
+        this.probe = this.options.manifestUrl
+            ? createVersionProbe({
+                identity: this.options.identity,
+                manifestUrl: this.options.manifestUrl,
+            })
+            : null;
+        if (this.isBrowser)
+            this.listen();
+    }
+    listen() {
+        this.router.events.subscribe((event) => {
+            if (event instanceof NavigationError && isChunkLoadFailure(event.error)) {
+                // Not public API — see `disabled.ts` in @braidlabs/skew. The NavigationError
+                // is left to propagate untouched: no retry, no manifest probe, no
+                // classification, no decision. Whatever the application does next is
+                // whatever it would have done without this package installed.
+                if (isSkewDisabled())
+                    return;
+                void this.handle(event.error, event.url);
+            }
+        });
+    }
+    /** Re-checks the origin. Safe to call from a "check for updates" control. */
+    async check() {
+        if (!this.probe)
+            return null;
+        const status = await this.probe.check();
+        this.statusSignal.set(status);
+        return status;
+    }
+    /** Completes a deferred recovery — what a "Reload" button calls. */
+    recover() {
+        const pending = this.pendingSignal();
+        if (!pending)
+            return;
+        this.pendingSignal.set(null);
+        this.assign(pending.targetUrl);
+    }
+    /** Dismisses a pending recovery without acting on it. */
+    dismiss() {
+        this.pendingSignal.set(null);
+    }
+    async handle(failure, targetUrl) {
+        const context = await this.classify(failure, targetUrl);
+        const action = await this.chooseAction(context);
+        this.dispatch(action, context);
+    }
+    async classify(failure, targetUrl) {
+        const status = await this.check();
+        const serverBuildId = status?.kind === 'current'
+            ? status.buildId
+            : status && 'remote' in status
+                ? status.remote
+                : undefined;
+        // Absent a module map we must assume the route still exists. Claiming it
+        // was deleted would redirect users away from a route that merely moved —
+        // a worse failure than the one being recovered from.
+        const manifest = this.probe?.lastManifest() ?? null;
+        const moduleStillExists = failure.moduleId === undefined ||
+            manifest === null ||
+            !moduleWasRemoved(manifest, failure.moduleId);
+        return {
+            targetUrl,
+            currentUrl: this.router.url,
+            moduleId: failure.moduleId,
+            error: failure,
+            attempt: this.recoveryCount(),
+            isOnline: this.isOnline(),
+            clientBuildId: this.options.identity.buildId,
+            serverBuildId,
+            moduleStillExists,
+            entryDocumentStale: status?.kind === 'staleOrigin',
+            newAssetsReachable: status?.kind === 'staleClient',
+            hasUnsavedWork: this.options.respectUnsavedWork && this.unsavedWork.isDirty(),
+        };
+    }
+    async chooseAction(context) {
+        // Guard rails run before any application policy, because each of these is a
+        // case where reloading is actively harmful rather than merely unhelpful.
+        if (!context.isOnline)
+            return 'notify';
+        if (context.entryDocumentStale)
+            return 'notify'; // reloading would loop
+        if (context.attempt >= this.options.maxRecoveries)
+            return 'notify';
+        if (context.hasUnsavedWork)
+            return 'notify';
+        if (!context.moduleStillExists)
+            return 'redirect-to-fallback';
+        const strategy = this.options.onStaleChunk;
+        if (typeof strategy === 'function') {
+            try {
+                return await strategy(context);
+            }
+            catch {
+                // A throwing policy must not strand the user with nothing.
+                return 'notify';
+            }
+        }
+        return strategy;
+    }
+    dispatch(action, context) {
+        switch (action) {
+            case 'reload-at-target':
+                this.countRecovery();
+                this.assign(context.targetUrl);
+                return;
+            case 'reload-in-place':
+                this.countRecovery();
+                this.reload();
+                return;
+            case 'redirect-to-fallback':
+                void this.router.navigateByUrl(this.options.fallbackRoute);
+                return;
+            case 'ignore':
+                return;
+            case 'notify':
+                this.pendingSignal.set({
+                    targetUrl: context.targetUrl,
+                    moduleId: context.moduleId,
+                    serverBuildId: context.serverBuildId,
+                    reason: !context.isOnline
+                        ? 'offline'
+                        : context.entryDocumentStale
+                            ? 'loop-detected'
+                            : context.attempt >= this.options.maxRecoveries
+                                ? 'exhausted'
+                                : 'notify',
+                    context,
+                });
+                return;
+        }
+    }
+    // --- environment access, all browser-guarded ---------------------------
+    isOnline() {
+        if (!this.isBrowser)
+            return true;
+        const nav = this.document.defaultView?.navigator;
+        return nav?.onLine ?? true;
+    }
+    assign(url) {
+        if (!this.isBrowser)
+            return;
+        this.document.defaultView?.location.assign(url);
+    }
+    reload() {
+        if (!this.isBrowser)
+            return;
+        this.document.defaultView?.location.reload();
+    }
+    /**
+     * Recoveries already attempted, kept in `sessionStorage` so it survives the
+     * very reload it is counting. Without this, an origin serving a stale entry
+     * document turns one failure into an infinite reload loop.
+     */
+    recoveryCount() {
+        if (!this.isBrowser)
+            return 0;
+        try {
+            const raw = this.document.defaultView?.sessionStorage.getItem(LOOP_GUARD_KEY);
+            const parsed = raw ? JSON.parse(raw) : null;
+            // Scoped to a build: a genuinely new deployment gets a fresh budget.
+            return parsed?.buildId === this.options.identity.buildId ? (parsed.count ?? 0) : 0;
+        }
+        catch {
+            return 0;
+        }
+    }
+    countRecovery() {
+        if (!this.isBrowser)
+            return;
+        try {
+            this.document.defaultView?.sessionStorage.setItem(LOOP_GUARD_KEY, JSON.stringify({ buildId: this.options.identity.buildId, count: this.recoveryCount() + 1 }));
+        }
+        catch {
+            // Private mode. The manifest probe remains as the precise loop guard.
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: SkewRecoveryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: SkewRecoveryService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: SkewRecoveryService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+/**
+ * Enables skew recovery.
+ *
+ * ```ts
+ * bootstrapApplication(App, {
+ *   providers: [
+ *     provideRouter(routes),
+ *     provideSkewRecovery({
+ *       identity: BUILD_IDENTITY,          // from @braidlabs/build
+ *       manifestUrl: '/skew-manifest.json',
+ *     }),
+ *   ],
+ * });
+ * ```
+ *
+ * Deliberately *not* a `RouterFeature`: Angular's feature factory is internal,
+ * so third parties cannot construct one. This composes alongside
+ * `provideRouter` instead, and works with any router configuration.
+ *
+ * The service is instantiated eagerly — it subscribes to router events, and a
+ * lazily-created recovery service would miss the very first failure.
+ */
+function provideSkewRecovery(options) {
+    const resolved = resolveOptions(options);
+    return makeEnvironmentProviders([
+        { provide: SKEW_RECOVERY_OPTIONS, useValue: resolved },
+        provideEnvironmentInitializer(() => {
+            // Route definitions are evaluated before DI exists, so `lazy()` cannot
+            // inject its retry policy. Publishing the resolved values here keeps a
+            // single source of configuration without making `lazy()` DI-aware.
+            lazyDefaults.retryAttempts = resolved.retryAttempts;
+            lazyDefaults.retryDelayMs = resolved.retryDelayMs;
+            inject(SkewRecoveryService);
+        }),
+    ]);
+}
+/**
+ * ⚠️ NOT PUBLIC API. Undocumented on purpose. Do not use in an application.
+ *
+ * Angular-shaped wrapper around `setSkewDisabled()` from `@braidlabs/skew`. Read the
+ * module comment in `@braidlabs/skew`'s `disabled.ts` first — it explains what this
+ * turns off, why it exists, and why it is deliberately absent from the README,
+ * the package docs, and every example.
+ *
+ * ```ts
+ * // demo apps only
+ * providers: [provideSkewRecovery({ … }), provideSkewDisabled()]
+ * ```
+ *
+ * Two things worth knowing before using it anyway:
+ *
+ * **It is not scoped to this injector.** The flag lives in a module-level
+ * variable in `@braidlabs/skew`, because core is framework-agnostic and has no
+ * injector to read from. Calling this affects every `@braidlabs` package sharing
+ * that instance of core — including any other Angular application on the page.
+ * It is `provide*`-shaped for familiarity, not because it is scoped.
+ *
+ * **It applies at bootstrap.** For a control that flips at runtime — which is
+ * what a before/after demo actually wants — call `setSkewDisabled()` directly.
+ * Every check reads the flag at the moment it runs, so a later toggle takes
+ * effect on the next read, navigation or write with no reload.
+ *
+ * This lives in `@braidlabs/angular-router` for want of a shared Angular package;
+ * it belongs in `@braidlabs/angular-core` once that lands, since it governs all of
+ * them and nothing here is router-specific.
+ *
+ * @internal
+ */
+function provideSkewDisabled(disabled = true) {
+    return makeEnvironmentProviders([
+        provideEnvironmentInitializer(() => setSkewDisabled(disabled)),
+    ]);
+}
+/**
+ * Generated bundle index. Do not edit.
+ */
+export { ChunkLoadFailure, SKEW_RECOVERY_OPTIONS, SkewRecoveryService, UnsavedWorkRegistry, isChunkLoadFailure, lazy, lazyDefaults, looksLikeChunkError, provideSkewDisabled, provideSkewRecovery, resetLazyDefaults, resolveOptions, trackUnsavedWork };
+//# sourceMappingURL=braidlabs-angular-router.mjs.map

package/fesm2022/braidlabs-angular-router.mjs.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"braidlabs-angular-router.mjs","sources":["../../../../../libs/angular/router/src/lib/config.ts","../../../../../libs/angular/router/src/lib/lazy.ts","../../../../../libs/angular/router/src/lib/unsaved-work.ts","../../../../../libs/angular/router/src/lib/recovery.service.ts","../../../../../libs/angular/router/src/lib/provide.ts","../../../../../libs/angular/router/src/lib/disabled.provider.ts","../../../../../libs/angular/router/src/braidlabs-angular-router.ts"],"sourcesContent":["import { InjectionToken } from '@angular/core';\nimport type { BuildIdentity } from '@braidlabs/skew';\n\n/**\n * What to do when a lazy chunk cannot be loaded.\n *\n * These are not interchangeable. A missing chunk, an offline device, a deleted\n * route, and an origin serving a stale entry document all arrive as the same\n * rejected dynamic import, and each wants a different response — which is why\n * classification happens before dispatch.\n */\nexport type StaleChunkAction =\n /**\n * Hard-navigate to the URL the user was trying to reach.\n *\n * Distinct from a plain reload for a subtle reason: Angular's default\n * `urlUpdateStrategy` is `'deferred'`, so after a failed navigation the\n * address bar still shows the *previous* route. `location.reload()` would\n * therefore return the user where they started and silently discard the\n * navigation they attempted.\n */\n | 'reload-at-target'\n /** Refresh the current route, abandoning the attempted navigation. */\n | 'reload-in-place'\n /** Client-side redirect to `fallbackRoute`. Correct when the route is gone. */\n | 'redirect-to-fallback'\n /** Take no automatic action; expose it and let the application decide. */\n | 'notify'\n /** Leave `NavigationError` to propagate untouched. */\n | 'ignore';\n\n/** Everything known about the failure at the moment a strategy is chosen. */\nexport interface StaleChunkContext {\n /** The URL the user was navigating to. */\n readonly targetUrl: string;\n /** Where they still are, since the navigation failed. */\n readonly currentUrl: string;\n /** Logical id passed to `lazy()`, when one was supplied. */\n readonly moduleId?: string;\n readonly error: unknown;\n\n /** Recoveries already spent this session, for loop protection. */\n readonly attempt: number;\n readonly isOnline: boolean;\n\n readonly clientBuildId: string;\n /** Present only when the manifest probe succeeded. */\n readonly serverBuildId?: string;\n\n /**\n * False when the module is absent from the new build's manifest — the route\n * was deleted, so reloading would land on a router 404.\n */\n readonly moduleStillExists: boolean;\n /**\n * True when the origin reports an *older* build than the one running.\n * Reloading fetches the same stale bundle and fails again — forever.\n */\n readonly entryDocumentStale: boolean;\n /** True when the probe reached the origin and it is ahead of us. */\n readonly newAssetsReachable: boolean;\n\n /** True when something on the page has registered unsaved work. */\n readonly hasUnsavedWork: boolean;\n}\n\nexport type StaleChunkStrategy =\n | StaleChunkAction\n | ((context: StaleChunkContext) => StaleChunkAction | Promise<StaleChunkAction>);\n\nexport interface SkewRecoveryOptions {\n /** Identity of this build. Generate with `@braidlabs/build`. */\n readonly identity: BuildIdentity;\n /**\n * Manifest the origin serves, `Cache-Control: no-store`. Without it the\n * library still recovers, but cannot distinguish a deleted route or a stale\n * origin — so it degrades to conservative behaviour.\n */\n readonly manifestUrl?: string;\n /** Default `'reload-at-target'`. */\n readonly onStaleChunk?: StaleChunkStrategy;\n /** Transient-failure retries inside `lazy()`. Default 1. */\n readonly retryAttempts?: number;\n /** Backoff between retries. Default 250ms. */\n readonly retryDelayMs?: number;\n /**\n * Hard cap on automatic recoveries per session. Default 1.\n *\n * The blunt guard against reload loops; the manifest probe is the precise\n * one. Both exist because the failure mode — a bricked tab — is severe.\n */\n readonly maxRecoveries?: number;\n /** Target for `'redirect-to-fallback'`. Default `'/'`. */\n readonly fallbackRoute?: string;\n /**\n * Degrade to `'notify'` when unsaved work is registered. Default true.\n *\n * Angular does not let a library ask the router whether a `CanDeactivate`\n * guard would block, so components opt in via `trackUnsavedWork()`.\n */\n readonly respectUnsavedWork?: boolean;\n}\n\n/** Fully-resolved options, with defaults applied. */\nexport interface ResolvedSkewRecoveryOptions extends SkewRecoveryOptions {\n readonly onStaleChunk: StaleChunkStrategy;\n readonly retryAttempts: number;\n readonly retryDelayMs: number;\n readonly maxRecoveries: number;\n readonly fallbackRoute: string;\n readonly respectUnsavedWork: boolean;\n}\n\nexport const SKEW_RECOVERY_OPTIONS = new InjectionToken<ResolvedSkewRecoveryOptions>(\n 'SKEW_RECOVERY_OPTIONS',\n);\n\nexport function resolveOptions(options: SkewRecoveryOptions): ResolvedSkewRecoveryOptions {\n return {\n ...options,\n onStaleChunk: options.onStaleChunk ?? 'reload-at-target',\n retryAttempts: options.retryAttempts ?? 1,\n retryDelayMs: options.retryDelayMs ?? 250,\n maxRecoveries: options.maxRecoveries ?? 1,\n fallbackRoute: options.fallbackRoute ?? '/',\n respectUnsavedWork: options.respectUnsavedWork ?? true,\n };\n}\n\n/** A recovery the application has been asked to complete itself. */\nexport interface PendingSkew {\n readonly targetUrl: string;\n readonly moduleId?: string;\n readonly serverBuildId?: string;\n readonly reason: 'notify' | 'exhausted' | 'loop-detected' | 'offline';\n readonly context: StaleChunkContext;\n}\n","/**\n * Wrapping the dynamic import.\n *\n * Two problems are solved here, both before any Angular machinery is involved:\n *\n * 1. **Attribution.** By the time an import rejects, the runtime holds\n * `chunk-ABC123.js` — not `./admin/routes`. Without a logical id there is no\n * way to ask the new build's manifest whether that route still exists.\n * 2. **Transience.** A flaky network, a CDN edge miss, and a genuinely purged\n * asset are indistinguishable from the error alone. A bounded retry resolves\n * the first two without inflicting a page reload on anyone.\n *\n * Retry is therefore a *precondition* to recovery, not one of the strategies.\n */\n\nimport { isSkewDisabled } from '@braidlabs/skew';\n\n/** Defaults for `lazy()`, overridable globally by `provideSkewRecovery()`. */\nexport const lazyDefaults = {\n retryAttempts: 1,\n retryDelayMs: 250,\n};\n\n/** Restores defaults. Exposed for tests, which must not leak configuration. */\nexport function resetLazyDefaults(): void {\n lazyDefaults.retryAttempts = 1;\n lazyDefaults.retryDelayMs = 250;\n}\n\n/**\n * Thrown when a lazy load fails after its retries are exhausted.\n *\n * Angular surfaces this through `NavigationError`, where the recovery service\n * recognises it. Carrying the module id across that boundary is the whole\n * reason this error type exists.\n */\nexport class ChunkLoadFailure extends Error {\n override readonly name = 'ChunkLoadFailure';\n constructor(\n readonly moduleId: string | undefined,\n readonly cause: unknown,\n readonly attempts: number,\n ) {\n super(\n `[skew] failed to load ${moduleId ? `\"${moduleId}\"` : 'a lazy chunk'} ` +\n `after ${attempts} attempt${attempts === 1 ? '' : 's'}`,\n );\n }\n}\n\nexport function isChunkLoadFailure(value: unknown): value is ChunkLoadFailure {\n return value instanceof ChunkLoadFailure;\n}\n\n/**\n * Heuristic for \"this looks like a module that failed to load\" rather than an\n * error thrown *by* the module once it ran.\n *\n * Deliberately broad: bundlers and browsers disagree on the shape here\n * (`ChunkLoadError`, a bare `TypeError`, a CSP violation), and a false positive\n * costs one wasted retry while a false negative costs the user their session.\n */\nexport function looksLikeChunkError(error: unknown): boolean {\n if (!error) return false;\n const name = (error as Error).name ?? '';\n const message = (error as Error).message ?? '';\n return (\n name === 'ChunkLoadError' ||\n /loading (chunk|css chunk)/i.test(message) ||\n /failed to fetch dynamically imported module/i.test(message) ||\n /error loading dynamically imported module/i.test(message) ||\n /importing a module script failed/i.test(message)\n );\n}\n\nexport interface LazyOptions {\n readonly retryAttempts?: number;\n readonly retryDelayMs?: number;\n}\n\n/**\n * Wraps a dynamic import for use as `loadChildren` or `loadComponent`.\n *\n * ```ts\n * { path: 'admin', loadChildren: lazy('admin.routes', () => import('./admin/routes')) }\n * { path: 'help', loadComponent: lazy('help.page', () => import('./help').then(m => m.Help)) }\n * ```\n *\n * The returned function is a plain loader — the router needs no knowledge of\n * this library, and routes remain usable if the package is removed.\n */\nexport function lazy<T>(\n moduleId: string,\n loader: () => Promise<T>,\n options?: LazyOptions,\n): () => Promise<T>;\nexport function lazy<T>(loader: () => Promise<T>, options?: LazyOptions): () => Promise<T>;\nexport function lazy<T>(\n moduleIdOrLoader: string | (() => Promise<T>),\n loaderOrOptions?: (() => Promise<T>) | LazyOptions,\n maybeOptions?: LazyOptions,\n): () => Promise<T> {\n const hasId = typeof moduleIdOrLoader === 'string';\n const moduleId = hasId ? moduleIdOrLoader : undefined;\n const loader = (hasId ? loaderOrOptions : moduleIdOrLoader) as () => Promise<T>;\n const options = (hasId ? maybeOptions : (loaderOrOptions as LazyOptions)) ?? {};\n\n if (typeof loader !== 'function') {\n throw new TypeError('[skew] lazy() requires a loader function');\n }\n\n return async () => {\n // Not public API — see `disabled.ts` in @braidlabs/skew. A bare dynamic import\n // with no retry and no attribution: the rejection propagates exactly as the\n // bundler produced it, and nothing downstream knows which module it was.\n if (isSkewDisabled()) return loader();\n\n const attempts = Math.max(0, options.retryAttempts ?? lazyDefaults.retryAttempts) + 1;\n const delay = options.retryDelayMs ?? lazyDefaults.retryDelayMs;\n\n let lastError: unknown;\n for (let attempt = 1; attempt <= attempts; attempt++) {\n try {\n return await loader();\n } catch (error) {\n lastError = error;\n // An error thrown by module *evaluation* is a bug in the module, not a\n // transport failure. Retrying it just runs the bug again.\n if (!looksLikeChunkError(error)) throw error;\n if (attempt < attempts && delay > 0) {\n await new Promise((resolve) => setTimeout(resolve, delay * attempt));\n }\n }\n }\n throw new ChunkLoadFailure(moduleId, lastError, attempts);\n };\n}\n","import { DestroyRef, Injectable, inject, signal } from '@angular/core';\n\n/**\n * Unsaved-work tracking.\n *\n * A hard reload destroys in-memory state, so recovery must know whether that\n * matters. Angular already has a declaration for exactly this — `CanDeactivate`\n * — but the router exposes no way to ask \"would a guard block here?\", so a\n * library cannot reuse it.\n *\n * This registry is the workaround: components declare dirtiness explicitly and\n * the recovery service consults it. If Angular ever exposes guard\n * introspection, this whole file becomes deletable.\n */\n@Injectable({ providedIn: 'root' })\nexport class UnsavedWorkRegistry {\n private readonly sources = signal<ReadonlyArray<() => boolean>>([]);\n\n /** Registers a predicate. Returns a disposer. */\n register(isDirty: () => boolean): () => void {\n this.sources.update((current) => [...current, isDirty]);\n return () => {\n this.sources.update((current) => current.filter((entry) => entry !== isDirty));\n };\n }\n\n /**\n * True when any registered source reports unsaved work.\n *\n * A throwing predicate is treated as *clean* rather than dirty: a broken\n * dirty-check should not permanently block recovery and strand the user.\n */\n isDirty(): boolean {\n return this.sources().some((isDirty) => {\n try {\n return isDirty();\n } catch {\n return false;\n }\n });\n }\n\n /** Count of registered sources. Diagnostics only. */\n get size(): number {\n return this.sources().length;\n }\n}\n\n/**\n * Declares that this component holds unsaved work, so automatic recovery will\n * not discard it. Unregisters automatically on destroy.\n *\n * ```ts\n * export class BulletinEditor {\n * protected readonly form = …;\n * constructor() {\n * trackUnsavedWork(() => this.form.dirty);\n * }\n * }\n * ```\n *\n * Must be called in an injection context.\n */\nexport function trackUnsavedWork(isDirty: () => boolean): void {\n const registry = inject(UnsavedWorkRegistry);\n const destroyRef = inject(DestroyRef);\n const dispose = registry.register(isDirty);\n destroyRef.onDestroy(dispose);\n}\n","import { DOCUMENT, Injectable, PLATFORM_ID, computed, inject, signal } from '@angular/core';\nimport { isPlatformBrowser } from '@angular/common';\nimport { NavigationError, Router } from '@angular/router';\nimport {\n type SkewStatus,\n type VersionProbe,\n createVersionProbe,\n isSkewDisabled,\n moduleWasRemoved,\n} from '@braidlabs/skew';\nimport {\n type PendingSkew,\n SKEW_RECOVERY_OPTIONS,\n type StaleChunkAction,\n type StaleChunkContext,\n} from './config';\nimport { ChunkLoadFailure, isChunkLoadFailure } from './lazy';\nimport { UnsavedWorkRegistry } from './unsaved-work';\n\nconst LOOP_GUARD_KEY = 'skew:recoveries';\n\n/**\n * Orchestrates recovery from a failed lazy load.\n *\n * Wiring is via router events rather than a global registry: `lazy()` throws a\n * {@link ChunkLoadFailure}, Angular surfaces it as `NavigationError`, and this\n * service recognises it there. That keeps `lazy()` dependency-free and usable\n * in route definitions, which are evaluated long before DI exists.\n *\n * Zoneless-safe and SSR-safe: no `NgZone`, and every `location` /\n * `sessionStorage` touch is guarded.\n */\n@Injectable({ providedIn: 'root' })\nexport class SkewRecoveryService {\n private readonly options = inject(SKEW_RECOVERY_OPTIONS);\n private readonly router = inject(Router);\n private readonly document = inject(DOCUMENT);\n private readonly unsavedWork = inject(UnsavedWorkRegistry);\n private readonly isBrowser = isPlatformBrowser(inject(PLATFORM_ID));\n\n private readonly probe: VersionProbe | null;\n\n private readonly pendingSignal = signal<PendingSkew | null>(null);\n private readonly statusSignal = signal<SkewStatus | null>(null);\n\n /** A recovery the application has been asked to complete itself. */\n readonly pending = this.pendingSignal.asReadonly();\n /** Last known comparison against the origin. */\n readonly status = this.statusSignal.asReadonly();\n /** True when a newer deployment is known to exist. */\n readonly updateAvailable = computed(() => this.statusSignal()?.kind === 'staleClient');\n\n constructor() {\n this.probe = this.options.manifestUrl\n ? createVersionProbe({\n identity: this.options.identity,\n manifestUrl: this.options.manifestUrl,\n })\n : null;\n\n if (this.isBrowser) this.listen();\n }\n\n private listen(): void {\n this.router.events.subscribe((event) => {\n if (event instanceof NavigationError && isChunkLoadFailure(event.error)) {\n // Not public API — see `disabled.ts` in @braidlabs/skew. The NavigationError\n // is left to propagate untouched: no retry, no manifest probe, no\n // classification, no decision. Whatever the application does next is\n // whatever it would have done without this package installed.\n if (isSkewDisabled()) return;\n void this.handle(event.error, event.url);\n }\n });\n }\n\n /** Re-checks the origin. Safe to call from a \"check for updates\" control. */\n async check(): Promise<SkewStatus | null> {\n if (!this.probe) return null;\n const status = await this.probe.check();\n this.statusSignal.set(status);\n return status;\n }\n\n /** Completes a deferred recovery — what a \"Reload\" button calls. */\n recover(): void {\n const pending = this.pendingSignal();\n if (!pending) return;\n this.pendingSignal.set(null);\n this.assign(pending.targetUrl);\n }\n\n /** Dismisses a pending recovery without acting on it. */\n dismiss(): void {\n this.pendingSignal.set(null);\n }\n\n private async handle(failure: ChunkLoadFailure, targetUrl: string): Promise<void> {\n const context = await this.classify(failure, targetUrl);\n const action = await this.chooseAction(context);\n this.dispatch(action, context);\n }\n\n private async classify(\n failure: ChunkLoadFailure,\n targetUrl: string,\n ): Promise<StaleChunkContext> {\n const status = await this.check();\n\n const serverBuildId =\n status?.kind === 'current'\n ? status.buildId\n : status && 'remote' in status\n ? status.remote\n : undefined;\n\n // Absent a module map we must assume the route still exists. Claiming it\n // was deleted would redirect users away from a route that merely moved —\n // a worse failure than the one being recovered from.\n const manifest = this.probe?.lastManifest() ?? null;\n const moduleStillExists =\n failure.moduleId === undefined ||\n manifest === null ||\n !moduleWasRemoved(manifest, failure.moduleId);\n\n return {\n targetUrl,\n currentUrl: this.router.url,\n moduleId: failure.moduleId,\n error: failure,\n attempt: this.recoveryCount(),\n isOnline: this.isOnline(),\n clientBuildId: this.options.identity.buildId,\n serverBuildId,\n moduleStillExists,\n entryDocumentStale: status?.kind === 'staleOrigin',\n newAssetsReachable: status?.kind === 'staleClient',\n hasUnsavedWork: this.options.respectUnsavedWork && this.unsavedWork.isDirty(),\n };\n }\n\n private async chooseAction(context: StaleChunkContext): Promise<StaleChunkAction> {\n // Guard rails run before any application policy, because each of these is a\n // case where reloading is actively harmful rather than merely unhelpful.\n if (!context.isOnline) return 'notify';\n if (context.entryDocumentStale) return 'notify'; // reloading would loop\n if (context.attempt >= this.options.maxRecoveries) return 'notify';\n if (context.hasUnsavedWork) return 'notify';\n if (!context.moduleStillExists) return 'redirect-to-fallback';\n\n const strategy = this.options.onStaleChunk;\n if (typeof strategy === 'function') {\n try {\n return await strategy(context);\n } catch {\n // A throwing policy must not strand the user with nothing.\n return 'notify';\n }\n }\n return strategy;\n }\n\n private dispatch(action: StaleChunkAction, context: StaleChunkContext): void {\n switch (action) {\n case 'reload-at-target':\n this.countRecovery();\n this.assign(context.targetUrl);\n return;\n case 'reload-in-place':\n this.countRecovery();\n this.reload();\n return;\n case 'redirect-to-fallback':\n void this.router.navigateByUrl(this.options.fallbackRoute);\n return;\n case 'ignore':\n return;\n case 'notify':\n this.pendingSignal.set({\n targetUrl: context.targetUrl,\n moduleId: context.moduleId,\n serverBuildId: context.serverBuildId,\n reason: !context.isOnline\n ? 'offline'\n : context.entryDocumentStale\n ? 'loop-detected'\n : context.attempt >= this.options.maxRecoveries\n ? 'exhausted'\n : 'notify',\n context,\n });\n return;\n }\n }\n\n // --- environment access, all browser-guarded ---------------------------\n\n private isOnline(): boolean {\n if (!this.isBrowser) return true;\n const nav = this.document.defaultView?.navigator;\n return nav?.onLine ?? true;\n }\n\n private assign(url: string): void {\n if (!this.isBrowser) return;\n this.document.defaultView?.location.assign(url);\n }\n\n private reload(): void {\n if (!this.isBrowser) return;\n this.document.defaultView?.location.reload();\n }\n\n /**\n * Recoveries already attempted, kept in `sessionStorage` so it survives the\n * very reload it is counting. Without this, an origin serving a stale entry\n * document turns one failure into an infinite reload loop.\n */\n private recoveryCount(): number {\n if (!this.isBrowser) return 0;\n try {\n const raw = this.document.defaultView?.sessionStorage.getItem(LOOP_GUARD_KEY);\n const parsed = raw ? JSON.parse(raw) : null;\n // Scoped to a build: a genuinely new deployment gets a fresh budget.\n return parsed?.buildId === this.options.identity.buildId ? (parsed.count ?? 0) : 0;\n } catch {\n return 0;\n }\n }\n\n private countRecovery(): void {\n if (!this.isBrowser) return;\n try {\n this.document.defaultView?.sessionStorage.setItem(\n LOOP_GUARD_KEY,\n JSON.stringify({ buildId: this.options.identity.buildId, count: this.recoveryCount() + 1 }),\n );\n } catch {\n // Private mode. The manifest probe remains as the precise loop guard.\n }\n }\n}\n","import {\n type EnvironmentProviders,\n provideEnvironmentInitializer,\n makeEnvironmentProviders,\n inject,\n} from '@angular/core';\nimport { SKEW_RECOVERY_OPTIONS, type SkewRecoveryOptions, resolveOptions } from './config';\nimport { SkewRecoveryService } from './recovery.service';\nimport { lazyDefaults } from './lazy';\n\n/**\n * Enables skew recovery.\n *\n * ```ts\n * bootstrapApplication(App, {\n * providers: [\n * provideRouter(routes),\n * provideSkewRecovery({\n * identity: BUILD_IDENTITY, // from @braidlabs/build\n * manifestUrl: '/skew-manifest.json',\n * }),\n * ],\n * });\n * ```\n *\n * Deliberately *not* a `RouterFeature`: Angular's feature factory is internal,\n * so third parties cannot construct one. This composes alongside\n * `provideRouter` instead, and works with any router configuration.\n *\n * The service is instantiated eagerly — it subscribes to router events, and a\n * lazily-created recovery service would miss the very first failure.\n */\nexport function provideSkewRecovery(options: SkewRecoveryOptions): EnvironmentProviders {\n const resolved = resolveOptions(options);\n\n return makeEnvironmentProviders([\n { provide: SKEW_RECOVERY_OPTIONS, useValue: resolved },\n provideEnvironmentInitializer(() => {\n // Route definitions are evaluated before DI exists, so `lazy()` cannot\n // inject its retry policy. Publishing the resolved values here keeps a\n // single source of configuration without making `lazy()` DI-aware.\n lazyDefaults.retryAttempts = resolved.retryAttempts;\n lazyDefaults.retryDelayMs = resolved.retryDelayMs;\n\n inject(SkewRecoveryService);\n }),\n ]);\n}\n","import {\n type EnvironmentProviders,\n makeEnvironmentProviders,\n provideEnvironmentInitializer,\n} from '@angular/core';\nimport { setSkewDisabled } from '@braidlabs/skew';\n\n/**\n * ⚠️ NOT PUBLIC API. Undocumented on purpose. Do not use in an application.\n *\n * Angular-shaped wrapper around `setSkewDisabled()` from `@braidlabs/skew`. Read the\n * module comment in `@braidlabs/skew`'s `disabled.ts` first — it explains what this\n * turns off, why it exists, and why it is deliberately absent from the README,\n * the package docs, and every example.\n *\n * ```ts\n * // demo apps only\n * providers: [provideSkewRecovery({ … }), provideSkewDisabled()]\n * ```\n *\n * Two things worth knowing before using it anyway:\n *\n * **It is not scoped to this injector.** The flag lives in a module-level\n * variable in `@braidlabs/skew`, because core is framework-agnostic and has no\n * injector to read from. Calling this affects every `@braidlabs` package sharing\n * that instance of core — including any other Angular application on the page.\n * It is `provide*`-shaped for familiarity, not because it is scoped.\n *\n * **It applies at bootstrap.** For a control that flips at runtime — which is\n * what a before/after demo actually wants — call `setSkewDisabled()` directly.\n * Every check reads the flag at the moment it runs, so a later toggle takes\n * effect on the next read, navigation or write with no reload.\n *\n * This lives in `@braidlabs/angular-router` for want of a shared Angular package;\n * it belongs in `@braidlabs/angular-core` once that lands, since it governs all of\n * them and nothing here is router-specific.\n *\n * @internal\n */\nexport function provideSkewDisabled(disabled = true): EnvironmentProviders {\n return makeEnvironmentProviders([\n provideEnvironmentInitializer(() => setSkewDisabled(disabled)),\n ]);\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":"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"}

package/package.json ADDED Viewed

@@ -0,0 +1,39 @@
+{
+  "name": "@braidlabs/angular-router",
+  "version": "0.1.1",
+  "peerDependencies": {
+    "@angular/core": "^22.0.0",
+    "@angular/router": "^22.0.0",
+    "@angular/common": "^22.0.0",
+    "@braidlabs/skew": "^0.1.1"
+  },
+  "sideEffects": false,
+  "description": "Recovers from stale lazy-chunk failures after a deploy, with classification that avoids reload loops.",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/braidjs/braid.git",
+    "directory": "libs/angular/router"
+  },
+  "homepage": "https://github.com/braidjs/braid#readme",
+  "bugs": {
+    "url": "https://github.com/braidjs/braid/issues"
+  },
+  "module": "fesm2022/braidlabs-angular-router.mjs",
+  "typings": "types/braidlabs-angular-router.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./types/braidlabs-angular-router.d.ts",
+      "default": "./fesm2022/braidlabs-angular-router.mjs"
+    }
+  },
+  "type": "module",
+  "dependencies": {
+    "tslib": "^2.3.0"
+  }
+}

package/types/braidlabs-angular-router.d.ts ADDED Viewed

@@ -0,0 +1,334 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, EnvironmentProviders } from '@angular/core';
+import { BuildIdentity, SkewStatus } from '@braidlabs/skew';
+/**
+ * What to do when a lazy chunk cannot be loaded.
+ *
+ * These are not interchangeable. A missing chunk, an offline device, a deleted
+ * route, and an origin serving a stale entry document all arrive as the same
+ * rejected dynamic import, and each wants a different response — which is why
+ * classification happens before dispatch.
+ */
+type StaleChunkAction =
+/**
+ * Hard-navigate to the URL the user was trying to reach.
+ *
+ * Distinct from a plain reload for a subtle reason: Angular's default
+ * `urlUpdateStrategy` is `'deferred'`, so after a failed navigation the
+ * address bar still shows the *previous* route. `location.reload()` would
+ * therefore return the user where they started and silently discard the
+ * navigation they attempted.
+ */
+'reload-at-target'
+/** Refresh the current route, abandoning the attempted navigation. */
+ | 'reload-in-place'
+/** Client-side redirect to `fallbackRoute`. Correct when the route is gone. */
+ | 'redirect-to-fallback'
+/** Take no automatic action; expose it and let the application decide. */
+ | 'notify'
+/** Leave `NavigationError` to propagate untouched. */
+ | 'ignore';
+/** Everything known about the failure at the moment a strategy is chosen. */
+interface StaleChunkContext {
+    /** The URL the user was navigating to. */
+    readonly targetUrl: string;
+    /** Where they still are, since the navigation failed. */
+    readonly currentUrl: string;
+    /** Logical id passed to `lazy()`, when one was supplied. */
+    readonly moduleId?: string;
+    readonly error: unknown;
+    /** Recoveries already spent this session, for loop protection. */
+    readonly attempt: number;
+    readonly isOnline: boolean;
+    readonly clientBuildId: string;
+    /** Present only when the manifest probe succeeded. */
+    readonly serverBuildId?: string;
+    /**
+     * False when the module is absent from the new build's manifest — the route
+     * was deleted, so reloading would land on a router 404.
+     */
+    readonly moduleStillExists: boolean;
+    /**
+     * True when the origin reports an *older* build than the one running.
+     * Reloading fetches the same stale bundle and fails again — forever.
+     */
+    readonly entryDocumentStale: boolean;
+    /** True when the probe reached the origin and it is ahead of us. */
+    readonly newAssetsReachable: boolean;
+    /** True when something on the page has registered unsaved work. */
+    readonly hasUnsavedWork: boolean;
+}
+type StaleChunkStrategy = StaleChunkAction | ((context: StaleChunkContext) => StaleChunkAction | Promise<StaleChunkAction>);
+interface SkewRecoveryOptions {
+    /** Identity of this build. Generate with `@braidlabs/build`. */
+    readonly identity: BuildIdentity;
+    /**
+     * Manifest the origin serves, `Cache-Control: no-store`. Without it the
+     * library still recovers, but cannot distinguish a deleted route or a stale
+     * origin — so it degrades to conservative behaviour.
+     */
+    readonly manifestUrl?: string;
+    /** Default `'reload-at-target'`. */
+    readonly onStaleChunk?: StaleChunkStrategy;
+    /** Transient-failure retries inside `lazy()`. Default 1. */
+    readonly retryAttempts?: number;
+    /** Backoff between retries. Default 250ms. */
+    readonly retryDelayMs?: number;
+    /**
+     * Hard cap on automatic recoveries per session. Default 1.
+     *
+     * The blunt guard against reload loops; the manifest probe is the precise
+     * one. Both exist because the failure mode — a bricked tab — is severe.
+     */
+    readonly maxRecoveries?: number;
+    /** Target for `'redirect-to-fallback'`. Default `'/'`. */
+    readonly fallbackRoute?: string;
+    /**
+     * Degrade to `'notify'` when unsaved work is registered. Default true.
+     *
+     * Angular does not let a library ask the router whether a `CanDeactivate`
+     * guard would block, so components opt in via `trackUnsavedWork()`.
+     */
+    readonly respectUnsavedWork?: boolean;
+}
+/** Fully-resolved options, with defaults applied. */
+interface ResolvedSkewRecoveryOptions extends SkewRecoveryOptions {
+    readonly onStaleChunk: StaleChunkStrategy;
+    readonly retryAttempts: number;
+    readonly retryDelayMs: number;
+    readonly maxRecoveries: number;
+    readonly fallbackRoute: string;
+    readonly respectUnsavedWork: boolean;
+}
+declare const SKEW_RECOVERY_OPTIONS: InjectionToken<ResolvedSkewRecoveryOptions>;
+declare function resolveOptions(options: SkewRecoveryOptions): ResolvedSkewRecoveryOptions;
+/** A recovery the application has been asked to complete itself. */
+interface PendingSkew {
+    readonly targetUrl: string;
+    readonly moduleId?: string;
+    readonly serverBuildId?: string;
+    readonly reason: 'notify' | 'exhausted' | 'loop-detected' | 'offline';
+    readonly context: StaleChunkContext;
+}
+/**
+ * Wrapping the dynamic import.
+ *
+ * Two problems are solved here, both before any Angular machinery is involved:
+ *
+ * 1. **Attribution.** By the time an import rejects, the runtime holds
+ *    `chunk-ABC123.js` — not `./admin/routes`. Without a logical id there is no
+ *    way to ask the new build's manifest whether that route still exists.
+ * 2. **Transience.** A flaky network, a CDN edge miss, and a genuinely purged
+ *    asset are indistinguishable from the error alone. A bounded retry resolves
+ *    the first two without inflicting a page reload on anyone.
+ *
+ * Retry is therefore a *precondition* to recovery, not one of the strategies.
+ */
+/** Defaults for `lazy()`, overridable globally by `provideSkewRecovery()`. */
+declare const lazyDefaults: {
+    retryAttempts: number;
+    retryDelayMs: number;
+};
+/** Restores defaults. Exposed for tests, which must not leak configuration. */
+declare function resetLazyDefaults(): void;
+/**
+ * Thrown when a lazy load fails after its retries are exhausted.
+ *
+ * Angular surfaces this through `NavigationError`, where the recovery service
+ * recognises it. Carrying the module id across that boundary is the whole
+ * reason this error type exists.
+ */
+declare class ChunkLoadFailure extends Error {
+    readonly moduleId: string | undefined;
+    readonly cause: unknown;
+    readonly attempts: number;
+    readonly name = "ChunkLoadFailure";
+    constructor(moduleId: string | undefined, cause: unknown, attempts: number);
+}
+declare function isChunkLoadFailure(value: unknown): value is ChunkLoadFailure;
+/**
+ * Heuristic for "this looks like a module that failed to load" rather than an
+ * error thrown *by* the module once it ran.
+ *
+ * Deliberately broad: bundlers and browsers disagree on the shape here
+ * (`ChunkLoadError`, a bare `TypeError`, a CSP violation), and a false positive
+ * costs one wasted retry while a false negative costs the user their session.
+ */
+declare function looksLikeChunkError(error: unknown): boolean;
+interface LazyOptions {
+    readonly retryAttempts?: number;
+    readonly retryDelayMs?: number;
+}
+/**
+ * Wraps a dynamic import for use as `loadChildren` or `loadComponent`.
+ *
+ * ```ts
+ * { path: 'admin', loadChildren: lazy('admin.routes', () => import('./admin/routes')) }
+ * { path: 'help',  loadComponent: lazy('help.page', () => import('./help').then(m => m.Help)) }
+ * ```
+ *
+ * The returned function is a plain loader — the router needs no knowledge of
+ * this library, and routes remain usable if the package is removed.
+ */
+declare function lazy<T>(moduleId: string, loader: () => Promise<T>, options?: LazyOptions): () => Promise<T>;
+declare function lazy<T>(loader: () => Promise<T>, options?: LazyOptions): () => Promise<T>;
+/**
+ * Unsaved-work tracking.
+ *
+ * A hard reload destroys in-memory state, so recovery must know whether that
+ * matters. Angular already has a declaration for exactly this — `CanDeactivate`
+ * — but the router exposes no way to ask "would a guard block here?", so a
+ * library cannot reuse it.
+ *
+ * This registry is the workaround: components declare dirtiness explicitly and
+ * the recovery service consults it. If Angular ever exposes guard
+ * introspection, this whole file becomes deletable.
+ */
+declare class UnsavedWorkRegistry {
+    private readonly sources;
+    /** Registers a predicate. Returns a disposer. */
+    register(isDirty: () => boolean): () => void;
+    /**
+     * True when any registered source reports unsaved work.
+     *
+     * A throwing predicate is treated as *clean* rather than dirty: a broken
+     * dirty-check should not permanently block recovery and strand the user.
+     */
+    isDirty(): boolean;
+    /** Count of registered sources. Diagnostics only. */
+    get size(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UnsavedWorkRegistry, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UnsavedWorkRegistry>;
+}
+/**
+ * Declares that this component holds unsaved work, so automatic recovery will
+ * not discard it. Unregisters automatically on destroy.
+ *
+ * ```ts
+ * export class BulletinEditor {
+ *   protected readonly form = …;
+ *   constructor() {
+ *     trackUnsavedWork(() => this.form.dirty);
+ *   }
+ * }
+ * ```
+ *
+ * Must be called in an injection context.
+ */
+declare function trackUnsavedWork(isDirty: () => boolean): void;
+/**
+ * Orchestrates recovery from a failed lazy load.
+ *
+ * Wiring is via router events rather than a global registry: `lazy()` throws a
+ * {@link ChunkLoadFailure}, Angular surfaces it as `NavigationError`, and this
+ * service recognises it there. That keeps `lazy()` dependency-free and usable
+ * in route definitions, which are evaluated long before DI exists.
+ *
+ * Zoneless-safe and SSR-safe: no `NgZone`, and every `location` /
+ * `sessionStorage` touch is guarded.
+ */
+declare class SkewRecoveryService {
+    private readonly options;
+    private readonly router;
+    private readonly document;
+    private readonly unsavedWork;
+    private readonly isBrowser;
+    private readonly probe;
+    private readonly pendingSignal;
+    private readonly statusSignal;
+    /** A recovery the application has been asked to complete itself. */
+    readonly pending: i0.Signal<PendingSkew | null>;
+    /** Last known comparison against the origin. */
+    readonly status: i0.Signal<SkewStatus | null>;
+    /** True when a newer deployment is known to exist. */
+    readonly updateAvailable: i0.Signal<boolean>;
+    constructor();
+    private listen;
+    /** Re-checks the origin. Safe to call from a "check for updates" control. */
+    check(): Promise<SkewStatus | null>;
+    /** Completes a deferred recovery — what a "Reload" button calls. */
+    recover(): void;
+    /** Dismisses a pending recovery without acting on it. */
+    dismiss(): void;
+    private handle;
+    private classify;
+    private chooseAction;
+    private dispatch;
+    private isOnline;
+    private assign;
+    private reload;
+    /**
+     * Recoveries already attempted, kept in `sessionStorage` so it survives the
+     * very reload it is counting. Without this, an origin serving a stale entry
+     * document turns one failure into an infinite reload loop.
+     */
+    private recoveryCount;
+    private countRecovery;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkewRecoveryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkewRecoveryService>;
+}
+/**
+ * Enables skew recovery.
+ *
+ * ```ts
+ * bootstrapApplication(App, {
+ *   providers: [
+ *     provideRouter(routes),
+ *     provideSkewRecovery({
+ *       identity: BUILD_IDENTITY,          // from @braidlabs/build
+ *       manifestUrl: '/skew-manifest.json',
+ *     }),
+ *   ],
+ * });
+ * ```
+ *
+ * Deliberately *not* a `RouterFeature`: Angular's feature factory is internal,
+ * so third parties cannot construct one. This composes alongside
+ * `provideRouter` instead, and works with any router configuration.
+ *
+ * The service is instantiated eagerly — it subscribes to router events, and a
+ * lazily-created recovery service would miss the very first failure.
+ */
+declare function provideSkewRecovery(options: SkewRecoveryOptions): EnvironmentProviders;
+/**
+ * ⚠️ NOT PUBLIC API. Undocumented on purpose. Do not use in an application.
+ *
+ * Angular-shaped wrapper around `setSkewDisabled()` from `@braidlabs/skew`. Read the
+ * module comment in `@braidlabs/skew`'s `disabled.ts` first — it explains what this
+ * turns off, why it exists, and why it is deliberately absent from the README,
+ * the package docs, and every example.
+ *
+ * ```ts
+ * // demo apps only
+ * providers: [provideSkewRecovery({ … }), provideSkewDisabled()]
+ * ```
+ *
+ * Two things worth knowing before using it anyway:
+ *
+ * **It is not scoped to this injector.** The flag lives in a module-level
+ * variable in `@braidlabs/skew`, because core is framework-agnostic and has no
+ * injector to read from. Calling this affects every `@braidlabs` package sharing
+ * that instance of core — including any other Angular application on the page.
+ * It is `provide*`-shaped for familiarity, not because it is scoped.
+ *
+ * **It applies at bootstrap.** For a control that flips at runtime — which is
+ * what a before/after demo actually wants — call `setSkewDisabled()` directly.
+ * Every check reads the flag at the moment it runs, so a later toggle takes
+ * effect on the next read, navigation or write with no reload.
+ *
+ * This lives in `@braidlabs/angular-router` for want of a shared Angular package;
+ * it belongs in `@braidlabs/angular-core` once that lands, since it governs all of
+ * them and nothing here is router-specific.
+ *
+ * @internal
+ */
+declare function provideSkewDisabled(disabled?: boolean): EnvironmentProviders;
+export { ChunkLoadFailure, SKEW_RECOVERY_OPTIONS, SkewRecoveryService, UnsavedWorkRegistry, isChunkLoadFailure, lazy, lazyDefaults, looksLikeChunkError, provideSkewDisabled, provideSkewRecovery, resetLazyDefaults, resolveOptions, trackUnsavedWork };
+export type { LazyOptions, PendingSkew, ResolvedSkewRecoveryOptions, SkewRecoveryOptions, StaleChunkAction, StaleChunkContext, StaleChunkStrategy };