@keeex/utils 7.2.1 → 7.4.0

package/web/async/eventqueue.js

@@ -0,0 +1,126 @@
+/**
+ * @license
+ * @preserve
+ *
+ * MIT License
+ * 
+ * Copyright (c) 2023 KeeeX SAS
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ */
+import * as kxLog from "@keeex/log";
+/**
+ * Provides asynchronous handling of a sequential event queue.
+ *
+ * This should work as a regular sequential event queue, except that the handling of these events
+ * can be done using asynchronous functions.
+ * All handlers will be called on all input events in the order they came in, but there is no
+ * guarantee on the *order* of the event handlers when there is more than one.
+ *
+ * More events can be triggered while some events are processed, in which case they'll cause more
+ * calls to the handlers as needed.
+ */
+export class EventQueue {
+  #activeDispenser = null;
+  #closed = false;
+  #events = [];
+  #handlers = [];
+  #log;
+  #merger;
+  constructor(merger, logger = kxLog.createLogger({
+    tag: "EventQueue",
+    numbered: true
+  })) {
+    this.#log = logger;
+    this.#merger = merger;
+  }
+  addHandler = handler => {
+    this.#handlers.push(handler);
+  };
+  removeHandler = handler => {
+    const index = this.#handlers.indexOf(handler);
+    if (index !== -1) this.#handlers.splice(index, 1);
+  };
+  /**
+   * Cancel all pending events.
+   *
+   * Currently pending events that are not being processed are dropped.
+   * This does not prevent more events from being sent, and will not stop current processing.
+   */
+  cancelAll = () => {
+    this.#events.length = 0;
+  };
+  /**
+   * Disable all further event processing.
+   *
+   * This will not stop current processing.
+   */
+  close = (cancelAll = false) => {
+    this.#closed = true;
+    if (cancelAll) this.cancelAll();
+  };
+  /**
+   * Wait for all handlers to complete.
+   *
+   * If there are currently events being processed, this will wait until they are all processed.
+   * If more events show up while waiting, it will wait for those events to be processed too.
+   * If there are no events currently being processed, it will resolve immediately.
+   */
+  wait = () => this.#activeDispenser ?? Promise.resolve();
+  /** Trigger an event to be handled */
+  trigger = data => {
+    if (this.#closed) {
+      try {
+        this.#log.error("Received event while closed", data);
+      } catch {
+        this.#log.error("Received event while closed (can't display)");
+      }
+      return;
+    }
+    this.#events.push(data);
+    try {
+      this.#log.debug("Event trigger with data", data);
+    } catch {
+      this.#log.debug("Event trigger with data (can't display)");
+    }
+    this.#activeDispenser ??= this.#triggerAsync();
+  };
+  /** Call the event handlers sequentially on all buffered data */
+  #triggerAsync = async () => {
+    this.#log.debug("Dispensing events to handlers");
+    try {
+      // We could do this with recursive calls after instead, but there is no need for a deep stack
+      // trace for this.
+      while (this.#events.length > 0) {
+        // eslint-disable-next-line no-await-in-loop
+        const nextEvent = await this.#getNextEvent();
+        // eslint-disable-next-line no-await-in-loop
+        await Promise.all(this.#handlers.map(handler => handler(nextEvent)));
+        if (this.#events.length > 0) {
+          this.#log.debug("More events in queue");
+        }
+      }
+    } finally {
+      this.#log.debug("Done dispensing events");
+      this.#activeDispenser = null;
+    }
+  };
+  /** Return the next event to process */
+  #getNextEvent = async () => {
+    if (this.#events.length === 0) throw new Error("No more events to process");
+    if (this.#merger && this.#events.length > 1) {
+      this.#log.debug(`Merging ${this.#events.length} events into one`);
+      const allEvents = [...this.#events];
+      this.#events.length = 0;
+      const merged = await this.#merger(allEvents);
+      return merged;
+    }
+    const nextEvent = this.#events.shift();
+    return nextEvent;
+  };
+}

package/web/async/keycache.d.ts

@@ -13,7 +13,7 @@
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  * 
  */
-import { Awaitable } from "../types/types.js";
+import { type Awaitable } from "../types/types.js";
 /**
  * Function used to fill a cache entry on a cache miss.
  *

package/web/async/timecache.d.ts

@@ -13,7 +13,7 @@
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  * 
  */
-import { Awaitable } from "../types/types.js";
+import { type Awaitable } from "../types/types.js";
 /** Function used to refresh a timed cache */
 export type ProbeFunc<T> = () => Awaitable<T>;
 type HandlerFunc<T> = (error?: Error, value?: T) => void;

package/web/benchmark.d.ts

@@ -13,7 +13,7 @@
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  * 
  */
-import { Awaitable } from "./types/types.js";
+import { type Awaitable } from "./types/types.js";
 export type BenchmarkFunction = (() => Promise<void>) | (() => void);
 /**
  * Run the provided function for given iterations and return the average runtime in ms.

package/web/benchmark.js

@@ -13,7 +13,7 @@
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  * 
  */
-import { createLogger } from "@keeex/log";
+import * as kxLog from "@keeex/log";
 /** Return now() up to the best precision available */
 const getNow = typeof performance.now === "function" ? () => performance.now() : () => Date.now();
 /**
@@ -73,7 +73,7 @@ const addToAverageWindow = (value, window, len) => {
 };
 let logger = null;
 const getLogger = () => {
-  logger ??= createLogger({
+  logger ??= kxLog.createLogger({
     tag: "@keeex/js-utils:benchmark"
   });
   return logger;

package/web/bits/arraybuffer.js

@@ -23,7 +23,9 @@ import { b64EffectiveData, B64_PAD2, B64_PAD1, B64_PAD0, B64_CHARBLOCK } from ".
 export const getArrayBuffer = typedArray => {
   if (typedArray instanceof ArrayBuffer) return typedArray;
   const ab = typedArray.buffer;
-  if (typedArray.byteOffset === 0 && typedArray.byteLength === ab.byteLength) return ab;
+  if (typedArray.byteOffset === 0 && typedArray.byteLength === ab.byteLength) {
+    return ab;
+  }
   return ab.slice(typedArray.byteOffset, typedArray.byteOffset + typedArray.byteLength);
 };
 /**

package/web/bits/triggers/base.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @license
+ * @preserve
+ *
+ * MIT License
+ * 
+ * Copyright (c) 2023 KeeeX SAS
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ */
+import * as kxLog from "@keeex/log";
+import * as types from "./types.js";
+/**
+ * Base implementation for all triggers.
+ */
+export declare abstract class BaseTrigger implements types.Trigger {
+    #private;
+    constructor(handler: types.TriggerHandler, delayMs: number, logger?: kxLog.Logger | string);
+    protected get state(): types.TriggerState;
+    protected set state(value: types.TriggerState);
+    protected get logger(): kxLog.Logger;
+    abstract trigger(): void;
+    cancel: () => void;
+    stop: () => void;
+}

package/web/bits/triggers/base.js

@@ -0,0 +1,173 @@
+/**
+ * @license
+ * @preserve
+ *
+ * MIT License
+ * 
+ * Copyright (c) 2023 KeeeX SAS
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ */
+import * as kxLog from "@keeex/log";
+import { dropPromise } from "../../promise.js";
+import * as types from "./types.js";
+/**
+ * Base implementation for all triggers.
+ */
+export class BaseTrigger {
+  #state = types.TriggerState.inactive;
+  #timeout = null;
+  #delay;
+  #handler;
+  #logger;
+  constructor(handler, delayMs, logger) {
+    this.#handler = handler;
+    this.#delay = delayMs;
+    if (typeof logger === "string") {
+      this.#logger = kxLog.createLogger({
+        tag: logger,
+        numbered: true
+      });
+    } else if (logger) {
+      this.#logger = logger;
+    } else {
+      this.#logger = kxLog.createLogger({
+        tag: "PromiseTrigger",
+        numbered: true
+      });
+    }
+    this.#logger.debug(`Initialized with timer of ${delayMs}`);
+  }
+  get state() {
+    return this.#state;
+  }
+  set state(value) {
+    const oldState = this.#state;
+    this.#logger.debug(`State transition: ${oldState} → ${value}`);
+    this.#state = value;
+    switch (oldState) {
+      case types.TriggerState.inactive:
+        this.#stateFromInactive(value);
+        break;
+      case types.TriggerState.pending:
+        this.#stateFromPending(value);
+        break;
+      case types.TriggerState.running:
+        this.#stateFromRunning(value);
+        break;
+      case types.TriggerState.runningRetrigger:
+        this.#stateFromRunningRetrigger(value);
+        break;
+      case types.TriggerState.runningStop:
+        this.#stateFromRunningStop(value);
+        break;
+      case types.TriggerState.stop:
+        this.#stateFromStop(value);
+        break;
+    }
+  }
+  get logger() {
+    return this.#logger;
+  }
+  cancel = () => {
+    this.state = types.TriggerState.inactive;
+  };
+  stop = () => {
+    this.state = types.TriggerState.stop;
+  };
+  #stateFromInactive = value => {
+    switch (value) {
+      case types.TriggerState.pending:
+        this.#armTimeout();
+        break;
+      case types.TriggerState.running:
+      case types.TriggerState.runningRetrigger:
+        throw new Error("Cannot transition from inactive to running");
+    }
+  };
+  #stateFromPending = value => {
+    switch (value) {
+      case types.TriggerState.inactive:
+        this.#disarmTimeout();
+        break;
+      case types.TriggerState.running:
+        this.#timeout = null;
+        break;
+      case types.TriggerState.stop:
+        this.#disarmTimeout();
+        this.#runHandler();
+    }
+  };
+  #stateFromRunning = value => {
+    switch (value) {
+      case types.TriggerState.pending:
+        this.state = types.TriggerState.runningRetrigger;
+    }
+  };
+  #stateFromRunningRetrigger = value => {
+    switch (value) {
+      case types.TriggerState.inactive:
+        this.state = types.TriggerState.pending;
+        break;
+      case types.TriggerState.pending:
+        this.state = types.TriggerState.runningRetrigger;
+        break;
+      case types.TriggerState.running:
+        throw new Error("Cannot transition from retrigger to running");
+      case types.TriggerState.stop:
+        this.#runHandler();
+    }
+  };
+  #stateFromRunningStop = value => {
+    switch (value) {
+      case types.TriggerState.inactive:
+        this.state = types.TriggerState.stop;
+        break;
+      case types.TriggerState.pending:
+      case types.TriggerState.running:
+      case types.TriggerState.runningRetrigger:
+      case types.TriggerState.runningStop:
+        throw new Error("Invalid state transition from runningStop");
+    }
+  };
+  #stateFromStop = value => {
+    switch (value) {
+      case types.TriggerState.inactive:
+      case types.TriggerState.pending:
+      case types.TriggerState.runningRetrigger:
+        this.state = types.TriggerState.stop;
+        break;
+      case types.TriggerState.running:
+        this.state = types.TriggerState.runningStop;
+        break;
+    }
+  };
+  #armTimeout = () => {
+    this.#disarmTimeout();
+    this.#logger.debug("Arming timeout");
+    this.#timeout = setTimeout(this.#runHandler, this.#delay);
+  };
+  #disarmTimeout = () => {
+    if (this.#timeout === null) return;
+    this.#logger.debug("Disarming previous timeout");
+    clearTimeout(this.#timeout);
+    this.#timeout = null;
+  };
+  #runHandler = () => {
+    this.#logger.debug("Running handler");
+    this.state = types.TriggerState.running;
+    dropPromise(this.#runHandlerPromise, this.#logger);
+  };
+  #runHandlerPromise = async () => {
+    try {
+      await this.#handler();
+    } finally {
+      this.state = types.TriggerState.inactive;
+    }
+  };
+}

package/web/bits/triggers/debounce.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @license
+ * @preserve
+ *
+ * MIT License
+ * 
+ * Copyright (c) 2023 KeeeX SAS
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ */
+import { type Logger } from "@keeex/log";
+import { BaseTrigger } from "./base.js";
+import * as types from "./types.js";
+/**
+ * Debouncing trigger.
+ *
+ * Each time the trigger is triggered, the timer rearms itself, delaying the callback ever more.
+ * Once there is no trigger for the duration of the trigger, the callback is finally called.
+ *
+ * Useful for debouncing.
+ */
+export declare class DebounceTrigger extends BaseTrigger {
+    constructor(handler: types.TriggerHandler, delayMs: number, logger?: Logger | string);
+    trigger: () => void;
+}

package/web/bits/triggers/debounce.js

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * @preserve
+ *
+ * MIT License
+ * 
+ * Copyright (c) 2023 KeeeX SAS
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ */
+import { BaseTrigger } from "./base.js";
+import * as types from "./types.js";
+/**
+ * Debouncing trigger.
+ *
+ * Each time the trigger is triggered, the timer rearms itself, delaying the callback ever more.
+ * Once there is no trigger for the duration of the trigger, the callback is finally called.
+ *
+ * Useful for debouncing.
+ */
+export class DebounceTrigger extends BaseTrigger {
+  constructor(handler, delayMs, logger = "DebounceTrigger") {
+    super(handler, delayMs, logger);
+  }
+  trigger = () => {
+    if (this.state === types.TriggerState.pending) {
+      this.state = types.TriggerState.inactive;
+    }
+    this.state = types.TriggerState.pending;
+  };
+}

package/web/bits/triggers/grenade.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * @preserve
+ *
+ * MIT License
+ * 
+ * Copyright (c) 2023 KeeeX SAS
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ */
+import { type Logger } from "@keeex/log";
+import { BaseTrigger } from "./base.js";
+import * as types from "./types.js";
+/**
+ * Trigger that *will* fire its event after the time is elapsed, no matter how many times it is
+ * triggered afterward.
+ *
+ * After a call to `trigger()`, the timer is started.
+ * When it runs out, the even function is called.
+ * Multiple calls to `trigger()` will not delay the call, and they will not cause additional calls
+ * to occur.
+ * Calling `trigger()` while the callback is running will reschedule a call *after* the callback
+ * completes.
+ */
+export declare class GrenadeTrigger extends BaseTrigger {
+    constructor(handler: types.TriggerHandler, delayMs: number, logger?: Logger | string);
+    trigger: () => void;
+}

package/web/bits/triggers/grenade.js

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * @preserve
+ *
+ * MIT License
+ * 
+ * Copyright (c) 2023 KeeeX SAS
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ */
+import { BaseTrigger } from "./base.js";
+import * as types from "./types.js";
+/**
+ * Trigger that *will* fire its event after the time is elapsed, no matter how many times it is
+ * triggered afterward.
+ *
+ * After a call to `trigger()`, the timer is started.
+ * When it runs out, the even function is called.
+ * Multiple calls to `trigger()` will not delay the call, and they will not cause additional calls
+ * to occur.
+ * Calling `trigger()` while the callback is running will reschedule a call *after* the callback
+ * completes.
+ */
+export class GrenadeTrigger extends BaseTrigger {
+  constructor(handler, delayMs, logger = "GrenadeTrigger") {
+    super(handler, delayMs, logger);
+  }
+  trigger = () => {
+    this.logger.debug("Triggered");
+    this.state = types.TriggerState.pending;
+  };
+}

package/web/bits/triggers/types.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @license
+ * @preserve
+ *
+ * MIT License
+ * 
+ * Copyright (c) 2023 KeeeX SAS
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ */
+import { type Awaitable } from "../../types/types.js";
+export type TriggerHandler = () => Awaitable<void>;
+export declare enum TriggerState {
+    /** Trigger was not triggered */
+    inactive = "inactive",
+    /** Trigger was triggered, fuse timer is counting down */
+    pending = "pending",
+    /** Trigger was triggered and timer expired, the handler is running */
+    running = "running",
+    /** Handler is running, and trigger was called again */
+    runningRetrigger = "runningTrigger",
+    /** Last run after stop */
+    runningStop = "runningStop",
+    /** Handler is killed, will never run except for currently triggered call */
+    stop = "stop"
+}
+/** Generic interface for delayed triggers */
+export interface Trigger {
+    /** Call when the trigger should start (or restart, depending on the implementation) */
+    trigger: () => void;
+    /** Call when the trigger should be canceled */
+    cancel: () => void;
+    /**
+     * Call when the trigger should stop (it can't be triggered again).
+     * If there is an execution pending, it is run immediately.
+     */
+    stop: () => void;
+}

package/web/bits/triggers/types.js

@@ -0,0 +1,30 @@
+/**
+ * @license
+ * @preserve
+ *
+ * MIT License
+ * 
+ * Copyright (c) 2023 KeeeX SAS
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ */
+export var TriggerState;
+(function (TriggerState) {
+  /** Trigger was not triggered */
+  TriggerState["inactive"] = "inactive";
+  /** Trigger was triggered, fuse timer is counting down */
+  TriggerState["pending"] = "pending";
+  /** Trigger was triggered and timer expired, the handler is running */
+  TriggerState["running"] = "running";
+  /** Handler is running, and trigger was called again */
+  TriggerState["runningRetrigger"] = "runningTrigger";
+  /** Last run after stop */
+  TriggerState["runningStop"] = "runningStop";
+  /** Handler is killed, will never run except for currently triggered call */
+  TriggerState["stop"] = "stop";
+})(TriggerState || (TriggerState = {}));

package/web/cron.d.ts

@@ -13,9 +13,9 @@
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  * 
  */
-import { Logger } from "@keeex/log";
+import { type Logger } from "@keeex/log";
 import ScheduledTask from "./cron/scheduledtask.js";
-import { TaskFunction, TaskOptions, Overrun, CompleteTaskOptions } from "./cron/types.js";
+import { type TaskFunction, type TaskOptions, Overrun, type CompleteTaskOptions } from "./cron/types.js";
 export { Overrun };
 export type { ScheduledTask, TaskFunction, TaskOptions, CompleteTaskOptions };
 /**

package/web/marshalling/marshaller.d.ts

@@ -23,7 +23,7 @@ export default class Marshaller {
     private constructor();
     static readonly start: (magicNumbers?: string) => Marshaller;
     /** End building the buffer and returns the result */
-    readonly end: () => ArrayBuffer;
+    readonly end: () => Uint8Array;
     /** Append an utf-8 string */
     readonly str: (value: string) => this;
     /** Append a 32-bit unsigned int */