@simplysm/core-common 13.0.99 → 14.0.1

package/tests/utils/path.spec.ts

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

package/tests/utils/primitive.spec.ts

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

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

@@ -1,189 +0,0 @@
-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("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("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

@@ -1,305 +0,0 @@
-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);
-    });
-
-  });
-
-  //#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("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 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
-});