@simplysm/core-common 13.0.76 → 13.0.78

package/src/extensions/arr-ext.ts

@@ -5,7 +5,7 @@
  */
 
 import "./map-ext";
-import { objClone, objEqual, objMerge } from "../utils/obj";
+import { clone, equal, merge } from "../utils/obj";
 import type { PrimitiveTypeStr, Type } from "../common.types";
 import { DateTime } from "../types/date-time";
 import { DateOnly } from "../types/date-only";
@@ -13,12 +13,12 @@ import { Time } from "../types/time";
 import { Uuid } from "../types/uuid";
 import { ArgumentError } from "../errors/argument-error";
 import { SdError } from "../errors/sd-error";
-import { compareForOrder } from "./arr-ext.helpers";
+import { compareForOrder, getDistinctIndices } from "./arr-ext.helpers";
 import type {
   ReadonlyArrayExt,
   MutableArrayExt,
   ArrayDiffsResult,
-  ArrayDiffs2Result,
+  ArrayOneWayDiffResult,
   TreeArray,
 } from "./arr-ext.types";
 
@@ -155,7 +155,7 @@ const arrayReadonlyExtensions: ReadonlyArrayExt<any> & ThisType<any[]> = {
       }
 
       // Object keys use the existing approach O(n²)
-      const existsRecord = result.find((item) => objEqual(item.key, keyObj));
+      const existsRecord = result.find((item) => equal(item.key, keyObj));
       if (existsRecord !== undefined) {
         existsRecord.values.push(valueObj);
       } else {
@@ -298,7 +298,7 @@ const arrayReadonlyExtensions: ReadonlyArrayExt<any> & ThisType<any[]> = {
 
     const fn = (items: T[]): TreeArray<T>[] => {
       return items.map((item) => ({
-        ...objClone(item),
+        ...clone(item),
         children: fn(childrenMap.get(item[key]) ?? []),
       }));
     };
@@ -310,66 +310,8 @@ const arrayReadonlyExtensions: ReadonlyArrayExt<any> & ThisType<any[]> = {
   distinct<T>(
     options?: boolean | { matchAddress?: boolean; keyFn?: (item: T) => string | number },
   ): T[] {
-    // Normalize options
-    const opts = typeof options === "boolean" ? { matchAddress: options } : (options ?? {});
-
-    // matchAddress: Set-based O(n)
-    if (opts.matchAddress === true) return [...new Set(this)];
-
-    // keyFn provided: custom key-based O(n)
-    if (opts.keyFn) {
-      const seen = new Set<string | number>();
-      const result: T[] = [];
-      for (const item of this) {
-        const key = opts.keyFn(item);
-        if (!seen.has(key)) {
-          seen.add(key);
-          result.push(item);
-        }
-      }
-      return result;
-    }
-
-    // Default: type-based processing
-    const seen = new Map<string, T>();
-    const seenRefs = new Set<symbol | ((...args: unknown[]) => unknown)>(); // O(n) processing for symbol/function
-    const result: T[] = [];
-
-    for (const item of this) {
-      // primitive types take the fast path
-      if (item === null || typeof item !== "object") {
-        const type = typeof item;
-
-        // symbol, function use Set for identity comparison (O(n))
-        if (type === "symbol" || type === "function") {
-          if (!seenRefs.has(item)) {
-            seenRefs.add(item);
-            result.push(item);
-          }
-          continue;
-        }
-
-        // Other primitives: type prefix + special case handling
-        let key = type + ":";
-        if (Object.is(item, -0)) {
-          key += "-0";
-        } else {
-          key += String(item);
-        }
-
-        if (!seen.has(key)) {
-          seen.set(key, item);
-          result.push(item);
-        }
-        continue;
-      }
-
-      if (!result.some((item1) => objEqual(item1, item))) {
-        result.push(item);
-      }
-    }
-
-    return result;
+    const keptIndices = getDistinctIndices(this, options);
+    return Array.from(keptIndices).map((i) => this[i]);
   },
 
   orderBy<T>(
@@ -432,7 +374,7 @@ const arrayReadonlyExtensions: ReadonlyArrayExt<any> & ThisType<any[]> = {
       // Skip already matched items using Set-based skipping (avoid O(n) splice removal)
       for (const targetItem of uncheckedTarget) {
         if (!uncheckedTargetSet.has(targetItem)) continue;
-        if (objEqual(targetItem, sourceItem, excludeOpts)) {
+        if (equal(targetItem, sourceItem, excludeOpts)) {
           sameTarget = targetItem;
           break;
         }
@@ -475,7 +417,7 @@ const arrayReadonlyExtensions: ReadonlyArrayExt<any> & ThisType<any[]> = {
       excludes?: string[];
       includes?: string[];
     },
-  ): ArrayDiffs2Result<T>[] {
+  ): ArrayOneWayDiffResult<T>[] {
     const orgItemMap =
       orgItems instanceof Map
         ? orgItems
@@ -486,7 +428,7 @@ const arrayReadonlyExtensions: ReadonlyArrayExt<any> & ThisType<any[]> = {
           );
     const includeSame = options?.includeSame ?? false;
 
-    const diffs: ArrayDiffs2Result<T>[] = [];
+    const diffs: ArrayOneWayDiffResult<T>[] = [];
     for (const item of this) {
       const keyValue =
         typeof keyPropNameOrGetValFn === "function"
@@ -504,7 +446,7 @@ const arrayReadonlyExtensions: ReadonlyArrayExt<any> & ThisType<any[]> = {
       }
 
       if (
-        objEqual(orgItem, item, {
+        equal(orgItem, item, {
           topLevelExcludes: options?.excludes,
           topLevelIncludes: options?.includes,
         })
@@ -527,9 +469,9 @@ const arrayReadonlyExtensions: ReadonlyArrayExt<any> & ThisType<any[]> = {
       excludes?: string[];
     },
   ): (T | P | (T & P))[] {
-    const diffs = this.diffs(target, options);
+    const diffs = this.diffs(target as any[], options as any);
 
-    const result: (T | P | (T & P))[] = objClone(this);
+    const result: (T | P | (T & P))[] = clone(this);
 
     // Pre-calculate original index of source items to improve O(n) lookup to O(1)
     const sourceIndexMap = new Map<T, number>();
@@ -544,7 +486,7 @@ const arrayReadonlyExtensions: ReadonlyArrayExt<any> & ThisType<any[]> = {
         if (sourceIndex === undefined) {
           throw new SdError("Unexpected error: source item not found in merge.");
         }
-        result[sourceIndex] = objMerge(diff.source, diff.target);
+        result[sourceIndex] = merge(diff.source, diff.target);
       }
       // When adding
       else if (diff.target !== undefined) {
@@ -622,107 +564,17 @@ const arrayMutableExtensions: MutableArrayExt<any> & ThisType<any[]> = {
   distinctThis<T>(
     options?: boolean | { matchAddress?: boolean; keyFn?: (item: T) => string | number },
   ): T[] {
-    // Normalize options
-    const opts = typeof options === "boolean" ? { matchAddress: options } : (options ?? {});
-
-    // matchAddress: Set-based O(n)
-    // To preserve first occurrence, collect indices to remove after forward traversal
-    if (opts.matchAddress === true) {
-      const seen = new Set<T>();
-      const toRemove: number[] = [];
-      for (let i = 0; i < this.length; i++) {
-        if (seen.has(this[i])) {
-          toRemove.push(i);
-        } else {
-          seen.add(this[i]);
-        }
-      }
-      // Remove in reverse order (prevent index changes)
-      for (let i = toRemove.length - 1; i >= 0; i--) {
-        this.splice(toRemove[i], 1);
-      }
-      return this;
-    }
-
-    // keyFn provided: custom key-based O(n)
-    // To preserve first occurrence, collect indices to remove after forward traversal
-    if (opts.keyFn) {
-      const seen = new Set<string | number>();
-      const toRemove: number[] = [];
-      for (let i = 0; i < this.length; i++) {
-        const key = opts.keyFn(this[i]);
-        if (seen.has(key)) {
-          toRemove.push(i);
-        } else {
-          seen.add(key);
-        }
-      }
-      // Remove in reverse order (prevent index changes)
-      for (let i = toRemove.length - 1; i >= 0; i--) {
-        this.splice(toRemove[i], 1);
-      }
-      return this;
-    }
-
-    // Default: type-based processing (primitive optimization)
-    const seen = new Map<string, T>();
-    const seenRefs = new Set<symbol | ((...args: unknown[]) => unknown)>();
-    const toRemoveSet = new Set<number>();
-
+    const keptIndices = getDistinctIndices(this, options);
+    const indicesToRemove = [];
     for (let i = 0; i < this.length; i++) {
-      const item = this[i];
-
-      // primitive types take the fast path O(n)
-      if (item === null || typeof item !== "object") {
-        const type = typeof item;
-
-        // symbol, function use Set for identity comparison
-        if (type === "symbol" || type === "function") {
-          if (seenRefs.has(item)) {
-            toRemoveSet.add(i);
-          } else {
-            seenRefs.add(item);
-          }
-          continue;
-        }
-
-        // Other primitives: type prefix + special case handling
-        let key = type + ":";
-        if (Object.is(item, -0)) {
-          key += "-0";
-        } else {
-          key += String(item);
-        }
-
-        if (seen.has(key)) {
-          toRemoveSet.add(i);
-        } else {
-          seen.set(key, item);
-        }
-        continue;
-      }
-
-      // Objects: deep comparison O(n²) - compare with previous non-removed items
-      let hasDuplicateBefore = false;
-      for (let j = 0; j < i; j++) {
-        // Skip indices in toRemoveSet (O(1) lookup)
-        if (toRemoveSet.has(j)) continue;
-        if (objEqual(this[j], item)) {
-          hasDuplicateBefore = true;
-          break;
-        }
-      }
-      if (hasDuplicateBefore) {
-        toRemoveSet.add(i);
+      if (!keptIndices.has(i)) {
+        indicesToRemove.push(i);
       }
     }
-
-    // Remove in reverse order (prevent index changes)
-    const toRemoveArr = Array.from(toRemoveSet).sort((a, b) => b - a);
-    for (const idx of toRemoveArr) {
-      this.splice(idx, 1);
+    // Remove in reverse order to prevent index shifts
+    for (let i = indicesToRemove.length - 1; i >= 0; i--) {
+      this.splice(indicesToRemove[i], 1);
     }
-
     return this;
   },
 
@@ -806,7 +658,7 @@ declare global {
 
 export type {
   ArrayDiffsResult,
-  ArrayDiffs2Result,
+  ArrayOneWayDiffResult,
   TreeArray,
   ComparableType,
 } from "./arr-ext.types";

package/src/extensions/arr-ext.types.ts

@@ -39,33 +39,33 @@ export interface ReadonlyArrayExt<TItem> {
   filterExists(): NonNullable<TItem>[];
 
   /** Filter only elements of specific type (PrimitiveTypeStr or constructor type) */
-  ofType<K extends PrimitiveTypeStr>(type: K): Extract<TItem, PrimitiveTypeMap[K]>[];
-  ofType<N extends TItem>(type: Type<N>): N[];
+  ofType<TKey extends PrimitiveTypeStr>(type: TKey): Extract<TItem, PrimitiveTypeMap[TKey]>[];
+  ofType<TNarrow extends TItem>(type: Type<TNarrow>): TNarrow[];
 
   /** Async mapping (sequential execution) */
-  mapAsync<R>(selector: (item: TItem, index: number) => Promise<R>): Promise<R[]>;
+  mapAsync<TResult>(selector: (item: TItem, index: number) => Promise<TResult>): Promise<TResult[]>;
 
   /** Flatten nested array */
   mapMany(): TItem extends readonly (infer U)[] ? U[] : TItem;
 
   /** Map and then flatten */
-  mapMany<R>(selector: (item: TItem, index: number) => R[]): R[];
+  mapMany<TResult>(selector: (item: TItem, index: number) => TResult[]): TResult[];
 
   /** Async mapping and then flatten (sequential execution) */
-  mapManyAsync<R>(selector: (item: TItem, index: number) => Promise<R[]>): Promise<R[]>;
+  mapManyAsync<TResult>(selector: (item: TItem, index: number) => Promise<TResult[]>): Promise<TResult[]>;
 
   /**
    * Async parallel processing (using Promise.all)
    * @note If any rejects, entire operation fail-fast rejects (Promise.all behavior)
    */
-  parallelAsync<R>(fn: (item: TItem, index: number) => Promise<R>): Promise<R[]>;
+  parallelAsync<TResult>(fn: (item: TItem, index: number) => Promise<TResult>): Promise<TResult[]>;
 
   /**
    * Group by key
    * @param keySelector Key selection function for group
    * @note O(n²) complexity (deep comparison for object key support). If only primitive keys are needed, toArrayMap() is more efficient at O(n)
    */
-  groupBy<K>(keySelector: (item: TItem, index: number) => K): { key: K; values: TItem[] }[];
+  groupBy<TKey>(keySelector: (item: TItem, index: number) => TKey): { key: TKey; values: TItem[] }[];
 
   /**
    * Group by key (with value transformation)
@@ -73,52 +73,52 @@ export interface ReadonlyArrayExt<TItem> {
    * @param valueSelector Value transformation function
    * @note O(n²) complexity (deep comparison for object key support). If only primitive keys are needed, toArrayMap() is more efficient at O(n)
    */
-  groupBy<K, V>(
-    keySelector: (item: TItem, index: number) => K,
-    valueSelector: (item: TItem, index: number) => V,
+  groupBy<TKey, TValue>(
+    keySelector: (item: TItem, index: number) => TKey,
+    valueSelector: (item: TItem, index: number) => TValue,
   ): {
-    key: K;
-    values: V[];
+    key: TKey;
+    values: TValue[];
   }[];
 
-  toMap<K>(keySelector: (item: TItem, index: number) => K): Map<K, TItem>;
+  toMap<TKey>(keySelector: (item: TItem, index: number) => TKey): Map<TKey, TItem>;
 
-  toMap<K, V>(
-    keySelector: (item: TItem, index: number) => K,
-    valueSelector: (item: TItem, index: number) => V,
-  ): Map<K, V>;
+  toMap<TKey, TValue>(
+    keySelector: (item: TItem, index: number) => TKey,
+    valueSelector: (item: TItem, index: number) => TValue,
+  ): Map<TKey, TValue>;
 
-  toMapAsync<K>(keySelector: (item: TItem, index: number) => Promise<K>): Promise<Map<K, TItem>>;
+  toMapAsync<TKey>(keySelector: (item: TItem, index: number) => Promise<TKey>): Promise<Map<TKey, TItem>>;
 
-  toMapAsync<K, V>(
-    keySelector: (item: TItem, index: number) => Promise<K> | K,
-    valueSelector: (item: TItem, index: number) => Promise<V> | V,
-  ): Promise<Map<K, V>>;
+  toMapAsync<TKey, TValue>(
+    keySelector: (item: TItem, index: number) => Promise<TKey> | TKey,
+    valueSelector: (item: TItem, index: number) => Promise<TValue> | TValue,
+  ): Promise<Map<TKey, TValue>>;
 
-  toArrayMap<K>(keySelector: (item: TItem, index: number) => K): Map<K, TItem[]>;
+  toArrayMap<TKey>(keySelector: (item: TItem, index: number) => TKey): Map<TKey, TItem[]>;
 
-  toArrayMap<K, V>(
-    keySelector: (item: TItem, index: number) => K,
-    valueSelector: (item: TItem, index: number) => V,
-  ): Map<K, V[]>;
+  toArrayMap<TKey, TValue>(
+    keySelector: (item: TItem, index: number) => TKey,
+    valueSelector: (item: TItem, index: number) => TValue,
+  ): Map<TKey, TValue[]>;
 
-  toSetMap<K>(keySelector: (item: TItem, index: number) => K): Map<K, Set<TItem>>;
-  toSetMap<K, V>(
-    keySelector: (item: TItem, index: number) => K,
-    valueSelector: (item: TItem, index: number) => V,
-  ): Map<K, Set<V>>;
+  toSetMap<TKey>(keySelector: (item: TItem, index: number) => TKey): Map<TKey, Set<TItem>>;
+  toSetMap<TKey, TValue>(
+    keySelector: (item: TItem, index: number) => TKey,
+    valueSelector: (item: TItem, index: number) => TValue,
+  ): Map<TKey, Set<TValue>>;
 
-  toMapValues<K, V>(
-    keySelector: (item: TItem, index: number) => K,
-    valueSelector: (items: TItem[]) => V,
-  ): Map<K, V>;
+  toMapValues<TKey, TValue>(
+    keySelector: (item: TItem, index: number) => TKey,
+    valueSelector: (items: TItem[]) => TValue,
+  ): Map<TKey, TValue>;
 
   toObject(keySelector: (item: TItem, index: number) => string): Record<string, TItem>;
 
-  toObject<V>(
+  toObject<TValue>(
     keySelector: (item: TItem, index: number) => string,
-    valueSelector: (item: TItem, index: number) => V,
-  ): Record<string, V>;
+    valueSelector: (item: TItem, index: number) => TValue,
+  ): Record<string, TValue>;
 
   /**
    * Convert flat array to tree structure
@@ -186,22 +186,50 @@ export interface ReadonlyArrayExt<TItem> {
    */
   diffs<TOtherItem>(
     target: TOtherItem[],
-    options?: { keys?: string[]; excludes?: string[] },
   ): ArrayDiffsResult<TItem, TOtherItem>[];
 
-  oneWayDiffs<K extends keyof TItem>(
-    orgItems: TItem[] | Map<TItem[K], TItem>,
-    keyPropNameOrGetValFn: K | ((item: TItem) => string | number | undefined),
+  diffs<TOtherItem extends Record<string, unknown> = Record<string, unknown>>(
+    target: TOtherItem[],
+    options: {
+      keys: ((keyof TItem | keyof TOtherItem) & string)[];
+      excludes?: ((keyof TItem | keyof TOtherItem) & string)[];
+    },
+  ): ArrayDiffsResult<TItem, TOtherItem>[];
+
+  diffs<TOtherItem extends Record<string, unknown> = Record<string, unknown>>(
+    target: TOtherItem[],
+    options: {
+      excludes: ((keyof TItem | keyof TOtherItem) & string)[];
+    },
+  ): ArrayDiffsResult<TItem, TOtherItem>[];
+
+  oneWayDiffs<TKey extends keyof TItem>(
+    orgItems: TItem[] | Map<TItem[TKey], TItem>,
+    keyPropNameOrGetValFn: TKey | ((item: TItem) => string | number | undefined),
     options?: {
       includeSame?: boolean;
       excludes?: string[];
       includes?: string[];
     },
-  ): ArrayDiffs2Result<TItem>[];
+  ): ArrayOneWayDiffResult<TItem>[];
 
   merge<TOtherItem>(
     target: TOtherItem[],
-    options?: { keys?: string[]; excludes?: string[] },
+  ): (TItem | TOtherItem | (TItem & TOtherItem))[];
+
+  merge<TOtherItem extends Record<string, unknown> = Record<string, unknown>>(
+    target: TOtherItem[],
+    options: {
+      keys: ((keyof TItem | keyof TOtherItem) & string)[];
+      excludes?: ((keyof TItem | keyof TOtherItem) & string)[];
+    },
+  ): (TItem | TOtherItem | (TItem & TOtherItem))[];
+
+  merge<TOtherItem extends Record<string, unknown> = Record<string, unknown>>(
+    target: TOtherItem[],
+    options: {
+      excludes: ((keyof TItem | keyof TOtherItem) & string)[];
+    },
   ): (TItem | TOtherItem | (TItem & TOtherItem))[];
 
   /**
@@ -213,11 +241,11 @@ export interface ReadonlyArrayExt<TItem> {
 
   min(): TItem extends number | string ? TItem | undefined : never;
 
-  min<P extends number | string>(selector?: (item: TItem, index: number) => P): P | undefined;
+  min<TProp extends number | string>(selector?: (item: TItem, index: number) => TProp): TProp | undefined;
 
   max(): TItem extends number | string ? TItem | undefined : never;
 
-  max<P extends number | string>(selector?: (item: TItem, index: number) => P): P | undefined;
+  max<TProp extends number | string>(selector?: (item: TItem, index: number) => TProp): TProp | undefined;
 
   shuffle(): TItem[];
 }
@@ -272,7 +300,7 @@ export type ArrayDiffsResult<TOriginal, TOther> =
   | { source: TOriginal; target: undefined } // DELETE
   | { source: TOriginal; target: TOther }; // UPDATE
 
-export type ArrayDiffs2Result<TItem> =
+export type ArrayOneWayDiffResult<TItem> =
   | { type: "create"; item: TItem; orgItem: undefined }
   | { type: "update"; item: TItem; orgItem: TItem }
   | { type: "same"; item: TItem; orgItem: TItem };

package/src/extensions/map-ext.ts

@@ -57,10 +57,10 @@ declare global {
 }
 
 Object.defineProperty(Map.prototype, "getOrCreate", {
-  value: function <K, V>(this: Map<K, V>, key: K, newValue: V | (() => V)): V {
+  value: function <TKey, TValue>(this: Map<TKey, TValue>, key: TKey, newValue: TValue | (() => TValue)): TValue {
     if (!this.has(key)) {
       if (typeof newValue === "function") {
-        this.set(key, (newValue as () => V)());
+        this.set(key, (newValue as () => TValue)());
       } else {
         this.set(key, newValue);
       }
@@ -73,7 +73,7 @@ Object.defineProperty(Map.prototype, "getOrCreate", {
 });
 
 Object.defineProperty(Map.prototype, "update", {
-  value: function <K, V>(this: Map<K, V>, key: K, updateFn: (v: V | undefined) => V): void {
+  value: function <TKey, TValue>(this: Map<TKey, TValue>, key: TKey, updateFn: (v: TValue | undefined) => TValue): void {
     const val = this.get(key);
     const res = updateFn(val);
     this.set(key, res);

package/src/extensions/set-ext.ts

@@ -36,7 +36,7 @@ declare global {
 }
 
 Object.defineProperty(Set.prototype, "adds", {
-  value: function <T>(this: Set<T>, ...values: T[]): Set<T> {
+  value: function <TItem>(this: Set<TItem>, ...values: TItem[]): Set<TItem> {
     for (const val of values) {
       this.add(val);
     }
@@ -48,7 +48,7 @@ Object.defineProperty(Set.prototype, "adds", {
 });
 
 Object.defineProperty(Set.prototype, "toggle", {
-  value: function <T>(this: Set<T>, value: T, addOrDel?: "add" | "del"): Set<T> {
+  value: function <TItem>(this: Set<TItem>, value: TItem, addOrDel?: "add" | "del"): Set<TItem> {
     if (addOrDel === "add") {
       this.add(value);
     } else if (addOrDel === "del") {

package/src/features/event-emitter.ts

@@ -35,7 +35,7 @@ export class EventEmitter<
    * @param listener Event handler
    * @note Duplicate registration of the same listener to the same event is ignored
    */
-  on<K extends keyof TEvents & string>(type: K, listener: (data: TEvents[K]) => void): void {
+  on<TEventName extends keyof TEvents & string>(type: TEventName, listener: (data: TEvents[TEventName]) => void): void {
     // Get or create map for event type
     let typeMap = this._listenerMap.get(type);
     if (!typeMap) {
@@ -57,7 +57,7 @@ export class EventEmitter<
    * @param type Event type
    * @param listener Event handler to remove
    */
-  off<K extends keyof TEvents & string>(type: K, listener: (data: TEvents[K]) => void): void {
+  off<TEventName extends keyof TEvents & string>(type: TEventName, listener: (data: TEvents[TEventName]) => void): void {
     const typeMap = this._listenerMap.get(type);
     if (!typeMap) return;
 
@@ -79,9 +79,9 @@ export class EventEmitter<
    * @param type Event type
    * @param args Event data (omitted if void type)
    */
-  emit<K extends keyof TEvents & string>(
-    type: K,
-    ...args: TEvents[K] extends void ? [] : [data: TEvents[K]]
+  emit<TEventName extends keyof TEvents & string>(
+    type: TEventName,
+    ...args: TEvents[TEventName] extends void ? [] : [data: TEvents[TEventName]]
   ): void {
     this._target.dispatchEvent(new CustomEvent(type, { detail: args[0] }));
   }
@@ -92,7 +92,7 @@ export class EventEmitter<
    * @param type Event type
    * @returns Number of registered listeners
    */
-  listenerCount<K extends keyof TEvents & string>(type: K): number {
+  listenerCount<TEventName extends keyof TEvents & string>(type: TEventName): number {
     return this._listenerMap.get(type)?.size ?? 0;
   }
 

package/src/features/serial-queue.ts

@@ -18,7 +18,7 @@
 import { SdError } from "../errors/sd-error";
 import { EventEmitter } from "./event-emitter";
 import consola from "consola";
-import { waitTime } from "../utils/wait";
+import { time } from "../utils/wait";
 
 interface SerialQueueEvents {
   error: SdError;
@@ -84,7 +84,7 @@ export class SerialQueue extends EventEmitter<SerialQueueEvents> {
         }
 
         if (this._gap > 0 && this._queue.length > 0) {
-          await waitTime(this._gap);
+          await time(this._gap);
         }
       }
     } finally {

package/src/index.ts

@@ -31,24 +31,24 @@ export * from "./features/serial-queue";
 export * from "./features/event-emitter";
 //#endregion
 
-//#region utils
-export * from "./utils/date-format";
-export * from "./utils/bytes";
-export * from "./utils/json";
-export * from "./utils/num";
-export * from "./utils/obj";
-export * from "./utils/primitive";
-export * from "./utils/str";
-export * from "./utils/template-strings";
-export * from "./utils/transferable";
-export * from "./utils/wait";
-export * from "./utils/xml";
-export * from "./utils/path";
-export * from "./utils/error";
+//#region utils (namespace exports)
+export * as obj from "./utils/obj";
+export * as str from "./utils/str";
+export * as num from "./utils/num";
+export * as bytes from "./utils/bytes";
+export * as path from "./utils/path";
+export * as json from "./utils/json";
+export * as xml from "./utils/xml";
+export * as wait from "./utils/wait";
+export * as transfer from "./utils/transferable";
+export * as err from "./utils/error";
+export * as dt from "./utils/date-format";
+export * as primitive from "./utils/primitive";
 //#endregion
 
-//#region zip
-export * from "./zip/sd-zip";
+//#region utils (direct exports)
+export * from "./utils/template-strings";
+export * from "./utils/zip";
 //#endregion
 
 //#region type utilities

package/src/types/date-only.ts

@@ -1,5 +1,5 @@
 import { ArgumentError } from "../errors/argument-error";
-import { formatDate, normalizeMonth } from "../utils/date-format";
+import { format, normalizeMonth } from "../utils/date-format";
 
 /**
  * Date class (without time: yyyy-MM-dd, immutable)
@@ -327,7 +327,7 @@ export class DateOnly {
    * @see dtFormat for supported format strings
    */
   toFormatString(formatStr: string): string {
-    return formatDate(formatStr, {
+    return format(formatStr, {
       year: this.year,
       month: this.month,
       day: this.day,

package/src/types/date-time.ts

@@ -1,5 +1,5 @@
 import { ArgumentError } from "../errors/argument-error";
-import { convert12To24, formatDate, normalizeMonth } from "../utils/date-format";
+import { convert12To24, format, normalizeMonth } from "../utils/date-format";
 
 /**
  * DateTime class (immutable)
@@ -355,7 +355,7 @@ export class DateTime {
    * @see dtFormat for supported format strings
    */
   toFormatString(formatStr: string): string {
-    return formatDate(formatStr, {
+    return format(formatStr, {
       year: this.year,
       month: this.month,
       day: this.day,