@sneat/logging 0.11.0 → 0.12.0

package/esm2022/index.js

@@ -1,4 +1,5 @@
 export * from './lib/sentry-setup';
+export * from './lib/chunk-load-error.handler';
 export * from './lib/sneat-logging.module';
 export * from './lib/analytics';
 //# sourceMappingURL=index.js.map

package/esm2022/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../libs/logging/src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,iBAAiB,CAAC","sourcesContent":["export * from './lib/sentry-setup';\nexport * from './lib/sneat-logging.module';\nexport * from './lib/analytics';\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../libs/logging/src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,iBAAiB,CAAC","sourcesContent":["export * from './lib/sentry-setup';\nexport * from './lib/chunk-load-error.handler';\nexport * from './lib/sneat-logging.module';\nexport * from './lib/analytics';\n"]}

package/esm2022/lib/chunk-load-error.handler.js

@@ -0,0 +1,84 @@
+import { ErrorHandler } from '@angular/core';
+/**
+ * Delegating {@link ErrorHandler} that reloads the app once when a lazy-loaded
+ * chunk fails to load, and forwards every other error to an inner handler.
+ *
+ * After a deploy, the hash-named lazy chunks are replaced on the server. A tab
+ * that was already open is still running an older `main.js` that references the
+ * previous chunk hashes, so navigating to a lazy route fetches a chunk URL that
+ * now 404s. Firebase Hosting's SPA rewrite then returns `index.html` for the
+ * missing `.js`, and the browser throws a `ChunkLoadError` /
+ * "'text/html' is not a valid JavaScript MIME type". A single full reload pulls
+ * the current `index.html` + matching chunks and transparently recovers.
+ *
+ * Non-chunk errors are delegated unchanged, so existing error reporting (e.g.
+ * the Sentry handler) keeps working. A short time-based guard (in
+ * `sessionStorage`) prevents a reload loop when a chunk is genuinely broken.
+ *
+ * Alternative considered: an Angular service worker (ngsw) + `SwUpdate` would
+ * largely *prevent* this by caching a consistent version set and prompting on a
+ * new deploy. We deliberately do NOT add a service worker just for this — the
+ * apps currently ship without one, and a SW brings its own caching/staleness
+ * complexity. If a PWA service worker is adopted later (for offline/installable
+ * support), this handler can stay as a cheap backstop.
+ */
+export class ChunkLoadErrorHandler {
+    static { this.reloadKey = 'sneat:chunk-reload-at'; }
+    static { this.reloadGuardMs = 10_000; }
+    constructor(delegate) {
+        this.delegate = delegate;
+    }
+    handleError(error) {
+        if (ChunkLoadErrorHandler.isChunkLoadError(error) &&
+            this.reloadOnceWithinGuard()) {
+            return;
+        }
+        this.delegate.handleError(error);
+    }
+    /** Reloads at most once per guard window; returns true if a reload was triggered. */
+    reloadOnceWithinGuard() {
+        let lastReloadAt = 0;
+        try {
+            lastReloadAt = Number(sessionStorage.getItem(ChunkLoadErrorHandler.reloadKey) ?? 0);
+        }
+        catch {
+            // sessionStorage may be unavailable (e.g. private mode) — fall through.
+        }
+        if (Date.now() - lastReloadAt <= ChunkLoadErrorHandler.reloadGuardMs) {
+            // Reloaded very recently and still failing -> stop to avoid a loop.
+            return false;
+        }
+        try {
+            sessionStorage.setItem(ChunkLoadErrorHandler.reloadKey, String(Date.now()));
+        }
+        catch {
+            // ignore storage failures; still attempt the reload below.
+        }
+        location.reload();
+        return true;
+    }
+    static isChunkLoadError(error) {
+        const err = error;
+        const name = err?.name ?? '';
+        const message = err?.message ?? String(error);
+        return (name === 'ChunkLoadError' ||
+            /Failed to fetch dynamically imported module/i.test(message) ||
+            /error loading dynamically imported module/i.test(message) ||
+            /Loading chunk [\w-]+ failed/i.test(message) ||
+            /Importing a module script failed/i.test(message) ||
+            /is not a valid JavaScript MIME type/i.test(message));
+    }
+}
+/**
+ * Provides a baseline {@link ChunkLoadErrorHandler} wrapping Angular's default
+ * `ErrorHandler`. Apps get this via `getStandardSneatProviders`. When Sentry is
+ * configured its own (also chunk-aware) handler is provided later and wins; this
+ * baseline covers apps without Sentry.
+ */
+export function provideChunkLoadErrorRecovery() {
+    return {
+        provide: ErrorHandler,
+        useFactory: () => new ChunkLoadErrorHandler(new ErrorHandler()),
+    };
+}
+//# sourceMappingURL=chunk-load-error.handler.js.map

package/esm2022/lib/chunk-load-error.handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk-load-error.handler.js","sourceRoot":"","sources":["../../../../../libs/logging/src/lib/chunk-load-error.handler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAY,MAAM,eAAe,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,OAAO,qBAAqB;aACT,cAAS,GAAG,uBAAuB,CAAC;aACpC,kBAAa,GAAG,MAAM,CAAC;IAE/C,YAA6B,QAAsB;QAAtB,aAAQ,GAAR,QAAQ,CAAc;IAAG,CAAC;IAEvD,WAAW,CAAC,KAAc;QACzB,IACC,qBAAqB,CAAC,gBAAgB,CAAC,KAAK,CAAC;YAC7C,IAAI,CAAC,qBAAqB,EAAE,EAC3B,CAAC;YACF,OAAO;QACR,CAAC;QACD,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC;IAED,qFAAqF;IAC7E,qBAAqB;QAC5B,IAAI,YAAY,GAAG,CAAC,CAAC;QACrB,IAAI,CAAC;YACJ,YAAY,GAAG,MAAM,CACpB,cAAc,CAAC,OAAO,CAAC,qBAAqB,CAAC,SAAS,CAAC,IAAI,CAAC,CAC5D,CAAC;QACH,CAAC;QAAC,MAAM,CAAC;YACR,wEAAwE;QACzE,CAAC;QACD,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,YAAY,IAAI,qBAAqB,CAAC,aAAa,EAAE,CAAC;YACtE,oEAAoE;YACpE,OAAO,KAAK,CAAC;QACd,CAAC;QACD,IAAI,CAAC;YACJ,cAAc,CAAC,OAAO,CACrB,qBAAqB,CAAC,SAAS,EAC/B,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAClB,CAAC;QACH,CAAC;QAAC,MAAM,CAAC;YACR,2DAA2D;QAC5D,CAAC;QACD,QAAQ,CAAC,MAAM,EAAE,CAAC;QAClB,OAAO,IAAI,CAAC;IACb,CAAC;IAEO,MAAM,CAAC,gBAAgB,CAAC,KAAc;QAC7C,MAAM,GAAG,GAAG,KAAmD,CAAC;QAChE,MAAM,IAAI,GAAG,GAAG,EAAE,IAAI,IAAI,EAAE,CAAC;QAC7B,MAAM,OAAO,GAAG,GAAG,EAAE,OAAO,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC;QAC9C,OAAO,CACN,IAAI,KAAK,gBAAgB;YACzB,8CAA8C,CAAC,IAAI,CAAC,OAAO,CAAC;YAC5D,4CAA4C,CAAC,IAAI,CAAC,OAAO,CAAC;YAC1D,8BAA8B,CAAC,IAAI,CAAC,OAAO,CAAC;YAC5C,mCAAmC,CAAC,IAAI,CAAC,OAAO,CAAC;YACjD,sCAAsC,CAAC,IAAI,CAAC,OAAO,CAAC,CACpD,CAAC;IACH,CAAC;;AAGF;;;;;GAKG;AACH,MAAM,UAAU,6BAA6B;IAC5C,OAAO;QACN,OAAO,EAAE,YAAY;QACrB,UAAU,EAAE,GAAG,EAAE,CAAC,IAAI,qBAAqB,CAAC,IAAI,YAAY,EAAE,CAAC;KAC/D,CAAC;AACH,CAAC","sourcesContent":["import { ErrorHandler, Provider } from '@angular/core';\n\n/**\n * Delegating {@link ErrorHandler} that reloads the app once when a lazy-loaded\n * chunk fails to load, and forwards every other error to an inner handler.\n *\n * After a deploy, the hash-named lazy chunks are replaced on the server. A tab\n * that was already open is still running an older `main.js` that references the\n * previous chunk hashes, so navigating to a lazy route fetches a chunk URL that\n * now 404s. Firebase Hosting's SPA rewrite then returns `index.html` for the\n * missing `.js`, and the browser throws a `ChunkLoadError` /\n * \"'text/html' is not a valid JavaScript MIME type\". A single full reload pulls\n * the current `index.html` + matching chunks and transparently recovers.\n *\n * Non-chunk errors are delegated unchanged, so existing error reporting (e.g.\n * the Sentry handler) keeps working. A short time-based guard (in\n * `sessionStorage`) prevents a reload loop when a chunk is genuinely broken.\n *\n * Alternative considered: an Angular service worker (ngsw) + `SwUpdate` would\n * largely *prevent* this by caching a consistent version set and prompting on a\n * new deploy. We deliberately do NOT add a service worker just for this — the\n * apps currently ship without one, and a SW brings its own caching/staleness\n * complexity. If a PWA service worker is adopted later (for offline/installable\n * support), this handler can stay as a cheap backstop.\n */\nexport class ChunkLoadErrorHandler implements ErrorHandler {\n\tprivate static readonly reloadKey = 'sneat:chunk-reload-at';\n\tprivate static readonly reloadGuardMs = 10_000;\n\n\tconstructor(private readonly delegate: ErrorHandler) {}\n\n\thandleError(error: unknown): void {\n\t\tif (\n\t\t\tChunkLoadErrorHandler.isChunkLoadError(error) &&\n\t\t\tthis.reloadOnceWithinGuard()\n\t\t) {\n\t\t\treturn;\n\t\t}\n\t\tthis.delegate.handleError(error);\n\t}\n\n\t/** Reloads at most once per guard window; returns true if a reload was triggered. */\n\tprivate reloadOnceWithinGuard(): boolean {\n\t\tlet lastReloadAt = 0;\n\t\ttry {\n\t\t\tlastReloadAt = Number(\n\t\t\t\tsessionStorage.getItem(ChunkLoadErrorHandler.reloadKey) ?? 0,\n\t\t\t);\n\t\t} catch {\n\t\t\t// sessionStorage may be unavailable (e.g. private mode) — fall through.\n\t\t}\n\t\tif (Date.now() - lastReloadAt <= ChunkLoadErrorHandler.reloadGuardMs) {\n\t\t\t// Reloaded very recently and still failing -> stop to avoid a loop.\n\t\t\treturn false;\n\t\t}\n\t\ttry {\n\t\t\tsessionStorage.setItem(\n\t\t\t\tChunkLoadErrorHandler.reloadKey,\n\t\t\t\tString(Date.now()),\n\t\t\t);\n\t\t} catch {\n\t\t\t// ignore storage failures; still attempt the reload below.\n\t\t}\n\t\tlocation.reload();\n\t\treturn true;\n\t}\n\n\tprivate static isChunkLoadError(error: unknown): boolean {\n\t\tconst err = error as { name?: string; message?: string } | null;\n\t\tconst name = err?.name ?? '';\n\t\tconst message = err?.message ?? String(error);\n\t\treturn (\n\t\t\tname === 'ChunkLoadError' ||\n\t\t\t/Failed to fetch dynamically imported module/i.test(message) ||\n\t\t\t/error loading dynamically imported module/i.test(message) ||\n\t\t\t/Loading chunk [\\w-]+ failed/i.test(message) ||\n\t\t\t/Importing a module script failed/i.test(message) ||\n\t\t\t/is not a valid JavaScript MIME type/i.test(message)\n\t\t);\n\t}\n}\n\n/**\n * Provides a baseline {@link ChunkLoadErrorHandler} wrapping Angular's default\n * `ErrorHandler`. Apps get this via `getStandardSneatProviders`. When Sentry is\n * configured its own (also chunk-aware) handler is provided later and wins; this\n * baseline covers apps without Sentry.\n */\nexport function provideChunkLoadErrorRecovery(): Provider {\n\treturn {\n\t\tprovide: ErrorHandler,\n\t\tuseFactory: () => new ChunkLoadErrorHandler(new ErrorHandler()),\n\t};\n}\n"]}

package/esm2022/lib/sentry-setup.js

@@ -1,6 +1,7 @@
 import { inject, provideAppInitializer, ErrorHandler } from '@angular/core';
 import { TraceService, init, createErrorHandler } from '@sentry/angular';
 import { Router } from '@angular/router';
+import { ChunkLoadErrorHandler } from './chunk-load-error.handler';
 export const provideSentryAppInitializer = (options) => {
     initSentry(options);
     return [
@@ -20,10 +21,12 @@ const sentryAppInitializerProviders = [
         deps: [Router],
     },
     {
+        // Recover from stale lazy-chunk loads after a deploy, delegating all other
+        // errors to Sentry's handler (see ChunkLoadErrorHandler doc).
         provide: ErrorHandler,
-        useValue: createErrorHandler({
+        useValue: new ChunkLoadErrorHandler(createErrorHandler({
             showDialog: true,
-        }),
+        })),
     },
 ];
 //# sourceMappingURL=sentry-setup.js.map

package/esm2022/lib/sentry-setup.js.map

@@ -1 +1 @@
-{"version":3,"file":"sentry-setup.js","sourceRoot":"","sources":["../../../../../libs/logging/src/lib/sentry-setup.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC5E,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACzE,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAGzC,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAAC,OAAuB,EAAE,EAAE;IACrE,UAAU,CAAC,OAAO,CAAC,CAAC;IACpB,OAAO;QACL,GAAG,6BAA6B;QAChC,qBAAqB,CAAC,GAAG,EAAE;YACzB,MAAM,CAAC,YAAY,CAAC,CAAC;QACvB,CAAC,CAAC;KACH,CAAC;AACJ,CAAC,CAAC;AAEF,SAAS,UAAU,CAAC,OAAuB;IACzC,+BAA+B;IAC/B,IAAI,CAAC,OAAO,CAAC,CAAC;AAChB,CAAC;AAED,MAAM,6BAA6B,GAAG;IACpC;QACE,OAAO,EAAE,YAAY;QACrB,IAAI,EAAE,CAAC,MAAM,CAAC;KACf;IACD;QACE,OAAO,EAAE,YAAY;QACrB,QAAQ,EAAE,kBAAkB,CAAC;YAC3B,UAAU,EAAE,IAAI;SACjB,CAAC;KACH;CACF,CAAC","sourcesContent":["import { inject, provideAppInitializer, ErrorHandler } from '@angular/core';\nimport { TraceService, init, createErrorHandler } from '@sentry/angular';\nimport { Router } from '@angular/router';\nimport { BrowserOptions } from '@sentry/browser';\n\nexport const provideSentryAppInitializer = (options: BrowserOptions) => {\n  initSentry(options);\n  return [\n    ...sentryAppInitializerProviders,\n    provideAppInitializer(() => {\n      inject(TraceService);\n    }),\n  ];\n};\n\nfunction initSentry(options: BrowserOptions): void {\n  // console.log('initSentry()');\n  init(options);\n}\n\nconst sentryAppInitializerProviders = [\n  {\n    provide: TraceService,\n    deps: [Router],\n  },\n  {\n    provide: ErrorHandler,\n    useValue: createErrorHandler({\n      showDialog: true,\n    }),\n  },\n];\n"]}
+{"version":3,"file":"sentry-setup.js","sourceRoot":"","sources":["../../../../../libs/logging/src/lib/sentry-setup.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC5E,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACzE,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAEnE,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAAC,OAAuB,EAAE,EAAE;IACrE,UAAU,CAAC,OAAO,CAAC,CAAC;IACpB,OAAO;QACL,GAAG,6BAA6B;QAChC,qBAAqB,CAAC,GAAG,EAAE;YACzB,MAAM,CAAC,YAAY,CAAC,CAAC;QACvB,CAAC,CAAC;KACH,CAAC;AACJ,CAAC,CAAC;AAEF,SAAS,UAAU,CAAC,OAAuB;IACzC,+BAA+B;IAC/B,IAAI,CAAC,OAAO,CAAC,CAAC;AAChB,CAAC;AAED,MAAM,6BAA6B,GAAG;IACpC;QACE,OAAO,EAAE,YAAY;QACrB,IAAI,EAAE,CAAC,MAAM,CAAC;KACf;IACD;QACE,2EAA2E;QAC3E,8DAA8D;QAC9D,OAAO,EAAE,YAAY;QACrB,QAAQ,EAAE,IAAI,qBAAqB,CACjC,kBAAkB,CAAC;YACjB,UAAU,EAAE,IAAI;SACjB,CAAC,CACH;KACF;CACF,CAAC","sourcesContent":["import { inject, provideAppInitializer, ErrorHandler } from '@angular/core';\nimport { TraceService, init, createErrorHandler } from '@sentry/angular';\nimport { Router } from '@angular/router';\nimport { BrowserOptions } from '@sentry/browser';\nimport { ChunkLoadErrorHandler } from './chunk-load-error.handler';\n\nexport const provideSentryAppInitializer = (options: BrowserOptions) => {\n  initSentry(options);\n  return [\n    ...sentryAppInitializerProviders,\n    provideAppInitializer(() => {\n      inject(TraceService);\n    }),\n  ];\n};\n\nfunction initSentry(options: BrowserOptions): void {\n  // console.log('initSentry()');\n  init(options);\n}\n\nconst sentryAppInitializerProviders = [\n  {\n    provide: TraceService,\n    deps: [Router],\n  },\n  {\n    // Recover from stale lazy-chunk loads after a deploy, delegating all other\n    // errors to Sentry's handler (see ChunkLoadErrorHandler doc).\n    provide: ErrorHandler,\n    useValue: new ChunkLoadErrorHandler(\n      createErrorHandler({\n        showDialog: true,\n      }),\n    ),\n  },\n];\n"]}

package/index.d.ts

@@ -1,3 +1,4 @@
 export * from './lib/sentry-setup';
+export * from './lib/chunk-load-error.handler';
 export * from './lib/sneat-logging.module';
 export * from './lib/analytics';

package/lib/chunk-load-error.handler.d.ts

@@ -0,0 +1,41 @@
+import { ErrorHandler, Provider } from '@angular/core';
+/**
+ * Delegating {@link ErrorHandler} that reloads the app once when a lazy-loaded
+ * chunk fails to load, and forwards every other error to an inner handler.
+ *
+ * After a deploy, the hash-named lazy chunks are replaced on the server. A tab
+ * that was already open is still running an older `main.js` that references the
+ * previous chunk hashes, so navigating to a lazy route fetches a chunk URL that
+ * now 404s. Firebase Hosting's SPA rewrite then returns `index.html` for the
+ * missing `.js`, and the browser throws a `ChunkLoadError` /
+ * "'text/html' is not a valid JavaScript MIME type". A single full reload pulls
+ * the current `index.html` + matching chunks and transparently recovers.
+ *
+ * Non-chunk errors are delegated unchanged, so existing error reporting (e.g.
+ * the Sentry handler) keeps working. A short time-based guard (in
+ * `sessionStorage`) prevents a reload loop when a chunk is genuinely broken.
+ *
+ * Alternative considered: an Angular service worker (ngsw) + `SwUpdate` would
+ * largely *prevent* this by caching a consistent version set and prompting on a
+ * new deploy. We deliberately do NOT add a service worker just for this — the
+ * apps currently ship without one, and a SW brings its own caching/staleness
+ * complexity. If a PWA service worker is adopted later (for offline/installable
+ * support), this handler can stay as a cheap backstop.
+ */
+export declare class ChunkLoadErrorHandler implements ErrorHandler {
+    private readonly delegate;
+    private static readonly reloadKey;
+    private static readonly reloadGuardMs;
+    constructor(delegate: ErrorHandler);
+    handleError(error: unknown): void;
+    /** Reloads at most once per guard window; returns true if a reload was triggered. */
+    private reloadOnceWithinGuard;
+    private static isChunkLoadError;
+}
+/**
+ * Provides a baseline {@link ChunkLoadErrorHandler} wrapping Angular's default
+ * `ErrorHandler`. Apps get this via `getStandardSneatProviders`. When Sentry is
+ * configured its own (also chunk-aware) handler is provided later and wins; this
+ * baseline covers apps without Sentry.
+ */
+export declare function provideChunkLoadErrorRecovery(): Provider;

package/lib/sentry-setup.d.ts

@@ -2,12 +2,13 @@ import { ErrorHandler } from '@angular/core';
 import { TraceService } from '@sentry/angular';
 import { Router } from '@angular/router';
 import { BrowserOptions } from '@sentry/browser';
+import { ChunkLoadErrorHandler } from './chunk-load-error.handler';
 export declare const provideSentryAppInitializer: (options: BrowserOptions) => ({
     provide: typeof TraceService;
     deps: (typeof Router)[];
     useValue?: undefined;
 } | {
     provide: typeof ErrorHandler;
-    useValue: import("@sentry/angular").SentryErrorHandler;
+    useValue: ChunkLoadErrorHandler;
     deps?: undefined;
 } | import("@angular/core").EnvironmentProviders)[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sneat/logging",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "publishConfig": {
     "access": "public"
   },