@trunkjs/browser-utils 1.0.15 → 1.0.17

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 1.0.17 (2025-09-11)
+
+This was a version bump only for browser-utils to align it with other projects, there were no code changes.
+
+## 1.0.16 (2025-08-27)
+
+This was a version bump only for browser-utils to align it with other projects, there were no code changes.
+
 ## 1.0.15 (2025-08-24)
 
 This was a version bump only for browser-utils to align it with other projects, there were no code changes.

package/README.md

@@ -9,29 +9,20 @@ Exports:
 - waitFor, waitForDomContentLoaded, waitForLoad, sleep, waitForAnimationEnd: Promise-based event and timing helpers
 - LoggingMixin: Lightweight logging mixin for Custom Elements
 
+- [Event Bindings  for WebComponents](./docs/README_EventHandling.md)
+
 ## Installation
 
 Within this monorepo, the package is consumed via path aliases. If you publish or consume it externally, import from the package name:
 
 ```ts
-import {
-  create_element,
-  Debouncer,
-  Stopwatch,
-  waitFor,
-  waitForDomContentLoaded,
-  waitForLoad,
-  sleep,
-  waitForAnimationEnd,
-  LoggingMixin,
-} from '@trunkjs/browser-utils';
+import { } from '@trunkjs/browser-utils';
 ```
 
-Note: Several utilities depend on browser globals (window, document, performance). Use them in browser-like environments.
 
 ## Quick start
 
-### Create and append an element
+### `function create_element()`: Create and append an element
 
 ```ts
 import { create_element } from '@trunkjs/browser-utils';
@@ -49,7 +40,7 @@ Notes:
 - Attributes with value true create boolean attributes (e.g. disabled becomes disabled="").
 - Attributes with null or undefined are omitted.
 
-### Debounce input handling
+### `class Debouncer`:Debounce input handling
 
 ```ts
 import { Debouncer } from '@trunkjs/browser-utils';
@@ -75,7 +66,7 @@ window.addEventListener('resize', () => {
 });
 ```
 
-### Measure performance with Stopwatch
+### `class Stopwatch`: Measure performance with Stopwatch
 
 ```ts
 import { Stopwatch } from '@trunkjs/browser-utils';
@@ -88,7 +79,7 @@ sw.lap('after step 2');
 console.debug('Total ms:', sw.stop());
 ```
 
-### Enable conditional logging in custom elements (LoggingMixin)
+### `class LoggingMixin`: Enable conditional logging in custom elements (LoggingMixin)
 
 ```ts
 import { LoggingMixin } from '@trunkjs/browser-utils';
@@ -113,7 +104,37 @@ customElements.define('my-el', MyEl);
 Tip:
 - If you toggle the debug attribute at runtime, call el.invalidateDebugCache() so the mixin re-evaluates the attribute on the next log/warn/error call.
 
-### Promise-based event helpers
+### `class EventBindingsMixin`: Auto-bind event listeners in custom elements
+
+This mixin handles automatic registration and removal of event listeners in custom elements. It uses the `@Listen` decorator to bind class methods to events on specified targets.
+
+It will register the events in connectedCallback and remove them in disconnectedCallback.
+
+```ts
+import { EventBindingsMixin } from '@trunkjs/browser-utils';
+import { Listen } from '@trunkjs/browser-utils';
+
+class MyEl extends EventBindingsMixin(HTMLElement) {
+    @Listen('click', { target: 'this' }) // listens to clicks on the element itself
+    onClick(event: MouseEvent) {
+        this.log('Element clicked', event);
+    }
+
+    @Listen('resize', { target: 'window' }) // listens to window resize events
+    onResize(event: UIEvent) {
+        this.log('Window resized', event);
+    }
+}
+```
+
+Target options:
+- 'host': the custom element itself
+- 'window': the global window object
+- 'document': the global document object
+- 'shadowRoot': the shadow root of the element (if any)
+- `(element) => EventTarget`: a function returning any EventTarget (e.g. another DOM element)
+
+### `async function waitForXYZ`: Promise-based event helpers
 
 ```ts
 import { waitFor, waitForDomContentLoaded, waitForLoad, sleep, waitForAnimationEnd } from '@trunkjs/browser-utils';
@@ -131,137 +152,7 @@ await sleep(250);
 await waitForAnimationEnd(document.querySelector('.animate')!);
 ```
 
-## API Reference
-
-### create_element(tag, attrs?, children?)
 
-- Signature:
-  - create_element(tag: string, attrs?: Record<string, string | true | null | undefined>, children?: (Node | string)[] | string | Node): HTMLElement
-- Behavior:
-  - Creates an element, sets provided attributes, and appends children.
-  - children can be a single Node/string or an array.
-  - Attribute values:
-    - true → renders as a boolean attribute with an empty value (e.g. disabled="")
-    - null/undefined → attribute is omitted
-    - string → sets the attribute to the given string
 
-Example:
-```ts
-create_element('input', { type: 'checkbox', checked: true });
-```
 
-### class Debouncer
-
-- constructor(delay: number, max_delay: number | false = false)
-  - delay: debounce window in ms
-  - max_delay: maximum time a call may be deferred. If false, no max is applied.
-- wait(): Promise<true>
-  - Returns a promise that resolves after delay ms since the last call.
-  - If max_delay is set and exceeded, the pending timer is not cleared and will resolve soon.
-- debounce(callback: () => void): void
-  - Schedules callback to run after delay ms since the last call.
-
-Use cases:
-- User input throttling (search boxes)
-- Resize or scroll handlers
-- Preventing excessive network calls
-
-### class Stopwatch
-
-- constructor(label: string, enabled: boolean = true)
-- lap(msg?: string): void
-  - Logs a lap line to console.debug in format: [label] msg +Xs
-- elapsed(): number
-  - Milliseconds since start
-- reset(): void
-- stop(): number
-  - Stops the stopwatch and returns elapsed ms
-- start(): void
-  - Starts (or restarts) and resets timings
-- isRunning(): boolean
-
-Notes:
-- Uses performance.now() for high-resolution timing
-- If enabled is false, lap is a no-op
-
-### LoggingMixin(Base)
-
-- Signature:
-  - LoggingMixin<TBase extends abstract new (...args: any[]) => object>(Base: TBase): class extends Base
-- Adds methods and properties to your Custom Element base class:
-  - log(...args: any[]): void
-    - Logs to console.log only when debug is enabled.
-  - warn(...args: any[]): void
-    - Always logs to console.warn (independent of debug).
-  - error(...args: any[]): void
-    - Always logs to console.error (independent of debug).
-  - get _debug(): boolean
-    - Indicates whether debug logging is enabled for the instance.
-  - invalidateDebugCache(): void
-    - Clears the cached debug flag. Call this after changing the debug attribute dynamically.
-
-How debug is determined:
-- On first call to log/warn/error, the mixin checks the element’s debug attribute and caches the result.
-- The attribute is considered truthy if present and not one of: "false", "0", "off", "no".
-  - Examples:
-    - <my-el debug></my-el> → debug ON
-    - <my-el debug="true"></my-el> → debug ON
-    - <my-el debug="false"></my-el> → debug OFF
-    - <my-el></my-el> → debug OFF
-- If you toggle the attribute at runtime, call invalidateDebugCache() so the next call re-evaluates it.
-
-Usage:
-```ts
-class MyEl extends LoggingMixin(HTMLElement) {
-  connectedCallback() {
-    this.log('connected');  // prints only if debug is ON
-    this.warn('warning');   // always prints
-    this.error('error');    // always prints
-  }
-}
-```
-
-### waitFor<T>(target, eventName, options?)
-
-- Signature:
-  - waitFor<T>(target: EventTarget, eventName: string, options?: AddEventListenerOptions): Promise<T>
-- Resolves with the event object T upon first occurrence.
-
-### waitForDomContentLoaded()
-
-- Resolves once the DOM is ready (DOMContentLoaded).
-- If the document is already past loading, resolves immediately.
-
-### waitForLoad()
-
-- Resolves once the window load event fires.
-- If the document is already complete, resolves immediately.
-
-### sleep(ms)
-
-- Signature: sleep(ms: number): Promise<void>
-- Resolves after the given delay.
-
-### waitForAnimationEnd(element)
-
-- Signature: waitForAnimationEnd(element: HTMLElement): Promise<AnimationEvent>
-- Resolves when the element fires animationend.
-
-## Building
-
-Run `nx build browser-utils` to build the library.
-
-The library is configured for:
-- ES module output
-- TypeScript declaration generation via vite-plugin-dts
-- Vite rollup bundling
-
-## Running unit tests
-
-Run `nx test browser-utils` to execute the unit tests via Vitest.
-
-## Notes and caveats
-
-- Environment: Some utilities require browser globals (window, document, performance). Use them in a DOM-capable environment (browser or a DOM-enabled test runner).
-- Types: Debouncer uses NodeJS.Timeout type in typings; in browsers, the runtime value is still a timeout handle and works as expected.
-- LoggingMixin: Designed for Custom Elements (HTMLElement or frameworks like Lit’s ReactiveElement). The debug attribute is cached for performance; call invalidateDebugCache() after toggling it dynamically. warn and error always log regardless of debug state.
+## API Reference

package/index.d.ts

@@ -1,7 +1,9 @@
+export * from './lib/breakpoints';
 export * from './lib/create-element';
 export * from './lib/Debouncer';
 export * from './lib/get-error-location';
 export * from './lib/Logger';
 export * from './lib/Stopwatch';
 export * from './lib/wait-for';
+export * from './mixins/EventBindingsMixin';
 export * from './mixins/LoggingMixin';

package/index.js

@@ -1,28 +1,51 @@
-var g = Object.defineProperty;
-var c = (t) => {
+var W = Object.defineProperty;
+var L = (t) => {
   throw TypeError(t);
 };
-var f = (t, e, n) => e in t ? g(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n;
-var l = (t, e, n) => f(t, typeof e != "symbol" ? e + "" : e, n), d = (t, e, n) => e.has(t) || c("Cannot " + n);
-var r = (t, e, n) => (d(t, e, "read from private field"), n ? n.call(t) : e.get(t)), u = (t, e, n) => e.has(t) ? c("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(t) : e.set(t, n), m = (t, e, n, i) => (d(t, e, "write to private field"), i ? i.call(t, n) : e.set(t, n), n);
-function E(t, e = {}, n = []) {
+var x = (t, e, n) => e in t ? W(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n;
+var u = (t, e, n) => x(t, typeof e != "symbol" ? e + "" : e, n), w = (t, e, n) => e.has(t) || L("Cannot " + n);
+var a = (t, e, n) => (w(t, e, "read from private field"), n ? n.call(t) : e.get(t)), l = (t, e, n) => e.has(t) ? L("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(t) : e.set(t, n), c = (t, e, n, i) => (w(t, e, "write to private field"), i ? i.call(t, n) : e.set(t, n), n), v = (t, e, n) => (w(t, e, "access private method"), n);
+const h = [
+  { name: "xs", minWidth: 0 },
+  { name: "sm", minWidth: 576 },
+  { name: "md", minWidth: 768 },
+  { name: "lg", minWidth: 992 },
+  { name: "xl", minWidth: 1200 },
+  { name: "xxl", minWidth: 1400 }
+], y = h.reduce(
+  (t, e) => (t[e.name] = e.minWidth, t),
+  {}
+);
+function P(t) {
+  if (!(t in y))
+    throw new Error(`Unknown breakpoint: ${t}`);
+  return y[t];
+}
+function B(t) {
+  t === void 0 && (t = window.innerWidth);
+  for (let e = h.length - 1; e >= 0; e--)
+    if (t >= h[e].minWidth)
+      return h[e].name;
+  return "xs";
+}
+function _(t, e = {}, n = []) {
   Array.isArray(n) || (n = [n]);
   const i = document.createElement(t);
-  for (const s in e)
-    e[s] !== null && e[s] !== void 0 && i.setAttribute(s, e[s] !== !0 ? e[s] : "");
-  for (const s of n)
-    i.append(typeof s == "string" ? document.createTextNode(s) : s);
+  for (const r in e)
+    e[r] !== null && e[r] !== void 0 && i.setAttribute(r, e[r] !== !0 ? e[r] : "");
+  for (const r of n)
+    i.append(typeof r == "string" ? document.createTextNode(r) : r);
   return i;
 }
-class y {
+class N {
   /**
    *
    * @param delay     Debounce delay in milliseconds
    * @param max_delay Maximum delay in milliseconds, if false then no maximum delay is applied
    */
   constructor(e, n = !1) {
-    l(this, "timeout", null);
-    l(this, "startTimeWithMs", 0);
+    u(this, "timeout", null);
+    u(this, "startTimeWithMs", 0);
     this.delay = e, this.max_delay = n;
   }
   async wait() {
@@ -38,7 +61,7 @@ class y {
     }, this.delay);
   }
 }
-function I(t) {
+function F(t) {
   if (typeof t.lineNumber == "number")
     return {
       file: t.fileName || t.sourceURL,
@@ -53,14 +76,14 @@ function I(t) {
     };
   const n = String(t.stack || t.message || "").split(`
 `), i = /(.*?)(?:\(|@)?(.*?):(\d+):(\d+)\)?$/;
-  for (const s of n) {
-    const a = s.match(i);
-    if (a)
-      return { file: a[2], line: +a[3], column: +a[4] };
+  for (const r of n) {
+    const s = r.match(i);
+    if (s)
+      return { file: s[2], line: +s[3], column: +s[4] };
   }
   return { file: t.fileName || t.sourceURL };
 }
-class w {
+class k {
   constructor(e, n, i = "main") {
     this._debug = e, this.myElementId = n, this.instanceId = i;
   }
@@ -78,13 +101,13 @@ class w {
     throw this.error(...e), new Error(n);
   }
 }
-class p {
+class O {
   constructor(e, n = !0) {
-    l(this, "label");
-    l(this, "last");
-    l(this, "startTime");
-    l(this, "running", !1);
-    l(this, "enabled");
+    u(this, "label");
+    u(this, "last");
+    u(this, "startTime");
+    u(this, "running", !1);
+    u(this, "enabled");
     this.label = e, this.enabled = n, this.startTime = this.last = performance.now(), this.running = !0;
   }
   lap(e = "") {
@@ -108,28 +131,38 @@ class p {
     return this.running;
   }
 }
-function T(t, e, n) {
-  return new Promise((i, s) => {
-    const a = (h) => {
-      t.removeEventListener(e, a, n), i(h);
+function S(t, e, n) {
+  return new Promise((i, r) => {
+    const s = (g) => {
+      t.removeEventListener(e, s, n), i(g);
     };
-    t.addEventListener(e, a, n);
+    t.addEventListener(e, s, n);
   });
 }
-function $() {
+function U() {
   return document.readyState === "loading" ? new Promise((t) => {
     document.addEventListener("DOMContentLoaded", () => t());
   }) : Promise.resolve();
 }
-function D() {
-  return document.readyState === "complete" ? Promise.resolve() : new Promise((t) => {
-    window.addEventListener("load", () => t());
+function H(t = null) {
+  if (t || (t = document), t instanceof Document) {
+    if (document.readyState === "complete")
+      return Promise.resolve();
+  } else if (t instanceof HTMLImageElement) {
+    if (t.complete)
+      return Promise.resolve();
+  } else if (t instanceof HTMLVideoElement || t instanceof HTMLAudioElement)
+    return t.readyState >= 3 ? Promise.resolve() : new Promise((e) => {
+      t.addEventListener("loadeddata", () => e(), { once: !0 });
+    });
+  return new Promise((e) => {
+    window.addEventListener("load", () => e());
   });
 }
-function v(t) {
+function G(t) {
   return new Promise((e) => setTimeout(e, t));
 }
-function R(t) {
+function j(t) {
   return new Promise((e) => {
     const n = (i) => {
       t.removeEventListener("animationend", n), e(i);
@@ -137,28 +170,80 @@ function R(t) {
     t.addEventListener("animationend", n);
   });
 }
-let b = 1;
-function x(t) {
-  var n, i, s;
+const f = Symbol("listenerDefs"), p = Symbol("withEventBindings");
+function V(t, e) {
+  const n = Array.isArray(t) ? t : [t];
+  return function(i, r) {
+    if (r.kind !== "method") throw new Error("@Listen nur für Methoden");
+    return r.addInitializer(function() {
+      const s = this.constructor;
+      (s[f] || (s[f] = [])).push({
+        method: r.name,
+        events: n,
+        opts: e
+      });
+    }), function(...s) {
+      if (!this[p])
+        throw new Error("[EventBindings] @Listen - decorator requires EventBindingMixin.");
+      return i.apply(this, s);
+    };
+  };
+}
+function A(t, e) {
+  var n;
+  return !e || e === "host" ? t : e === "document" ? t.ownerDocument ?? document : e === "window" ? ((n = t.ownerDocument) == null ? void 0 : n.defaultView) ?? window : e === "shadowRoot" ? t.shadowRoot ?? t : typeof e == "function" ? e(t) : e;
+}
+function q(t) {
+  var n, i, I;
+  class e extends t {
+    constructor(...o) {
+      super(...o);
+      l(this, i);
+      l(this, n);
+      this[p] = !0;
+    }
+    connectedCallback() {
+      var o;
+      (o = super.connectedCallback) == null || o.call(this), v(this, i, I).call(this);
+    }
+    disconnectedCallback() {
+      var o, d;
+      (o = a(this, n)) == null || o.abort(), (d = super.disconnectedCallback) == null || d.call(this);
+    }
+  }
+  return n = new WeakMap(), i = new WeakSet(), I = function() {
+    var d, b, E;
+    (d = a(this, n)) == null || d.abort(), c(this, n, new AbortController());
+    const o = this.constructor[f] || [];
+    for (const m of o) {
+      const T = A(this, (b = m.opts) == null ? void 0 : b.target), M = ((E = m.opts) == null ? void 0 : E.options) ?? {}, $ = this[m.method].bind(this);
+      for (const D of m.events)
+        T.addEventListener(D, $, { ...M, signal: a(this, n).signal });
+    }
+  }, e;
+}
+let R = 1;
+function z(t) {
+  var n, i, r;
   class e extends t {
     constructor() {
       super(...arguments);
-      u(this, n, null);
-      u(this, i, b++);
-      u(this, s, null);
+      l(this, n, null);
+      l(this, i, R++);
+      l(this, r, null);
     }
     /**
      * Clears the cached debug flag so the attribute will be checked again
      * on the next log/warn/error call.
      */
     invalidateDebugCache() {
-      m(this, n, null);
+      c(this, n, null);
     }
     get _debug() {
-      return r(this, n) !== null ? r(this, n) : (this instanceof HTMLElement && m(this, n, this.hasAttribute("debug") && !["false", "0", "off", "no"].includes(this.getAttribute("debug") || "")), r(this, n) === !0 && console.log(`[DEBUG][ID:${r(this, i)}] LoggingMixin: Debug mode is enabled for <${this.tagName}>`, this), r(this, n) ?? !1);
+      return a(this, n) !== null ? a(this, n) : (this instanceof HTMLElement && c(this, n, this.hasAttribute("debug") && !["false", "0", "off", "no"].includes(this.getAttribute("debug") || "")), a(this, n) === !0 && console.log(`[DEBUG][ID:${a(this, i)}] LoggingMixin: Debug mode is enabled for <${this.tagName}>`, this), a(this, n) ?? !1);
     }
     getLogger(o = "main") {
-      return r(this, s) || m(this, s, new w(this._debug, `${r(this, i)}`, o)), r(this, s);
+      return a(this, r) || c(this, r, new k(this._debug, `${a(this, i)}`, o)), a(this, r);
     }
     log(...o) {
       this.getLogger().log(...o);
@@ -173,18 +258,24 @@ function x(t) {
       return this.getLogger().throwError(...o);
     }
   }
-  return n = new WeakMap(), i = new WeakMap(), s = new WeakMap(), e;
+  return n = new WeakMap(), i = new WeakMap(), r = new WeakMap(), e;
 }
 export {
-  y as Debouncer,
-  w as Logger,
-  x as LoggingMixin,
-  p as Stopwatch,
-  E as create_element,
-  I as getErrorLocation,
-  v as sleep,
-  T as waitFor,
-  R as waitForAnimationEnd,
-  $ as waitForDomContentLoaded,
-  D as waitForLoad
+  N as Debouncer,
+  q as EventBindingsMixin,
+  V as Listen,
+  k as Logger,
+  z as LoggingMixin,
+  O as Stopwatch,
+  y as breakpointMap,
+  h as breakpoints,
+  _ as create_element,
+  P as getBreakpointMinWidth,
+  B as getCurrentBreakpoint,
+  F as getErrorLocation,
+  G as sleep,
+  S as waitFor,
+  j as waitForAnimationEnd,
+  U as waitForDomContentLoaded,
+  H as waitForLoad
 };

package/lib/breakpoints.d.ts

@@ -0,0 +1,24 @@
+export declare const breakpoints: readonly [{
+    readonly name: "xs";
+    readonly minWidth: 0;
+}, {
+    readonly name: "sm";
+    readonly minWidth: 576;
+}, {
+    readonly name: "md";
+    readonly minWidth: 768;
+}, {
+    readonly name: "lg";
+    readonly minWidth: 992;
+}, {
+    readonly name: "xl";
+    readonly minWidth: 1200;
+}, {
+    readonly name: "xxl";
+    readonly minWidth: 1400;
+}];
+export declare const breakpointMap: {
+    [key: string]: number;
+};
+export declare function getBreakpointMinWidth(breakpoint: string): number;
+export declare function getCurrentBreakpoint(width?: number): string;

package/lib/wait-for.d.ts

@@ -1,5 +1,16 @@
 export declare function waitFor<T>(target: EventTarget, eventName: string, options?: AddEventListenerOptions): Promise<T>;
 export declare function waitForDomContentLoaded(): Promise<void>;
-export declare function waitForLoad(): Promise<void>;
+/**
+ * Waits for the load event of the given element or the window if no element is provided.
+ *
+ * Hanles:
+ * - Document: waits for 'load' event if not already loaded
+ * - HTMLImageElement: waits for 'load' event if not already complete
+ * - HTMLVideoElement and HTMLAudioElement: waits for 'loadeddata' event if not
+ *
+ *
+ * @param element
+ */
+export declare function waitForLoad(element?: HTMLElement | Document | null): Promise<void>;
 export declare function sleep(ms: number): Promise<void>;
 export declare function waitForAnimationEnd(element: HTMLElement): Promise<AnimationEvent>;

package/mixins/EventBindingsMixin.d.ts

@@ -0,0 +1,17 @@
+type Ctor<T = object> = new (...args: any[]) => T;
+type TargetSpec = 'host' | 'document' | 'window' | 'shadowRoot' | EventTarget | ((host: HTMLElement) => EventTarget);
+type ListenOpts = {
+    target?: TargetSpec;
+    options?: AddEventListenerOptions;
+};
+type EventName = keyof DocumentEventMap;
+type OneOrMany<N extends EventName> = N | readonly N[];
+type EventFromInput<I extends OneOrMany<EventName>> = I extends readonly (infer K)[] ? K extends EventName ? DocumentEventMap[K] : never : I extends EventName ? DocumentEventMap[I] : never;
+export declare function Listen<I extends OneOrMany<EventName>>(type: I, opts?: ListenOpts): <This, Fn extends (this: This, ev: EventFromInput<I>, ...args: any[]) => any>(value: Fn, context: ClassMethodDecoratorContext<This, Fn>) => Fn;
+export declare function EventBindingsMixin<TBase extends Ctor<object>>(Base: TBase): (abstract new (...a: any[]) => {
+    "__#2347@#ac"?: AbortController;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    "__#2347@#bindEventListeners"(): void;
+}) & TBase;
+export {};

package/mixins/LoggingMixin.d.ts

@@ -26,14 +26,14 @@ type Constructor<T = object> = abstract new (...args: any[]) => T;
  *   <my-element debug></my-element>       // enables debug logging
  */
 export declare function LoggingMixin<TBase extends Constructor<object>>(Base: TBase): (abstract new (...args: any[]) => {
-    "__#1729@#debugCached": boolean | null;
-    "__#1729@#myElementId": number;
+    "__#2348@#debugCached": boolean | null;
+    "__#2348@#myElementId": number;
     /**
      * Clears the cached debug flag so the attribute will be checked again
      * on the next log/warn/error call.
      */
     invalidateDebugCache(): void;
-    "__#1729@#myLoggerInstance": Logger | null;
+    "__#2348@#myLoggerInstance": Logger | null;
     readonly _debug: boolean;
     getLogger(instanceId?: string): Logger;
     log(...args: any[]): void;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@trunkjs/browser-utils",
-    "version": "1.0.15",
+    "version": "1.0.17",
     "main": "./index.js",
     "dependencies": {},
     "type": "module",