@steve31415/baselib 3.23.0 → 3.24.0

package/dist/log-browser.d.ts

@@ -11,5 +11,24 @@ export interface BrowserLoggerOptions {
     console?: boolean;
 }
 export declare function createBrowserLogger(opts?: BrowserLoggerOptions): Logger;
-/** Route uncaught errors and unhandled rejections into the logger. */
+/**
+ * Make the shared `logger` forward to `instance`. Call once at boot, right
+ * after createBrowserLogger; tests install a recorder.
+ */
+export declare function installBrowserLogger(instance: Logger | null): void;
+/**
+ * The page's logger, importable from any module — no threading a Logger
+ * through props and constructors. It forwards to the instance given to
+ * installBrowserLogger; before that (or in a test that installs none)
+ * events go to the devtools console rather than being lost.
+ */
+export declare const logger: Logger;
+/**
+ * Route uncaught errors, unhandled rejections, and failed resource loads
+ * (`<img>`, `<script>`, `<link>`, media) into the logger. A resource load
+ * failure fires a non-bubbling `error` on its element, which only a
+ * capturing window listener sees; it logs WARN while the browser reports
+ * itself online and INFO while offline (expected then), once per URL per
+ * page so a re-rendering broken element cannot flood the dataset.
+ */
 export declare function installGlobalErrorHandlers(logger: Logger): void;

package/dist/log-browser.js

@@ -79,11 +79,75 @@ export function createBrowserLogger(opts = {}) {
     });
     return logger;
 }
-/** Route uncaught errors and unhandled rejections into the logger. */
+let installed = null;
+/**
+ * Make the shared `logger` forward to `instance`. Call once at boot, right
+ * after createBrowserLogger; tests install a recorder.
+ */
+export function installBrowserLogger(instance) {
+    installed = instance;
+}
+const CONSOLE_METHOD = { debug: 'debug', info: 'log', warn: 'warn', error: 'error' };
+function forwardingLogger(context) {
+    const emit = (level, message, meta) => {
+        // Resolved per call, so a module-scope `logger.with(...)` taken before
+        // boot still ships once the app installs its logger.
+        if (installed)
+            (context ? installed.with(context) : installed)[level](message, meta);
+        else
+            console[CONSOLE_METHOD[level]](message, meta ?? '');
+    };
+    return {
+        debug: (m, meta) => emit('debug', m, meta),
+        info: (m, meta) => emit('info', m, meta),
+        warn: (m, meta) => emit('warn', m, meta),
+        error: (m, meta) => emit('error', m, meta),
+        with: (extra) => forwardingLogger({ ...context, ...extra }),
+        flush: () => installed?.flush() ?? Promise.resolve(),
+    };
+}
+/**
+ * The page's logger, importable from any module — no threading a Logger
+ * through props and constructors. It forwards to the instance given to
+ * installBrowserLogger; before that (or in a test that installs none)
+ * events go to the devtools console rather than being lost.
+ */
+export const logger = forwardingLogger(undefined);
+const MAX_RESOURCE_URL = 500;
+function resourceUrl(target) {
+    // The resolved (absolute) URL, as the browser requested it.
+    const element = target;
+    const url = element.currentSrc || element.src || element.href || '';
+    return url.length > MAX_RESOURCE_URL ? `${url.slice(0, MAX_RESOURCE_URL)}…` : url;
+}
+/**
+ * Route uncaught errors, unhandled rejections, and failed resource loads
+ * (`<img>`, `<script>`, `<link>`, media) into the logger. A resource load
+ * failure fires a non-bubbling `error` on its element, which only a
+ * capturing window listener sees; it logs WARN while the browser reports
+ * itself online and INFO while offline (expected then), once per URL per
+ * page so a re-rendering broken element cannot flood the dataset.
+ */
 export function installGlobalErrorHandlers(logger) {
+    const failedResources = new Set();
     addEventListener('error', (e) => {
-        logger.error('uncaught error', { error: e.error ?? e.message });
-    });
+        const target = e.target;
+        if (typeof Element !== 'undefined' && target instanceof Element) {
+            const url = resourceUrl(target);
+            if (failedResources.has(url))
+                return;
+            failedResources.add(url);
+            const online = navigator.onLine !== false;
+            logger[online ? 'warn' : 'info']('resource failed to load', {
+                element: target.tagName.toLowerCase(),
+                url,
+                online,
+            });
+            return;
+        }
+        const event = e;
+        logger.error('uncaught error', { error: event.error ?? event.message });
+    }, true);
     addEventListener('unhandledrejection', (e) => {
         logger.error('unhandled rejection', { error: e.reason });
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steve31415/baselib",
-  "version": "3.23.0",
+  "version": "3.24.0",
   "description": "Plasticine new-world shared platform library: logging, auth, service-to-service auth, db, HTTP, sync, app updates",
   "type": "module",
   "license": "MIT",