@simplysm/core-common 13.0.69 → 13.0.71

package/tests/utils/path.spec.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect } from "vitest";
+import { pathJoin, pathBasename, pathExtname } from "@simplysm/core-common";
+
+describe("path utils", () => {
+  describe("pathJoin()", () => {
+    it("Combines path segments", () => {
+      expect(pathJoin("a", "b", "c")).toBe("a/b/c");
+    });
+
+    it("Preserves leading slash", () => {
+      expect(pathJoin("/a", "b")).toBe("/a/b");
+    });
+
+    it("Removes duplicate slashes", () => {
+      expect(pathJoin("a/", "/b/", "/c")).toBe("a/b/c");
+    });
+
+    it("Ignores empty segments", () => {
+      expect(pathJoin("a", "", "b")).toBe("a/b");
+    });
+
+    it("Returns single segment", () => {
+      expect(pathJoin("a")).toBe("a");
+    });
+
+    it("Empty input returns empty string", () => {
+      expect(pathJoin()).toBe("");
+    });
+  });
+
+  describe("pathBasename()", () => {
+    it("Extracts filename", () => {
+      expect(pathBasename("a/b/file.txt")).toBe("file.txt");
+    });
+
+    it("Removes extension", () => {
+      expect(pathBasename("a/b/file.txt", ".txt")).toBe("file");
+    });
+
+    it("Ignores non-matching extension", () => {
+      expect(pathBasename("a/b/file.txt", ".md")).toBe("file.txt");
+    });
+
+    it("Handles filename without path", () => {
+      expect(pathBasename("file.txt")).toBe("file.txt");
+    });
+
+    it("Empty string returns empty string", () => {
+      expect(pathBasename("")).toBe("");
+    });
+  });
+
+  describe("pathExtname()", () => {
+    it("Extracts extension", () => {
+      expect(pathExtname("file.txt")).toBe(".txt");
+    });
+
+    it("Extracts only last extension", () => {
+      expect(pathExtname("archive.tar.gz")).toBe(".gz");
+    });
+
+    it("File without extension returns empty string", () => {
+      expect(pathExtname("Makefile")).toBe("");
+    });
+
+    it("Hidden file returns empty string", () => {
+      expect(pathExtname(".gitignore")).toBe("");
+    });
+
+    it("Extracts extension from file with path", () => {
+      expect(pathExtname("a/b/file.ts")).toBe(".ts");
+    });
+
+    it("Empty string returns empty string", () => {
+      expect(pathExtname("")).toBe("");
+    });
+  });
+});

package/tests/utils/primitive.spec.ts

@@ -0,0 +1,43 @@
+import { describe, it, expect } from "vitest";
+import { getPrimitiveTypeStr, DateTime, DateOnly, Time, Uuid } from "@simplysm/core-common";
+
+describe("primitive utils", () => {
+  describe("getPrimitiveTypeStr()", () => {
+    it("Returns string", () => {
+      expect(getPrimitiveTypeStr("hello")).toBe("string");
+    });
+
+    it("Returns number", () => {
+      expect(getPrimitiveTypeStr(42)).toBe("number");
+    });
+
+    it("Returns boolean", () => {
+      expect(getPrimitiveTypeStr(true)).toBe("boolean");
+      expect(getPrimitiveTypeStr(false)).toBe("boolean");
+    });
+
+    it("Returns DateTime", () => {
+      expect(getPrimitiveTypeStr(new DateTime())).toBe("DateTime");
+    });
+
+    it("Returns DateOnly", () => {
+      expect(getPrimitiveTypeStr(new DateOnly())).toBe("DateOnly");
+    });
+
+    it("Returns Time", () => {
+      expect(getPrimitiveTypeStr(new Time())).toBe("Time");
+    });
+
+    it("Returns Uuid", () => {
+      expect(getPrimitiveTypeStr(Uuid.new())).toBe("Uuid");
+    });
+
+    it("Uint8Array returns Bytes", () => {
+      expect(getPrimitiveTypeStr(new Uint8Array([1, 2]))).toBe("Bytes");
+    });
+
+    it("Unsupported type throws error", () => {
+      expect(() => getPrimitiveTypeStr({} as never)).toThrow();
+    });
+  });
+});

package/tests/utils/sd-event-emitter.spec.ts

@@ -0,0 +1,216 @@
+import { describe, it, expect, vi } from "vitest";
+import { EventEmitter } from "@simplysm/core-common";
+
+interface TestEvents {
+  message: string;
+  count: number;
+  data: { id: number; name: string };
+  empty: void;
+}
+
+describe("SdEventEmitter", () => {
+  //#region on/emit
+
+  describe("on() / emit()", () => {
+    it("Emits and receives event", () => {
+      const emitter = new EventEmitter<TestEvents>();
+      const listener = vi.fn();
+
+      emitter.on("message", listener);
+      emitter.emit("message", "hello");
+
+      expect(listener).toHaveBeenCalledWith("hello");
+      expect(listener).toHaveBeenCalledTimes(1);
+    });
+
+    it("Listener called multiple times on multiple emit", () => {
+      const emitter = new EventEmitter<TestEvents>();
+      const listener = vi.fn();
+
+      emitter.on("count", listener);
+      emitter.emit("count", 1);
+      emitter.emit("count", 2);
+      emitter.emit("count", 3);
+
+      expect(listener).toHaveBeenCalledTimes(3);
+      expect(listener).toHaveBeenNthCalledWith(1, 1);
+      expect(listener).toHaveBeenNthCalledWith(2, 2);
+      expect(listener).toHaveBeenNthCalledWith(3, 3);
+    });
+
+    it("Passes object data", () => {
+      const emitter = new EventEmitter<TestEvents>();
+      const listener = vi.fn();
+
+      emitter.on("data", listener);
+      emitter.emit("data", { id: 1, name: "test" });
+
+      expect(listener).toHaveBeenCalledWith({ id: 1, name: "test" });
+    });
+
+    it("Handles void event", () => {
+      const emitter = new EventEmitter<TestEvents>();
+      const listener = vi.fn();
+
+      emitter.on("empty", listener);
+      emitter.emit("empty");
+
+      expect(listener).toHaveBeenCalledTimes(1);
+    });
+
+    it("Can register multiple listeners for same event", () => {
+      const emitter = new EventEmitter<TestEvents>();
+      const listener1 = vi.fn();
+      const listener2 = vi.fn();
+
+      emitter.on("message", listener1);
+      emitter.on("message", listener2);
+      emitter.emit("message", "test");
+
+      expect(listener1).toHaveBeenCalledWith("test");
+      expect(listener2).toHaveBeenCalledWith("test");
+    });
+  });
+
+  //#endregion
+
+  //#region off
+
+  describe("off()", () => {
+    it("Removes listener", () => {
+      const emitter = new EventEmitter<TestEvents>();
+      const listener = vi.fn();
+
+      emitter.on("message", listener);
+      emitter.off("message", listener);
+      emitter.emit("message", "test");
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it("Removes only specified listener, others remain", () => {
+      const emitter = new EventEmitter<TestEvents>();
+      const listener1 = vi.fn();
+      const listener2 = vi.fn();
+
+      emitter.on("message", listener1);
+      emitter.on("message", listener2);
+      emitter.off("message", listener1);
+      emitter.emit("message", "test");
+
+      expect(listener1).not.toHaveBeenCalled();
+      expect(listener2).toHaveBeenCalledWith("test");
+    });
+
+    it("No error removing unregistered listener", () => {
+      const emitter = new EventEmitter<TestEvents>();
+      const listener = vi.fn();
+
+      // Should run without error
+      expect(() => {
+        emitter.off("message", listener);
+      }).not.toThrow();
+    });
+  });
+
+  //#endregion
+
+  //#region listenerCount
+
+  describe("listenerCount()", () => {
+    it("Accurately counts listeners", () => {
+      const emitter = new EventEmitter<TestEvents>();
+
+      expect(emitter.listenerCount("message")).toBe(0);
+
+      emitter.on("message", () => {});
+      expect(emitter.listenerCount("message")).toBe(1);
+
+      emitter.on("message", () => {});
+      expect(emitter.listenerCount("message")).toBe(2);
+    });
+
+    it("Count decreases after off", () => {
+      const emitter = new EventEmitter<TestEvents>();
+      const listener = vi.fn();
+
+      emitter.on("message", listener);
+      expect(emitter.listenerCount("message")).toBe(1);
+
+      emitter.off("message", listener);
+      expect(emitter.listenerCount("message")).toBe(0);
+    });
+
+    it("Unregistered event type has 0 count", () => {
+      const emitter = new EventEmitter<TestEvents>();
+
+      expect(emitter.listenerCount("message")).toBe(0);
+      expect(emitter.listenerCount("count")).toBe(0);
+    });
+
+    it("Different event types have independent counts", () => {
+      const emitter = new EventEmitter<TestEvents>();
+
+      emitter.on("message", () => {});
+      emitter.on("message", () => {});
+      emitter.on("count", () => {});
+
+      expect(emitter.listenerCount("message")).toBe(2);
+      expect(emitter.listenerCount("count")).toBe(1);
+    });
+  });
+
+  //#endregion
+
+  //#region Prevent duplicate registration
+
+  describe("Prevent duplicate registration", () => {
+    it("Duplicate registration of same listener is ignored", () => {
+      const emitter = new EventEmitter<TestEvents>();
+      const listener = vi.fn();
+
+      emitter.on("message", listener);
+      emitter.on("message", listener); // duplicate registration attempt
+      emitter.on("message", listener); // duplicate registration attempt
+
+      expect(emitter.listenerCount("message")).toBe(1);
+
+      emitter.emit("message", "test");
+      expect(listener).toHaveBeenCalledTimes(1);
+    });
+
+    it("Can register same listener to different events", () => {
+      const emitter = new EventEmitter<TestEvents>();
+      const listener = vi.fn();
+
+      emitter.on("message", listener);
+      emitter.on("count", listener as any);
+
+      expect(emitter.listenerCount("message")).toBe(1);
+      expect(emitter.listenerCount("count")).toBe(1);
+
+      emitter.emit("message", "test");
+      emitter.emit("count", 123);
+
+      expect(listener).toHaveBeenCalledTimes(2);
+      expect(listener).toHaveBeenNthCalledWith(1, "test");
+      expect(listener).toHaveBeenNthCalledWith(2, 123);
+    });
+
+    it("Single off call removes after duplicate registration", () => {
+      const emitter = new EventEmitter<TestEvents>();
+      const listener = vi.fn();
+
+      emitter.on("message", listener);
+      emitter.on("message", listener); // duplicate registration attempt
+
+      emitter.off("message", listener);
+      expect(emitter.listenerCount("message")).toBe(0);
+
+      emitter.emit("message", "test");
+      expect(listener).not.toHaveBeenCalled();
+    });
+  });
+
+  //#endregion
+});

package/tests/utils/serial-queue.spec.ts

@@ -0,0 +1,365 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { SerialQueue, SdError } from "@simplysm/core-common";
+
+describe("SerialQueue", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  //#region Sequential execution
+
+  describe("Sequential execution", () => {
+    it("Executes queued functions in order", async () => {
+      const queue = new SerialQueue();
+      const calls: number[] = [];
+
+      queue.run(() => {
+        calls.push(1);
+      });
+      queue.run(() => {
+        calls.push(2);
+      });
+      queue.run(() => {
+        calls.push(3);
+      });
+
+      await vi.advanceTimersByTimeAsync(50);
+
+      expect(calls).toEqual([1, 2, 3]);
+    });
+
+    it("Executes next task after previous task completes", async () => {
+      const queue = new SerialQueue();
+      const calls: number[] = [];
+      const timestamps: number[] = [];
+
+      queue.run(async () => {
+        timestamps.push(Date.now());
+        calls.push(1);
+        await new Promise((r) => setTimeout(r, 50));
+      });
+      queue.run(async () => {
+        timestamps.push(Date.now());
+        calls.push(2);
+        await new Promise((r) => setTimeout(r, 50));
+      });
+
+      await vi.advanceTimersByTimeAsync(200);
+
+      expect(calls).toEqual([1, 2]);
+      // Second task starts after first task completes (exactly 50ms)
+      expect(timestamps[1] - timestamps[0]).toBe(50);
+    });
+
+    it("Executes tasks added during execution sequentially", async () => {
+      const queue = new SerialQueue();
+      const calls: number[] = [];
+
+      queue.run(async () => {
+        calls.push(1);
+        await new Promise((r) => setTimeout(r, 50));
+      });
+
+      // Wait for first task to start
+      await vi.advanceTimersByTimeAsync(10);
+
+      // Add task during execution
+      queue.run(() => {
+        calls.push(2);
+      });
+
+      await vi.advanceTimersByTimeAsync(100);
+
+      expect(calls).toEqual([1, 2]);
+    });
+  });
+
+  //#endregion
+
+  //#region Gap interval
+
+  describe("Gap interval", () => {
+    it("Waits gap duration between tasks when set", async () => {
+      const queue = new SerialQueue(50);
+      const timestamps: number[] = [];
+
+      queue.run(() => {
+        timestamps.push(Date.now());
+      });
+      queue.run(() => {
+        timestamps.push(Date.now());
+      });
+
+      await vi.advanceTimersByTimeAsync(150);
+
+      expect(timestamps).toHaveLength(2);
+      // Exactly 50ms gap between two tasks
+      expect(timestamps[1] - timestamps[0]).toBe(50);
+    });
+
+    it("Executes next task immediately when gap is 0", async () => {
+      const queue = new SerialQueue(0);
+      const timestamps: number[] = [];
+
+      queue.run(() => {
+        timestamps.push(Date.now());
+      });
+      queue.run(() => {
+        timestamps.push(Date.now());
+      });
+
+      await vi.advanceTimersByTimeAsync(50);
+
+      expect(timestamps).toHaveLength(2);
+      // Gap is 0
+      expect(timestamps[1] - timestamps[0]).toBe(0);
+    });
+
+    it("Default gap is 0", async () => {
+      const queue = new SerialQueue();
+      const timestamps: number[] = [];
+
+      queue.run(() => {
+        timestamps.push(Date.now());
+      });
+      queue.run(() => {
+        timestamps.push(Date.now());
+      });
+
+      await vi.advanceTimersByTimeAsync(50);
+
+      expect(timestamps).toHaveLength(2);
+      expect(timestamps[1] - timestamps[0]).toBe(0);
+    });
+
+    it("Does not wait gap after the last task", async () => {
+      const queue = new SerialQueue(100);
+      const timestamps: number[] = [];
+
+      queue.run(() => {
+        timestamps.push(Date.now());
+      });
+      queue.run(() => {
+        timestamps.push(Date.now());
+      });
+
+      // Wait long enough (task1 + gap100 + task2)
+      await vi.advanceTimersByTimeAsync(200);
+
+      // Verify gap was applied (exactly 100ms)
+      expect(timestamps).toHaveLength(2);
+      expect(timestamps[1] - timestamps[0]).toBe(100);
+    });
+  });
+
+  //#endregion
+
+  //#region Error handling
+
+  describe("Error handling", () => {
+    it("Emits error event when error occurs", async () => {
+      const queue = new SerialQueue();
+      const errors: SdError[] = [];
+
+      queue.on("error", (err) => {
+        errors.push(err);
+      });
+
+      queue.run(() => {
+        throw new Error("test error");
+      });
+
+      await vi.advanceTimersByTimeAsync(50);
+
+      expect(errors).toHaveLength(1);
+      expect(errors[0]).toBeInstanceOf(SdError);
+      expect(errors[0].message).toContain("Error occurred while executing queue task");
+      expect(errors[0].message).toContain("test error");
+    });
+
+    it("Continues executing next task even after error", async () => {
+      const queue = new SerialQueue();
+      const calls: number[] = [];
+      const errors: SdError[] = [];
+
+      // Add error listener to prevent unhandled rejection
+      queue.on("error", (err) => {
+        errors.push(err);
+      });
+
+      queue.run(() => {
+        calls.push(1);
+        throw new Error("error");
+      });
+      queue.run(() => {
+        calls.push(2);
+      });
+      queue.run(() => {
+        calls.push(3);
+      });
+
+      await vi.advanceTimersByTimeAsync(100);
+
+      expect(calls).toEqual([1, 2, 3]);
+      expect(errors).toHaveLength(1);
+    });
+
+    it("Executes all tasks even if multiple errors occur", async () => {
+      const queue = new SerialQueue();
+      const calls: number[] = [];
+      const errors: SdError[] = [];
+
+      queue.on("error", (err) => {
+        errors.push(err);
+      });
+
+      queue.run(() => {
+        calls.push(1);
+        throw new Error("error 1");
+      });
+      queue.run(() => {
+        calls.push(2);
+      });
+      queue.run(() => {
+        calls.push(3);
+        throw new Error("error 3");
+      });
+
+      await vi.advanceTimersByTimeAsync(100);
+
+      expect(calls).toEqual([1, 2, 3]);
+      expect(errors).toHaveLength(2);
+      expect(errors[0].message).toContain("error 1");
+      expect(errors[1].message).toContain("error 3");
+    });
+  });
+
+  //#endregion
+
+  //#region dispose
+
+  describe("dispose()", () => {
+    it("Clears pending queue", async () => {
+      const queue = new SerialQueue();
+      const calls: number[] = [];
+
+      // First task is executing
+      queue.run(async () => {
+        calls.push(1);
+        await new Promise((r) => setTimeout(r, 100));
+      });
+
+      // Add pending tasks
+      queue.run(() => {
+        calls.push(2);
+      });
+      queue.run(() => {
+        calls.push(3);
+      });
+
+      // Call dispose after first task starts
+      await vi.advanceTimersByTimeAsync(20);
+      queue.dispose();
+
+      // Wait for all tasks to complete
+      await vi.advanceTimersByTimeAsync(150);
+
+      // Only first task executes (running tasks complete)
+      expect(calls).toEqual([1]);
+    });
+
+    it("New tasks execute normally after dispose", async () => {
+      const queue = new SerialQueue();
+      const calls: number[] = [];
+
+      queue.run(() => {
+        calls.push(1);
+      });
+      queue.dispose();
+
+      // Add new task after dispose
+      queue.run(() => {
+        calls.push(2);
+      });
+
+      await vi.advanceTimersByTimeAsync(50);
+
+      expect(calls).toContain(2);
+    });
+
+    it("Safe to call multiple times", () => {
+      const queue = new SerialQueue();
+
+      // Multiple calls without error
+      queue.dispose();
+      queue.dispose();
+      queue.dispose();
+    });
+
+    it("Automatically disposes with using statement", async () => {
+      const calls: number[] = [];
+      {
+        using queue = new SerialQueue();
+        queue.run(async () => {
+          calls.push(1);
+          await new Promise((r) => setTimeout(r, 100));
+        });
+        queue.run(() => {
+          calls.push(2);
+        });
+        await vi.advanceTimersByTimeAsync(20);
+      } // dispose called automatically when using block ends
+      await vi.advanceTimersByTimeAsync(150);
+      // First task (running) completes, but pending tasks don't execute
+      expect(calls).toEqual([1]);
+    });
+  });
+
+  //#endregion
+
+  //#region Synchronous function support
+
+  describe("Synchronous function support", () => {
+    it("Can execute synchronous functions", async () => {
+      const queue = new SerialQueue();
+      const calls: number[] = [];
+
+      queue.run(() => {
+        calls.push(1);
+      });
+      queue.run(() => {
+        calls.push(2);
+      });
+
+      await vi.advanceTimersByTimeAsync(50);
+
+      expect(calls).toEqual([1, 2]);
+    });
+
+    it("Can mix synchronous and asynchronous functions", async () => {
+      const queue = new SerialQueue();
+      const calls: number[] = [];
+
+      queue.run(() => {
+        calls.push(1);
+      });
+      queue.run(async () => {
+        await new Promise((r) => setTimeout(r, 10));
+        calls.push(2);
+      });
+      queue.run(() => {
+        calls.push(3);
+      });
+
+      await vi.advanceTimersByTimeAsync(100);
+
+      expect(calls).toEqual([1, 2, 3]);
+    });
+  });
+
+  //#endregion
+});