@sv443-network/coreutils 3.5.0 → 3.6.0

package/dist/CoreUtils.umd.js

@@ -85,6 +85,7 @@ __export(lib_exports, {
   formatNumber: () => formatNumber,
   getCallStack: () => getCallStack,
   getListLength: () => getListLength,
+  getterifyObj: () => getterifyObj,
   hexToRgb: () => hexToRgb,
   insertValues: () => insertValues,
   joinArrayReadable: () => joinArrayReadable,
@@ -397,12 +398,12 @@ var NetworkError = class extends DatedError {
 };
 
 // lib/misc.ts
-async function consumeGen(valGen) {
-  return await (typeof valGen === "function" ? valGen() : valGen);
+async function consumeGen(valGen, ...args) {
+  return await (typeof valGen === "function" ? valGen(...args) : valGen);
 }
-async function consumeStringGen(strGen) {
+async function consumeStringGen(strGen, ...args) {
   return typeof strGen === "string" ? strGen : String(
-    typeof strGen === "function" ? await strGen() : strGen
+    typeof strGen === "function" ? await strGen(...args) : strGen
   );
 }
 async function fetchAdvanced(input, options = {}) {
@@ -441,6 +442,17 @@ function pauseFor(time, signal, rejectOnAbort = false) {
 function pureObj(obj) {
   return Object.assign(/* @__PURE__ */ Object.create(null), obj ?? {});
 }
+function getterifyObj(obj, asCopy = false) {
+  const newObj = {};
+  for (const key in obj) {
+    Object.defineProperty(newObj, key, {
+      get: () => obj[key],
+      enumerable: true,
+      configurable: true
+    });
+  }
+  return asCopy ? structuredClone(newObj) : newObj;
+}
 function setImmediateInterval(callback, interval, signal) {
   let intervalId;
   const cleanup = () => clearInterval(intervalId);
@@ -799,6 +811,8 @@ var NanoEmitter = class {
   events = createNanoEvents();
   eventUnsubscribes = [];
   emitterOptions;
+  /** Stores the last arguments for each event listed in `catchUpEvents` */
+  catchUpMemory = /* @__PURE__ */ new Map();
   /** Creates a new instance of NanoEmitter - a lightweight event emitter with helper methods and a strongly typed event map */
   constructor(options = {}) {
     this.emitterOptions = {
@@ -806,6 +820,18 @@ var NanoEmitter = class {
       ...options
     };
   }
+  //#region emitEvent
+  /**
+   * Emits an event on this instance, bypassing the `publicEmit` guard.
+   * Prefer this over `this.events.emit()` in subclasses — it updates catch-up memory
+   * for any event listed in `catchUpEvents` so late listeners can still receive the last value.
+   */
+  emitEvent(event, ...args) {
+    var _a;
+    if ((_a = this.emitterOptions.catchUpEvents) == null ? void 0 : _a.includes(event))
+      this.catchUpMemory.set(event, args);
+    this.events.emit(event, ...args);
+  }
   //#region on
   /**
    * Subscribes to an event and calls the callback when it's emitted.  
@@ -838,6 +864,9 @@ var NanoEmitter = class {
     };
     unsub = this.events.on(event, cb);
     this.eventUnsubscribes.push(unsub);
+    const memory = this.catchUpMemory.get(event);
+    if (memory)
+      cb(...memory);
     return unsubProxy;
   }
   //#region once
@@ -860,6 +889,12 @@ var NanoEmitter = class {
    * ```
    */
   once(event, cb) {
+    const memory = this.catchUpMemory.get(event);
+    if (memory) {
+      const args = memory;
+      cb == null ? void 0 : cb(...args);
+      return Promise.resolve(args);
+    }
     return new Promise((resolve) => {
       let unsub;
       const onceProxy = ((...args) => {
@@ -961,7 +996,7 @@ var NanoEmitter = class {
    */
   emit(event, ...args) {
     if (this.emitterOptions.publicEmit) {
-      this.events.emit(event, ...args);
+      this.emitEvent(event, ...args);
       return true;
     }
     return false;
@@ -1084,7 +1119,7 @@ var DataStore = class extends NanoEmitter {
       if (typeof storedDataRaw !== "string" && typeof storedDataRaw !== "object" || storedDataRaw === null || isNaN(storedFmtVer)) {
         await this.saveDefaultData(false);
         const data = this.engine.deepCopy(this.defaultData);
-        this.events.emit("loadData", data);
+        this.emitEvent("loadData", data);
         return data;
       }
       const storedData = storedDataRaw ?? JSON.stringify(this.defaultData);
@@ -1094,12 +1129,12 @@ var DataStore = class extends NanoEmitter {
       if (storedFmtVer < this.formatVersion && this.migrations)
         parsed = await this.runMigrations(parsed, storedFmtVer);
       const result = this.memoryCache ? this.cachedData = this.engine.deepCopy(parsed) : this.engine.deepCopy(parsed);
-      this.events.emit("loadData", result);
+      this.emitEvent("loadData", result);
       return result;
     } catch (err) {
       const error = err instanceof Error ? err : new Error(String(err));
       console.warn("Error while parsing JSON data, resetting it to the default value.", err);
-      this.events.emit("error", error);
+      this.emitEvent("error", error);
       await this.saveDefaultData();
       return this.defaultData;
     }
@@ -1121,7 +1156,7 @@ var DataStore = class extends NanoEmitter {
     const dataCopy = this.engine.deepCopy(data);
     if (this.memoryCache) {
       this.cachedData = data;
-      this.events.emit("updateDataSync", dataCopy);
+      this.emitEvent("updateDataSync", dataCopy);
     }
     return new Promise(async (resolve) => {
       const results = await Promise.allSettled([
@@ -1130,11 +1165,11 @@ var DataStore = class extends NanoEmitter {
         this.engine.setValue(`${this.keyPrefix}${this.id}-enf`, this.compressionFormat)
       ]);
       if (results.every((r) => r.status === "fulfilled"))
-        this.events.emit("updateData", dataCopy);
+        this.emitEvent("updateData", dataCopy);
       else {
         const error = new Error("Error while saving data to persistent storage: " + results.map((r) => r.status === "rejected" ? r.reason : null).filter(Boolean).join("; "));
         console.error(error);
-        this.events.emit("error", error);
+        this.emitEvent("error", error);
       }
       resolve();
     });
@@ -1153,11 +1188,11 @@ var DataStore = class extends NanoEmitter {
       this.engine.setValue(`${this.keyPrefix}${this.id}-enf`, this.compressionFormat)
     ]);
     if (results.every((r) => r.status === "fulfilled"))
-      emitEvent && this.events.emit("setDefaultData", this.defaultData);
+      emitEvent && this.emitEvent("setDefaultData", this.defaultData);
     else {
       const error = new Error("Error while saving default data to persistent storage: " + results.map((r) => r.status === "rejected" ? r.reason : null).filter(Boolean).join("; "));
       console.error(error);
-      this.events.emit("error", error);
+      this.emitEvent("error", error);
     }
   }
   //#region deleteData
@@ -1174,7 +1209,7 @@ var DataStore = class extends NanoEmitter {
       this.engine.deleteValue(`${this.keyPrefix}${this.id}-enf`)
     ]);
     await ((_b = (_a = this.engine).deleteStorage) == null ? void 0 : _b.call(_a));
-    this.events.emit("deleteData");
+    this.emitEvent("deleteData");
   }
   //#region encodingEnabled
   /** Returns whether encoding and decoding are enabled for this DataStore instance */
@@ -1204,11 +1239,11 @@ var DataStore = class extends NanoEmitter {
           newData = migRes instanceof Promise ? await migRes : migRes;
           lastFmtVer = oldFmtVer = ver;
           const isFinal = ver >= this.formatVersion || i === sortedMigrations.length - 1;
-          this.events.emit("migrateData", ver, newData, isFinal);
+          this.emitEvent("migrateData", ver, newData, isFinal);
         } catch (err) {
           const migError = new MigrationError(`Error while running migration function for format version '${fmtVer}'`, { cause: err });
-          this.events.emit("migrationError", ver, migError);
-          this.events.emit("error", migError);
+          this.emitEvent("migrationError", ver, migError);
+          this.emitEvent("error", migError);
           if (!resetOnError)
             throw migError;
           await this.saveDefaultData();
@@ -1222,7 +1257,7 @@ var DataStore = class extends NanoEmitter {
       this.engine.setValue(`${this.keyPrefix}${this.id}-enf`, this.compressionFormat)
     ]);
     const result = this.memoryCache ? this.cachedData = this.engine.deepCopy(newData) : this.engine.deepCopy(newData);
-    this.events.emit("updateData", result);
+    this.emitEvent("updateData", result);
     return result;
   }
   //#region migrateId
@@ -1252,7 +1287,7 @@ var DataStore = class extends NanoEmitter {
         this.engine.deleteValue(`${this.keyPrefix}${id}-ver`),
         this.engine.deleteValue(`${this.keyPrefix}${id}-enf`)
       ]);
-      this.events.emit("migrateId", id, this.id);
+      this.emitEvent("migrateId", id, this.id);
     }));
   }
 };
@@ -1495,15 +1530,20 @@ var DataStoreSerializer = class _DataStoreSerializer {
       addChecksum: true,
       ensureIntegrity: true,
       remapIds: {},
+      stringifyData: true,
       ...options
     };
   }
   /**
-   * Calculates the checksum of a string. Uses {@linkcode computeHash()} with SHA-256 and digests as a hex string by default.  
+   * Calculates the checksum of a string or {@linkcode DataStoreData} object. Uses {@linkcode computeHash()} with SHA-256 and digests as a hex string by default.  
    * Override this in a subclass if a custom checksum method is needed.
    */
   async calcChecksum(input) {
-    return computeHash(input, "SHA-256");
+    try {
+      return computeHash(typeof input === "string" ? input : JSON.stringify(input), "SHA-256");
+    } catch (err) {
+      throw new Error(`Failed to calculate checksum: ${err.message}`, { cause: err });
+    }
   }
   /**
    * Serializes only a subset of the data stores into a string.  
@@ -1518,7 +1558,7 @@ var DataStoreSerializer = class _DataStoreSerializer {
     for (const storeInst of filteredStores) {
       const encoded = Boolean(useEncoding && storeInst.encodingEnabled() && ((_a = storeInst.encodeData) == null ? void 0 : _a[1]));
       const rawData = storeInst.memoryCache ? storeInst.getData() : await storeInst.loadData();
-      const data = encoded ? await storeInst.encodeData[1](JSON.stringify(rawData)) : JSON.stringify(rawData);
+      const data = encoded ? await storeInst.encodeData[1](JSON.stringify(rawData)) : this.options.stringifyData ? JSON.stringify(rawData) : rawData;
       serData.push({
         id: storeInst.id,
         data,
@@ -1564,11 +1604,11 @@ var DataStoreSerializer = class _DataStoreSerializer {
 Expected: ${storeData.checksum}
 Has: ${checksum}`);
       }
-      const decodedData = storeData.encoded && storeInst.encodingEnabled() ? await storeInst.decodeData[1](storeData.data) : storeData.data;
+      const decodedData = storeData.encoded && storeInst.encodingEnabled() ? await storeInst.decodeData[1](typeof storeData.data === "string" ? storeData.data : JSON.stringify(storeData.data)) : storeData.data;
       if (storeData.formatVersion && !isNaN(Number(storeData.formatVersion)) && Number(storeData.formatVersion) < storeInst.formatVersion)
-        await storeInst.runMigrations(JSON.parse(decodedData), Number(storeData.formatVersion), false);
+        await storeInst.runMigrations(typeof decodedData === "string" ? JSON.parse(decodedData) : decodedData, Number(storeData.formatVersion), false);
       else
-        await storeInst.setData(JSON.parse(decodedData));
+        await storeInst.setData(typeof decodedData === "string" ? JSON.parse(decodedData) : decodedData);
     }
   }
   /**
@@ -1637,6 +1677,8 @@ var Debouncer = class extends NanoEmitter {
     this.timeout = timeout;
     this.type = type;
   }
+  timeout;
+  type;
   /** All registered listener functions and the time they were attached */
   listeners = [];
   /** The currently active timeout */
@@ -1664,7 +1706,7 @@ var Debouncer = class extends NanoEmitter {
   //#region timeout
   /** Sets the timeout for the debouncer */
   setTimeout(timeout) {
-    this.events.emit("change", this.timeout = timeout, this.type);
+    this.emitEvent("change", this.timeout = timeout, this.type);
   }
   /** Returns the current timeout */
   getTimeout() {
@@ -1677,7 +1719,7 @@ var Debouncer = class extends NanoEmitter {
   //#region type
   /** Sets the edge type for the debouncer */
   setType(type) {
-    this.events.emit("change", this.timeout, this.type = type);
+    this.emitEvent("change", this.timeout, this.type = type);
   }
   /** Returns the current edge type */
   getType() {
@@ -1688,7 +1730,7 @@ var Debouncer = class extends NanoEmitter {
   call(...args) {
     const cl = (...a) => {
       this.queuedCall = void 0;
-      this.events.emit("call", ...a);
+      this.emitEvent("call", ...a);
       this.listeners.forEach((l) => l.call(this, ...a));
     };
     const setRepeatTimeout = () => {
@@ -1728,166 +1770,7 @@ function debounce(fn, timeout = 200, type = "immediate", nanoEmitterOptions) {
   func.debouncer = debouncer;
   return func;
 }
-sistent data of the DataStore instances into the in-memory cache.  
-   * Also triggers the migration process if the data format has changed.
-   * @param stores An array of store IDs or a function that takes the store IDs and returns a boolean - if omitted, all stores will be loaded
-   * @returns Returns a PromiseSettledResult array with the results of each DataStore instance in the format `{ id: string, data: object }`
-   */
-  loadStoresData(stores) {
-    return __async(this, null, function* () {
-      return Promise.allSettled(
-        this.getStoresFiltered(stores).map((store) => __async(this, null, function* () {
-          return {
-            id: store.id,
-            data: yield store.loadData()
-          };
-        }))
-      );
-    });
-  }
-  /**
-   * Resets the persistent and in-memory data of the DataStore instances to their default values.
-   * @param stores An array of store IDs or a function that takes the store IDs and returns a boolean - if omitted, all stores will be affected
-   */
-  resetStoresData(stores) {
-    return __async(this, null, function* () {
-      return Promise.allSettled(
-        this.getStoresFiltered(stores).map((store) => store.saveDefaultData())
-      );
-    });
-  }
-  /**
-   * Deletes the persistent data of the DataStore instances.  
-   * Leaves the in-memory data untouched.  
-   * @param stores An array of store IDs or a function that takes the store IDs and returns a boolean - if omitted, all stores will be affected
-   */
-  deleteStoresData(stores) {
-    return __async(this, null, function* () {
-      return Promise.allSettled(
-        this.getStoresFiltered(stores).map((store) => store.deleteData())
-      );
-    });
-  }
-  /** Checks if a given value is an array of SerializedDataStore objects */
-  static isSerializedDataStoreObjArray(obj) {
-    return Array.isArray(obj) && obj.every((o) => typeof o === "object" && o !== null && "id" in o && "data" in o && "formatVersion" in o && "encoded" in o);
-  }
-  /** Checks if a given value is a SerializedDataStore object */
-  static isSerializedDataStoreObj(obj) {
-    return typeof obj === "object" && obj !== null && "id" in obj && "data" in obj && "formatVersion" in obj && "encoded" in obj;
-  }
-  /** Returns the DataStore instances whose IDs match the provided array or function */
-  getStoresFiltered(stores) {
-    return this.stores.filter((s) => typeof stores === "undefined" ? true : Array.isArray(stores) ? stores.includes(s.id) : stores(s.id));
-  }
-};
 
-// lib/Debouncer.ts
-var Debouncer = class extends NanoEmitter {
-  /**
-   * Creates a new debouncer with the specified timeout and edge type.
-   * @param timeout Timeout in milliseconds between letting through calls - defaults to 200
-   * @param type The edge type to use for the debouncer - see {@linkcode DebouncerType} for details or [the documentation for an explanation and diagram](https://github.com/Sv443-Network/UserUtils/blob/main/docs.md#debouncer) - defaults to "immediate"
-   */
-  constructor(timeout = 200, type = "immediate", nanoEmitterOptions) {
-    super(nanoEmitterOptions);
-    this.timeout = timeout;
-    this.type = type;
-    /** All registered listener functions and the time they were attached */
-    __publicField(this, "listeners", []);
-    /** The currently active timeout */
-    __publicField(this, "activeTimeout");
-    /** The latest queued call */
-    __publicField(this, "queuedCall");
-  }
-  //#region listeners
-  /** Adds a listener function that will be called on timeout */
-  addListener(fn) {
-    this.listeners.push(fn);
-  }
-  /** Removes the listener with the specified function reference */
-  removeListener(fn) {
-    const idx = this.listeners.findIndex((l) => l === fn);
-    idx !== -1 && this.listeners.splice(idx, 1);
-  }
-  /** Removes all listeners */
-  removeAllListeners() {
-    this.listeners = [];
-  }
-  /** Returns all registered listeners */
-  getListeners() {
-    return this.listeners;
-  }
-  //#region timeout
-  /** Sets the timeout for the debouncer */
-  setTimeout(timeout) {
-    this.events.emit("change", this.timeout = timeout, this.type);
-  }
-  /** Returns the current timeout */
-  getTimeout() {
-    return this.timeout;
-  }
-  /** Whether the timeout is currently active, meaning any latest call to the {@linkcode call()} method will be queued */
-  isTimeoutActive() {
-    return typeof this.activeTimeout !== "undefined";
-  }
-  //#region type
-  /** Sets the edge type for the debouncer */
-  setType(type) {
-    this.events.emit("change", this.timeout, this.type = type);
-  }
-  /** Returns the current edge type */
-  getType() {
-    return this.type;
-  }
-  //#region call
-  /** Use this to call the debouncer with the specified arguments that will be passed to all listener functions registered with {@linkcode addListener()} */
-  call(...args) {
-    const cl = (...a) => {
-      this.queuedCall = void 0;
-      this.events.emit("call", ...a);
-      this.listeners.forEach((l) => l.call(this, ...a));
-    };
-    const setRepeatTimeout = () => {
-      this.activeTimeout = setTimeout(() => {
-        if (this.queuedCall) {
-          this.queuedCall();
-          setRepeatTimeout();
-        } else
-          this.activeTimeout = void 0;
-      }, this.timeout);
-    };
-    switch (this.type) {
-      case "immediate":
-        if (typeof this.activeTimeout === "undefined") {
-          cl(...args);
-          setRepeatTimeout();
-        } else
-          this.queuedCall = () => cl(...args);
-        break;
-      case "idle":
-        if (this.activeTimeout)
-          clearTimeout(this.activeTimeout);
-        this.activeTimeout = setTimeout(() => {
-          cl(...args);
-          this.activeTimeout = void 0;
-        }, this.timeout);
-        break;
-      default:
-        throw new TypeError(`Invalid debouncer type: ${this.type}`);
-    }
-  }
-};
-function debounce(fn, timeout = 200, type = "immediate", nanoEmitterOptions) {
-  const debouncer = new Debouncer(timeout, type, nanoEmitterOptions);
-  debouncer.addListener(fn);
-  const func = ((...args) => debouncer.call(...args));
-  func.debouncer = debouncer;
-  return func;
-}
-
-if(__exports != exports)module.exports = exports;return module.exports}));
-//# sourceMappingURL=CoreUtils.umd.js.map
 
 
 if (typeof module.exports == "object" && typeof exports == "object") {

package/dist/lib/DataStoreSerializer.d.ts

@@ -2,7 +2,7 @@
  * @module DataStoreSerializer  
  * This module contains the DataStoreSerializer class, which allows you to import and export serialized DataStore data - [see the documentation for more info](https://github.com/Sv443-Network/UserUtils/blob/main/docs.md#datastoreserializer)  
  */
-import type { DataStore } from "./DataStore.ts";
+import type { DataStore, DataStoreData } from "./DataStore.ts";
 /** Options for the DataStoreSerializer class */
 export type DataStoreSerializerOptions = {
     /** Whether to add a checksum to the exported data. Defaults to `true` */
@@ -11,13 +11,18 @@ export type DataStoreSerializerOptions = {
     ensureIntegrity?: boolean;
     /** If provided, all stores with an ID in the value's array will be remapped to the key's ID when deserialization is called. If they don't match a DataStore instance's ID, nothing will happen. */
     remapIds?: Record<string, string[]>;
+    /**
+     * Controls the type of the `data` property on {@linkcode SerializedDataStore} objects.  
+     * When this is set to `false`, `data` will be the raw data object instead of a string, regardless of whether {@linkcode DataStoreSerializer.serialize()} or {@linkcode DataStoreSerializer.serializePartial()} are called with their `stringify` / `stringified` parameter set to `true` or `false`.  
+     */
+    stringifyData?: boolean;
 };
 /** Meta object and serialized data of a DataStore instance */
-export type SerializedDataStore = {
+export type SerializedDataStore<TData extends string | DataStoreData = string> = {
     /** The ID of the DataStore instance */
     id: string;
     /** The serialized data */
-    data: string;
+    data: TData;
     /** The format version of the data */
     formatVersion: number;
     /** Whether the data is encoded */
@@ -48,10 +53,10 @@ export declare class DataStoreSerializer {
     protected options: Required<DataStoreSerializerOptions>;
     constructor(stores: DataStore<any, boolean>[], options?: DataStoreSerializerOptions);
     /**
-     * Calculates the checksum of a string. Uses {@linkcode computeHash()} with SHA-256 and digests as a hex string by default.  
+     * Calculates the checksum of a string or {@linkcode DataStoreData} object. Uses {@linkcode computeHash()} with SHA-256 and digests as a hex string by default.  
      * Override this in a subclass if a custom checksum method is needed.  
      */
-    protected calcChecksum(input: string): Promise<string>;
+    protected calcChecksum(input: string | DataStoreData): Promise<string>;
     /**
      * Serializes only a subset of the data stores into a string.  
      * @param stores An array of store IDs or functions that take a store ID and return a boolean  
@@ -65,14 +70,14 @@ export declare class DataStoreSerializer {
      * @param useEncoding Whether to encode the data using each DataStore's `encodeData()` method  
      * @param stringified Whether to return the result as a string or as an array of `SerializedDataStore` objects  
      */
-    serializePartial(stores: StoreFilter, useEncoding?: boolean, stringified?: false): Promise<SerializedDataStore[]>;
+    serializePartial(stores: StoreFilter, useEncoding?: boolean, stringified?: false): Promise<SerializedDataStore<string | DataStoreData>[]>;
     /**
      * Serializes only a subset of the data stores into a string.  
      * @param stores An array of store IDs or functions that take a store ID and return a boolean  
      * @param useEncoding Whether to encode the data using each DataStore's `encodeData()` method  
      * @param stringified Whether to return the result as a string or as an array of `SerializedDataStore` objects  
      */
-    serializePartial(stores: StoreFilter, useEncoding?: boolean, stringified?: boolean): Promise<string | SerializedDataStore[]>;
+    serializePartial(stores: StoreFilter, useEncoding?: boolean, stringified?: boolean): Promise<string | SerializedDataStore<string | DataStoreData>[]>;
     /**
      * Serializes the data stores into a string.  
      * @param useEncoding Whether to encode the data using each DataStore's `encodeData()` method  
@@ -84,7 +89,7 @@ export declare class DataStoreSerializer {
      * @param useEncoding Whether to encode the data using each DataStore's `encodeData()` method  
      * @param stringified Whether to return the result as a string or as an array of `SerializedDataStore` objects  
      */
-    serialize(useEncoding?: boolean, stringified?: false): Promise<SerializedDataStore[]>;
+    serialize(useEncoding?: boolean, stringified?: false): Promise<SerializedDataStore<string | DataStoreData>[]>;
     /**
      * Deserializes the data exported via {@linkcode serialize()} and imports only a subset into the DataStore instances.  
      * Also triggers the migration process if the data format has changed.  

package/dist/lib/NanoEmitter.d.ts

@@ -7,6 +7,13 @@ import type { Prettify } from "./types.ts";
 export interface NanoEmitterOptions {
     /** If set to true, allows emitting events through the public method emit() */
     publicEmit: boolean;
+    /**
+     * When provided, the emitter will remember the last arguments of each listed event.  
+     * Any listener attached via `on()` or `once()` after the event has already fired will  
+     * be immediately called / resolved with the cached arguments (catch-up behaviour).  
+     * Only works for emissions that go through the public `emit()` or the protected `emitEvent()` method.  
+     */
+    catchUpEvents?: PropertyKey[];
 }
 type NanoEmitterOnMultiTriggerOptions<TEvtMap extends EventsMap, TKey extends keyof TEvtMap = keyof TEvtMap> = {
     /** Calls the callback when one of the given events is emitted. Either one of or both of `oneOf` and `allOf` need to be set. If both are set, they behave like an "AND" condition. */
@@ -25,14 +32,22 @@ export type NanoEmitterOnMultiOptions<TEvtMap extends EventsMap, TKey extends ke
 } & NanoEmitterOnMultiTriggerOptions<TEvtMap, TKey> & (Pick<Required<NanoEmitterOnMultiTriggerOptions<TEvtMap, TKey>>, "oneOf"> | Pick<Required<NanoEmitterOnMultiTriggerOptions<TEvtMap, TKey>>, "allOf">)>;
 /**
  * Class that can be extended or instantiated by itself to create a lightweight event emitter with helper methods and a strongly typed event map.  
- * If extended from, you can use `this.events.emit()` to emit events, even if the `emit()` method doesn't work because `publicEmit` is not set to true in the constructor.  
+ * If extended from, prefer using `this.emitEvent()` over `this.events.emit()` — it updates the catch-up memory for any events listed in `catchUpEvents`.  
  */
 export declare class NanoEmitter<TEvtMap extends EventsMap = DefaultEvents> {
     protected readonly events: Emitter<TEvtMap>;
     protected eventUnsubscribes: Unsubscribe[];
     protected emitterOptions: NanoEmitterOptions;
+    /** Stores the last arguments for each event listed in `catchUpEvents` */
+    protected catchUpMemory: Map<PropertyKey, unknown[]>;
     /** Creates a new instance of NanoEmitter - a lightweight event emitter with helper methods and a strongly typed event map */
     constructor(options?: Partial<NanoEmitterOptions>);
+    /**
+     * Emits an event on this instance, bypassing the `publicEmit` guard.  
+     * Prefer this over `this.events.emit()` in subclasses — it updates catch-up memory  
+     * for any event listed in `catchUpEvents` so late listeners can still receive the last value.  
+     */
+    protected emitEvent<TKey extends keyof TEvtMap>(event: TKey, ...args: Parameters<TEvtMap[TKey]>): void;
     /**
      * Subscribes to an event and calls the callback when it's emitted.  
      * @param event The event to subscribe to. Use `as "_"` in case your event names aren't thoroughly typed (like when using a template literal, e.g. \`event-${val}\` as "_")  

package/dist/lib/misc.d.ts

@@ -6,24 +6,32 @@ import type { ListLike, Prettify, Stringifiable } from "./types.ts";
 /**
  * A ValueGen value is either its type, a promise that resolves to its type, or a function that returns its type, either synchronous or asynchronous.  
  * ValueGen allows for the utmost flexibility when applied to any type, as long as {@linkcode consumeGen()} is used to get the final value.  
+ * The optional `TFn` parameter allows specifying the function variant's signature, enabling parametrized consumption via {@linkcode consumeGen()}.  
  * @template TValueType The type of the value that the ValueGen should yield  
+ * @template TFn The function signature for the function variant - defaults to a no-arg function for backwards compatibility  
  */
-export type ValueGen<TValueType> = TValueType | Promise<TValueType> | (() => TValueType | Promise<TValueType>);
+export type ValueGen<TValueType, TFn extends (...args: any[]) => TValueType | Promise<TValueType> = () => TValueType | Promise<TValueType>> = TValueType | Promise<TValueType> | TFn;
 /**
  * Turns a {@linkcode ValueGen} into its final value.  
+ * @param args Optional arguments forwarded to the function, if the ValueGen is a parametrized function  
  * @template TValueType The type of the value that the ValueGen should yield  
+ * @template TFn The function signature for the function variant - inferred automatically  
  */
-export declare function consumeGen<TValueType>(valGen: ValueGen<TValueType>): Promise<TValueType>;
+export declare function consumeGen<TValueType, TFn extends (...args: any[]) => TValueType | Promise<TValueType> = () => TValueType | Promise<TValueType>>(valGen: ValueGen<TValueType, TFn>, ...args: Parameters<TFn>): Promise<TValueType>;
 /**
  * A StringGen value is either a string, anything that can be converted to a string, or a function that returns one of the previous two, either synchronous or asynchronous, or a promise that returns a string.  
  * StringGen allows for the utmost flexibility when dealing with strings, as long as {@linkcode consumeStringGen()} is used to get the final string.  
+ * The optional `TFn` parameter allows specifying the function variant's signature, enabling parametrized consumption via {@linkcode consumeStringGen()}.  
+ * @template TFn The function signature for the function variant - defaults to a no-arg function for backwards compatibility  
  */
-export type StringGen = ValueGen<Stringifiable>;
+export type StringGen<TFn extends (...args: any[]) => Stringifiable | Promise<Stringifiable> = () => Stringifiable | Promise<Stringifiable>> = ValueGen<Stringifiable, TFn>;
 /**
  * Turns a {@linkcode StringGen} into its final string value.  
+ * @param args Optional arguments forwarded to the function, if the StringGen is a parametrized function  
  * @template TStrUnion The union of strings that the StringGen should yield - this allows for finer type control compared to {@linkcode consumeGen()}  
+ * @template TFn The function signature for the function variant - inferred automatically  
  */
-export declare function consumeStringGen<TStrUnion extends string>(strGen: StringGen): Promise<TStrUnion>;
+export declare function consumeStringGen<TStrUnion extends string, TFn extends (...args: any[]) => Stringifiable | Promise<Stringifiable> = () => Stringifiable | Promise<Stringifiable>>(strGen: StringGen<TFn>, ...args: Parameters<TFn>): Promise<TStrUnion>;
 /** Options for the `fetchAdvanced()` function */
 export type FetchAdvancedOpts = Prettify<Partial<{
     /** Timeout in milliseconds after which the fetch call will be canceled with an AbortController signal */
@@ -50,6 +58,11 @@ export declare function pauseFor(time: number, signal?: AbortSignal, rejectOnAbo
  * If no object is passed, it will return an empty object without prototype chain.  
  */
 export declare function pureObj<TObj extends object>(obj?: TObj): TObj;
+/**
+ * Transforms an object's enumerable, own, string-keyed properties into getters that return the original values.  
+ * Set `asCopy` to true to return a new object with the getterified properties instead of a live view of the original object.  
+ */
+export declare function getterifyObj<TObj extends object>(obj: TObj, asCopy?: boolean): TObj;
 /**
  * Works similarly to `setInterval()`, but the callback is also called immediately and can be aborted with an `AbortSignal`.  
  * Uses `setInterval()` internally, which might cause overlapping calls if the callback's synchronous execution takes longer than the given interval time.  

package/dist/lib/text.d.ts

@@ -99,7 +99,7 @@ export type TableLineCharset = Record<TableLineStyle, TableLineStyleChars>;
 export declare const defaultTableLineCharset: TableLineCharset;
 /**
  * Creates an ASCII table string from the given rows and options.  
- * Supports `\x1b` ANSI color codes in cell content: they are ignored for width calculation, included in the final output, and handled correctly during truncation (escape sequences are never split; any open color code is closed with a reset).  
+ * Supports ANSI color codes in cell content: they are ignored for width calculation, included in the final output, and handled correctly during truncation (escape sequences are never split; any open color code is closed with a reset).  
  * @param rows Array of tuples, where each tuple represents a row and its values. The first tuple is used to determine the column count.  
  * @param options Object with options for customizing the table output, such as column alignment, truncation, padding and line styles.  
  */

package/dist/lib/types.d.ts

@@ -35,7 +35,7 @@ export type NonEmptyString<TString extends string> = TString extends "" ? never
 /** String constant that decides which set of number formatting options to use */
 export type NumberFormat = "short" | "long";
 /**
- * Makes the structure of a type more readable by expanding it.  
+ * Makes the structure of a type more readable by expanding other types merged via intersections.  
  * This can be useful for debugging or for improving the readability of complex types.  
  */
 export type Prettify<T> = {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sv443-network/coreutils",
   "libName": "@sv443-network/coreutils",
-  "version": "3.5.0",
+  "version": "3.6.0",
   "description": "Cross-platform, general-purpose, JavaScript core library for Node, Deno and the browser. Intended to be used in conjunction with `@sv443-network/userutils` and `@sv443-network/djsutils`, but can be used independently as well.",
   "main": "dist/CoreUtils.cjs",
   "module": "dist/CoreUtils.mjs",