@simplysm/core-common 13.0.74 → 13.0.76

package/tests/types/time.spec.ts

@@ -193,123 +193,8 @@ describe("Time", () => {
 
   //#endregion
 
-  //#region Getters
-
-  describe("Getters", () => {
-    it("Returns hour", () => {
-      const time = new Time(15, 30, 45, 123);
-      expect(time.hour).toBe(15);
-    });
-
-    it("Returns minute", () => {
-      const time = new Time(15, 30, 45, 123);
-      expect(time.minute).toBe(30);
-    });
-
-    it("Returns second", () => {
-      const time = new Time(15, 30, 45, 123);
-      expect(time.second).toBe(45);
-    });
-
-    it("Returns millisecond", () => {
-      const time = new Time(15, 30, 45, 123);
-      expect(time.millisecond).toBe(123);
-    });
-
-    it("Returns tick", () => {
-      const time = new Time(15, 30, 45, 123);
-      const expectedTick = (15 * 60 * 60 + 30 * 60 + 45) * 1000 + 123;
-      expect(time.tick).toBe(expectedTick);
-    });
-  });
-
-  //#endregion
-
-  //#region tick comparison
-
-  describe("tick comparison", () => {
-    it("Same times have same tick", () => {
-      const t1 = new Time(10, 30, 45, 123);
-      const t2 = new Time(10, 30, 45, 123);
-
-      expect(t1.tick).toBe(t2.tick);
-    });
-
-    it("Different times have different ticks", () => {
-      const t1 = new Time(10, 30, 45, 123);
-      const t2 = new Time(10, 30, 45, 124);
-
-      expect(t1.tick).not.toBe(t2.tick);
-    });
-
-    it("Can compare time order by tick", () => {
-      const t1 = new Time(0, 0, 0);
-      const t2 = new Time(12, 30, 0);
-      const t3 = new Time(23, 59, 59);
-
-      expect(t1.tick).toBeLessThan(t2.tick);
-      expect(t2.tick).toBeLessThan(t3.tick);
-    });
-
-    it("Millisecond precision comparison is possible", () => {
-      const t1 = new Time(10, 30, 45, 0);
-      const t2 = new Time(10, 30, 45, 1);
-
-      expect(t2.tick - t1.tick).toBe(1);
-    });
-
-    it("Can calculate time difference by tick", () => {
-      const t1 = new Time(10, 0, 0);
-      const t2 = new Time(11, 0, 0);
-
-      // 1 hour = 3600000ms
-      expect(t2.tick - t1.tick).toBe(3600000);
-    });
-  });
-
-  //#endregion
-
   //#region setX methods (immutable)
 
-  describe("setHour()", () => {
-    it("Returns new instance with hour changed", () => {
-      const time = new Time(15, 30, 45, 123);
-      const newTime = time.setHour(20);
-
-      expect(newTime.hour).toBe(20);
-      expect(newTime.minute).toBe(30);
-      expect(newTime.second).toBe(45);
-      expect(newTime.millisecond).toBe(123);
-      expect(time.hour).toBe(15); // original immutable
-    });
-  });
-
-  describe("setMinute()", () => {
-    it("Returns new instance with minute changed", () => {
-      const time = new Time(15, 30, 45, 123);
-      const newTime = time.setMinute(50);
-
-      expect(newTime.hour).toBe(15);
-      expect(newTime.minute).toBe(50);
-      expect(newTime.second).toBe(45);
-      expect(newTime.millisecond).toBe(123);
-      expect(time.minute).toBe(30); // original immutable
-    });
-  });
-
-  describe("setSecond()", () => {
-    it("Returns new instance with second changed", () => {
-      const time = new Time(15, 30, 45, 123);
-      const newTime = time.setSecond(55);
-
-      expect(newTime.hour).toBe(15);
-      expect(newTime.minute).toBe(30);
-      expect(newTime.second).toBe(55);
-      expect(newTime.millisecond).toBe(123);
-      expect(time.second).toBe(45); // original immutable
-    });
-  });
-
   describe("setMillisecond()", () => {
     it("Returns new instance with millisecond changed", () => {
       const time = new Time(15, 30, 45, 123);
@@ -495,22 +380,6 @@ describe("Time", () => {
   //#region isValid
 
   describe("isValid", () => {
-    it("Valid time returns true", () => {
-      const time = new Time(15, 30, 45);
-      expect(time.isValid).toBe(true);
-    });
-
-    it("Default constructor is valid time", () => {
-      const time = new Time();
-      expect(time.isValid).toBe(true);
-    });
-
-    it("Time created with tick is valid", () => {
-      const tick = (15 * 60 * 60 + 30 * 60 + 45) * 1000;
-      const time = new Time(tick);
-      expect(time.isValid).toBe(true);
-    });
-
     it("Time created with NaN tick has isValid false", () => {
       const time = new Time(NaN);
       expect(time.isValid).toBe(false);

package/tests/utils/bytes-utils.spec.ts

@@ -29,14 +29,6 @@ describe("BytesUtils", () => {
       expect(result.length).toBe(0);
     });
 
-    it("Handles single array", () => {
-      const arr = new Uint8Array([1, 2, 3]);
-
-      const result = concat([arr]);
-
-      expect(result).toEqual(new Uint8Array([1, 2, 3]));
-    });
-
     it("Handles empty Uint8Array in array", () => {
       const arr1 = new Uint8Array([1, 2]);
       const arr2 = new Uint8Array([]);
@@ -106,15 +98,6 @@ describe("BytesUtils", () => {
   });
 
   describe("toHex/fromHex round-trip conversion", () => {
-    it("Round-trip conversion matches", () => {
-      const original = new Uint8Array([0, 127, 128, 255, 1, 2, 3]);
-
-      const hex = toHex(original);
-      const restored = fromHex(hex);
-
-      expect(restored).toEqual(original);
-    });
-
     it("Round-trip conversion matches all byte values (0-255)", () => {
       const original = new Uint8Array(256);
       for (let i = 0; i < 256; i++) {
@@ -190,15 +173,6 @@ describe("BytesUtils", () => {
   });
 
   describe("toBase64/fromBase64 round-trip conversion", () => {
-    it("Round-trip conversion matches", () => {
-      const original = new Uint8Array([0, 127, 128, 255, 1, 2, 3]);
-
-      const base64 = toBase64(original);
-      const restored = fromBase64(base64);
-
-      expect(restored).toEqual(original);
-    });
-
     it("Round-trip conversion matches all byte values (0-255)", () => {
       const original = new Uint8Array(256);
       for (let i = 0; i < 256; i++) {

package/tests/utils/date-format.spec.ts

@@ -228,14 +228,6 @@ describe("formatDateTime", () => {
       it("outputs +00:00 with zzz format", () => {
         expect(formatDate("zzz", { timezoneOffsetMinutes: 0 })).toBe("+00:00");
       });
-
-      it("outputs +00 with zz format", () => {
-        expect(formatDate("zz", { timezoneOffsetMinutes: 0 })).toBe("+00");
-      });
-
-      it("outputs +0 with z format", () => {
-        expect(formatDate("z", { timezoneOffsetMinutes: 0 })).toBe("+0");
-      });
     });
   });
 
@@ -308,17 +300,9 @@ describe("normalizeMonth", () => {
       expect(normalizeMonth(2025, 13, 15)).toEqual({ year: 2026, month: 1, day: 15 });
     });
 
-    it("month 14 becomes February next year", () => {
-      expect(normalizeMonth(2025, 14, 15)).toEqual({ year: 2026, month: 2, day: 15 });
-    });
-
     it("month 25 becomes January 2 years later", () => {
       expect(normalizeMonth(2025, 25, 15)).toEqual({ year: 2027, month: 1, day: 15 });
     });
-
-    it("month 24 becomes December next year", () => {
-      expect(normalizeMonth(2025, 24, 15)).toEqual({ year: 2026, month: 12, day: 15 });
-    });
   });
 
   //#endregion
@@ -334,14 +318,6 @@ describe("normalizeMonth", () => {
       expect(normalizeMonth(2025, -1, 15)).toEqual({ year: 2024, month: 11, day: 15 });
     });
 
-    it("month -11 becomes January previous year", () => {
-      expect(normalizeMonth(2025, -11, 15)).toEqual({ year: 2024, month: 1, day: 15 });
-    });
-
-    it("month -12 becomes December 2 years ago", () => {
-      expect(normalizeMonth(2025, -12, 15)).toEqual({ year: 2023, month: 12, day: 15 });
-    });
-
     it("month -13 becomes November 2 years ago", () => {
       expect(normalizeMonth(2025, -13, 15)).toEqual({ year: 2023, month: 11, day: 15 });
     });

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

@@ -204,15 +204,6 @@ describe("DebounceQueue", () => {
       expect(calls).toEqual([]);
     });
 
-    it("Safe to call multiple times", () => {
-      const queue = new DebounceQueue(50);
-
-      // Multiple calls without error
-      queue.dispose();
-      queue.dispose();
-      queue.dispose();
-    });
-
     it("Auto-disposed with using statement", async () => {
       const calls: number[] = [];
       {
@@ -230,43 +221,4 @@ describe("DebounceQueue", () => {
 
   //#endregion
 
-  //#region Synchronous function support
-
-  describe("Synchronous function support", () => {
-    it("Can execute synchronous function", async () => {
-      const queue = new DebounceQueue(10);
-      const calls: number[] = [];
-
-      queue.run(() => {
-        calls.push(1);
-      });
-
-      await time(50);
-
-      expect(calls).toEqual([1]);
-    });
-
-    it("Can mix synchronous and asynchronous functions", async () => {
-      const queue = new DebounceQueue(10);
-      const calls: number[] = [];
-
-      queue.run(() => {
-        calls.push(1);
-      });
-      queue.run(async () => {
-        await time(10);
-        calls.push(2);
-      });
-      queue.run(() => {
-        calls.push(3);
-      });
-
-      await time(100);
-
-      // Only last request executed
-      expect(calls).toEqual([3]);
-    });
-  });
-
-  //#endregion
 });

package/tests/utils/json.spec.ts

@@ -12,13 +12,6 @@ describe("JsonConvert", () => {
   //#region stringify
 
   describe("stringify()", () => {
-    it("Serializes primitive values", () => {
-      expect(stringify(42)).toBe("42");
-      expect(stringify("hello")).toBe('"hello"');
-      expect(stringify(true)).toBe("true");
-      expect(stringify(null)).toBe("null");
-    });
-
     it("Serializes Date with __type__", () => {
       const date = new Date("2024-03-15T10:30:00.000Z");
       const json = stringify(date);
@@ -122,13 +115,6 @@ describe("JsonConvert", () => {
       expect(parsed.data.data).toBe("__hidden__");
     });
 
-    it("Indents with space option", () => {
-      const obj = { a: 1 };
-      const json = stringify(obj, { space: 2 });
-
-      expect(json).toBe('{\n  "a": 1\n}');
-    });
-
     it("Transforms values with replacer option", () => {
       const obj = { a: 1, b: 2, c: 3 };
       const json = stringify(obj, {
@@ -250,65 +236,6 @@ describe("JsonConvert", () => {
       expect(parsed.converted).toBe(true);
       expect(parsed.date.__type__).toBe("Date");
     });
-
-    it("Serializes getter properties", () => {
-      const obj = {
-        _value: 10,
-        get computed() {
-          return this._value * 2;
-        },
-      };
-
-      const json = stringify(obj);
-      const parsed = JSON.parse(json);
-
-      expect(parsed._value).toBe(10);
-      expect(parsed.computed).toBe(20);
-    });
-
-    it("Serializes empty objects and arrays", () => {
-      expect(stringify({})).toBe("{}");
-      expect(stringify([])).toBe("[]");
-      expect(stringify({ arr: [], obj: {} })).toBe('{"arr":[],"obj":{}}');
-    });
-
-    it("Excludes properties with undefined value", () => {
-      const obj = { a: 1, b: undefined, c: 3 };
-      const json = stringify(obj);
-      const parsed = JSON.parse(json);
-
-      expect(parsed.a).toBe(1);
-      expect("b" in parsed).toBe(false);
-      expect(parsed.c).toBe(3);
-    });
-
-    it("Performance completes in reasonable time", () => {
-      // Create complex test object
-      const createTestObject = () => ({
-        id: 1,
-        name: "test",
-        date: new Date(),
-        nested: {
-          array: [1, 2, 3, new Date(), { deep: true }],
-          map: new Map([["a", 1]]),
-          set: new Set([1, 2, 3]),
-        },
-      });
-
-      const iterations = 1000;
-      const testObj = createTestObject();
-
-      // Measure jsonStringify performance
-      const startCustom = performance.now();
-      for (let i = 0; i < iterations; i++) {
-        stringify(testObj);
-      }
-      const customTime = performance.now() - startCustom;
-
-      // 1000 serializations should complete within 100ms
-      // (includes custom type handling, circular reference detection, etc)
-      expect(customTime).toBeLessThan(100);
-    });
   });
 
   //#endregion
@@ -316,12 +243,6 @@ describe("JsonConvert", () => {
   //#region parse
 
   describe("parse()", () => {
-    it("Deserializes primitive values", () => {
-      expect(parse("42")).toBe(42);
-      expect(parse('"hello"')).toBe("hello");
-      expect(parse("true")).toBe(true);
-    });
-
     it("Converts null to undefined", () => {
       expect(parse("null")).toBe(undefined);
     });

package/tests/utils/number.spec.ts

@@ -10,10 +10,6 @@ describe("number utils", () => {
   //#region numParseInt
 
   describe("numParseInt()", () => {
-    it("Parses numeric string to integer", () => {
-      expect(parseInt("123")).toBe(123);
-    });
-
     it("Parses negative string", () => {
       expect(parseInt("-123")).toBe(-123);
     });
@@ -62,10 +58,6 @@ describe("number utils", () => {
       expect(parseRoundedInt("123.4")).toBe(123);
     });
 
-    it("Integer string returned as-is", () => {
-      expect(parseRoundedInt("123")).toBe(123);
-    });
-
     it("Rounds number type", () => {
       expect(parseRoundedInt(123.7)).toBe(124);
     });
@@ -80,14 +72,6 @@ describe("number utils", () => {
   //#region numParseFloat
 
   describe("numParseFloat()", () => {
-    it("Parses floating string", () => {
-      expect(parseFloat("123.45")).toBe(123.45);
-    });
-
-    it("Parses integer string as float", () => {
-      expect(parseFloat("123")).toBe(123);
-    });
-
     it("Parses negative floating string", () => {
       expect(parseFloat("-123.45")).toBe(-123.45);
     });

package/tests/utils/path.spec.ts

@@ -19,10 +19,6 @@ describe("path utils", () => {
       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("");
     });
@@ -44,10 +40,6 @@ describe("path utils", () => {
     it("Handles filename without path", () => {
       expect(pathBasename("file.txt")).toBe("file.txt");
     });
-
-    it("Empty string returns empty string", () => {
-      expect(pathBasename("")).toBe("");
-    });
   });
 
   describe("pathExtname()", () => {

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

@@ -38,26 +38,6 @@ describe("SdEventEmitter", () => {
       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();
@@ -141,13 +121,6 @@ describe("SdEventEmitter", () => {
       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>();
 

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

@@ -119,41 +119,6 @@ describe("SerialQueue", () => {
       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
@@ -291,15 +256,6 @@ describe("SerialQueue", () => {
       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[] = [];
       {
@@ -324,22 +280,6 @@ describe("SerialQueue", () => {
   //#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[] = [];

package/tests/utils/string.spec.ts

@@ -264,17 +264,9 @@ describe("string utils", () => {
       expect(strInsert("world", 0, "hello ")).toBe("hello world");
     });
 
-    it("inserts in middle of string", () => {
-      expect(strInsert("helloworld", 5, " ")).toBe("hello world");
-    });
-
     it("inserts at end of string", () => {
       expect(strInsert("hello", 5, " world")).toBe("hello world");
     });
-
-    it("inserts into empty string", () => {
-      expect(strInsert("", 0, "hello")).toBe("hello");
-    });
   });
 
   //#endregion

package/tests/utils/template-strings.spec.ts

@@ -39,19 +39,10 @@ describe("template-strings", () => {
       expect(js`x = ${value}`).toBe("x = ");
     });
 
-    it("Handles number value", () => {
-      expect(js`x = ${42}`).toBe("x = 42");
-    });
-
     it("Interpolates multiple values", () => {
       const a = 1;
       const b = 2;
       expect(js`${a} + ${b} = ${a + b}`).toBe("1 + 2 = 3");
     });
-
-    it("Handles object value", () => {
-      const obj = { toString: () => "custom" };
-      expect(js`value = ${obj}`).toBe("value = custom");
-    });
   });
 });