@simplysm/core-common 13.0.75 → 13.0.77

package/tests/types/date-time.spec.ts

@@ -48,22 +48,6 @@ describe("DateTime", () => {
       expect(dt.day).toBe(29);
       expect(dt.isValid).toBe(true);
     });
-
-    it("non-leap year February 29th auto-adjusts to March 1st (JS Date behavior)", () => {
-      const dt = new DateTime(2023, 2, 29);
-
-      expect(dt.year).toBe(2023);
-      expect(dt.month).toBe(3);
-      expect(dt.day).toBe(1);
-    });
-
-    it("invalid month (13) auto-adjusts to next year January 1st (JS Date behavior)", () => {
-      const dt = new DateTime(2024, 13, 1);
-
-      expect(dt.year).toBe(2025);
-      expect(dt.month).toBe(1);
-      expect(dt.day).toBe(1);
-    });
   });
 
   describe("parse()", () => {
@@ -219,42 +203,9 @@ describe("DateTime", () => {
       expect(result.month).toBe(11);
       expect(result.day).toBe(15);
     });
-
-    it("setMonth(25) returns January 2 years later", () => {
-      const dt = new DateTime(2024, 6, 15);
-      const result = dt.setMonth(25);
-
-      expect(result.year).toBe(2026);
-      expect(result.month).toBe(1);
-      expect(result.day).toBe(15);
-    });
-
-    it("setMonth(-13) returns November 2 years earlier", () => {
-      const dt = new DateTime(2024, 6, 15);
-      const result = dt.setMonth(-13);
-
-      expect(result.year).toBe(2022);
-      expect(result.month).toBe(11);
-      expect(result.day).toBe(15);
-    });
   });
 
   describe("Arithmetic Methods", () => {
-    it("addYears", () => {
-      const dt1 = new DateTime(2024, 3, 15);
-      const dt2 = dt1.addYears(2);
-
-      expect(dt2.year).toBe(2026);
-      expect(dt1.year).toBe(2024); // original unchanged
-    });
-
-    it("addMonths", () => {
-      const dt1 = new DateTime(2024, 3, 15);
-      const dt2 = dt1.addMonths(3);
-
-      expect(dt2.month).toBe(6);
-    });
-
     it("addDays", () => {
       const dt1 = new DateTime(2024, 3, 15);
       const dt2 = dt1.addDays(20);
@@ -263,13 +214,6 @@ describe("DateTime", () => {
       expect(dt2.day).toBe(4);
     });
 
-    it("addHours", () => {
-      const dt1 = new DateTime(2024, 3, 15, 10);
-      const dt2 = dt1.addHours(5);
-
-      expect(dt2.hour).toBe(15);
-    });
-
     it("addMinutes", () => {
       const dt1 = new DateTime(2024, 3, 15, 10, 30);
       const dt2 = dt1.addMinutes(45);
@@ -277,76 +221,6 @@ describe("DateTime", () => {
       expect(dt2.hour).toBe(11);
       expect(dt2.minute).toBe(15);
     });
-
-    it("addSeconds", () => {
-      const dt1 = new DateTime(2024, 3, 15, 10, 30, 45);
-      const dt2 = dt1.addSeconds(30);
-
-      expect(dt2.minute).toBe(31);
-      expect(dt2.second).toBe(15);
-    });
-
-    it("addMilliseconds", () => {
-      const dt1 = new DateTime(2024, 3, 15, 10, 30, 45, 500);
-      const dt2 = dt1.addMilliseconds(600);
-
-      expect(dt2.second).toBe(46);
-      expect(dt2.millisecond).toBe(100);
-    });
-  });
-
-  //#region tick comparison
-
-  describe("tick comparison", () => {
-    it("same datetime has same tick", () => {
-      const dt1 = new DateTime(2025, 3, 15, 10, 30, 45, 123);
-      const dt2 = new DateTime(2025, 3, 15, 10, 30, 45, 123);
-
-      expect(dt1.tick).toBe(dt2.tick);
-    });
-
-    it("different datetime has different tick", () => {
-      const dt1 = new DateTime(2025, 3, 15, 10, 30, 45, 123);
-      const dt2 = new DateTime(2025, 3, 15, 10, 30, 45, 124);
-
-      expect(dt1.tick).not.toBe(dt2.tick);
-    });
-
-    it("can compare datetime order using tick", () => {
-      const dt1 = new DateTime(2025, 1, 1, 0, 0, 0);
-      const dt2 = new DateTime(2025, 6, 15, 12, 30, 0);
-      const dt3 = new DateTime(2025, 12, 31, 23, 59, 59);
-
-      expect(dt1.tick).toBeLessThan(dt2.tick);
-      expect(dt2.tick).toBeLessThan(dt3.tick);
-    });
-
-    it("can compare millisecond precision", () => {
-      const dt1 = new DateTime(2025, 3, 15, 10, 30, 45, 0);
-      const dt2 = new DateTime(2025, 3, 15, 10, 30, 45, 1);
-
-      expect(dt2.tick - dt1.tick).toBe(1);
-    });
-  });
-
-  //#endregion
-
-  describe("timezoneOffsetMinutes", () => {
-    it("returns current timezone offset", () => {
-      const dt = new DateTime(2024, 3, 15, 10, 30, 45);
-      const expected = new Date().getTimezoneOffset() * -1;
-
-      expect(dt.timezoneOffsetMinutes).toBe(expected);
-    });
-  });
-
-  describe("dayOfWeek", () => {
-    it("returns day of week (Sun~Sat: 0~6)", () => {
-      // 2024-03-15 is Friday (5)
-      const dt = new DateTime(2024, 3, 15);
-
-      expect(dt.dayOfWeek).toBe(5);
-    });
   });
 
   describe("isValid", () => {
@@ -359,25 +233,6 @@ describe("DateTime", () => {
       const dt = new DateTime(NaN);
       expect(dt.isValid).toBe(false);
     });
-
-    it("default constructor is valid datetime", () => {
-      const dt = new DateTime();
-      expect(dt.isValid).toBe(true);
-    });
-  });
-
-  describe("toFormatString()", () => {
-    it("yyyy-MM-dd format", () => {
-      const dt = new DateTime(2024, 3, 5);
-
-      expect(dt.toFormatString("yyyy-MM-dd")).toBe("2024-03-05");
-    });
-
-    it("HH:mm:ss format", () => {
-      const dt = new DateTime(2024, 3, 5, 9, 5, 3);
-
-      expect(dt.toFormatString("HH:mm:ss")).toBe("09:05:03");
-    });
   });
 
   describe("toString()", () => {

package/tests/types/lazy-gc-map.spec.ts

@@ -13,27 +13,6 @@ describe("LazyGcMap", () => {
   //#region Basic Map operations
 
   describe("Basic Map operations", () => {
-    it("Stores and retrieves values with set/get", () => {
-      const map = new LazyGcMap<string, number>({
-        gcInterval: 1000,
-        expireTime: 5000,
-      });
-
-      map.set("key1", 100);
-      expect(map.get("key1")).toBe(100);
-    });
-
-    it("Checks key existence with has", () => {
-      const map = new LazyGcMap<string, number>({
-        gcInterval: 1000,
-        expireTime: 5000,
-      });
-
-      map.set("key1", 100);
-      expect(map.has("key1")).toBe(true);
-      expect(map.has("key2")).toBe(false);
-    });
-
     it("Deletes values with delete", () => {
       const map = new LazyGcMap<string, number>({
         gcInterval: 1000,
@@ -61,30 +40,6 @@ describe("LazyGcMap", () => {
       expect(map.has("key1")).toBe(false);
       expect(map.has("key2")).toBe(false);
     });
-
-    it("Gets size with size property", () => {
-      const map = new LazyGcMap<string, number>({
-        gcInterval: 1000,
-        expireTime: 5000,
-      });
-
-      expect(map.size).toBe(0);
-      map.set("key1", 100);
-      expect(map.size).toBe(1);
-      map.set("key2", 200);
-      expect(map.size).toBe(2);
-      map.delete("key1");
-      expect(map.size).toBe(1);
-    });
-
-    it("Returns undefined for non-existent keys", () => {
-      const map = new LazyGcMap<string, number>({
-        gcInterval: 1000,
-        expireTime: 5000,
-      });
-
-      expect(map.get("nonexistent")).toBe(undefined);
-    });
   });
 
   //#endregion
@@ -493,22 +448,6 @@ describe("LazyGcMap", () => {
       expect(map.get("key2")).toBe(200);
     });
 
-    it("clear is safe to call multiple times", () => {
-      const map = new LazyGcMap<string, number>({
-        gcInterval: 1000,
-        expireTime: 5000,
-      });
-
-      map.set("key1", 100);
-
-      // Safe to call multiple times
-      map.clear();
-      map.clear();
-      map.clear();
-
-      expect(map.size).toBe(0);
-    });
-
     it("GC works normally after clear", async () => {
       const map = new LazyGcMap<string, number>({
         gcInterval: 100,
@@ -529,31 +468,6 @@ describe("LazyGcMap", () => {
 
   //#endregion
 
-  //#region SharedArrayBuffer support
-
-  describe("SharedArrayBuffer support", () => {
-    it("Can use SharedArrayBuffer as value", () => {
-      // SharedArrayBuffer may be disabled for security in some environments
-      if (typeof SharedArrayBuffer === "undefined") {
-        expect(true).toBe(true); // Skip if not supported
-        return;
-      }
-
-      const map = new LazyGcMap<string, SharedArrayBuffer>({
-        gcInterval: 1000,
-        expireTime: 5000,
-      });
-
-      const buffer = new SharedArrayBuffer(16);
-      map.set("key1", buffer);
-
-      expect(map.get("key1")).toBe(buffer);
-      expect(map.get("key1")?.byteLength).toBe(16);
-    });
-  });
-
-  //#endregion
-
   //#region Iterator
 
   describe("Iterator", () => {

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/types/uuid.spec.ts

@@ -2,9 +2,9 @@ import { describe, it, expect } from "vitest";
 import { Uuid } from "@simplysm/core-common";
 
 describe("Uuid", () => {
-  describe("new()", () => {
+  describe("generate()", () => {
     it("Generates valid UUID v4 format", () => {
-      const uuid = Uuid.new();
+      const uuid = Uuid.generate();
       const str = uuid.toString();
 
       // UUID v4 format: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
@@ -12,8 +12,8 @@ describe("Uuid", () => {
     });
 
     it("Generates new UUID each time", () => {
-      const uuid1 = Uuid.new();
-      const uuid2 = Uuid.new();
+      const uuid1 = Uuid.generate();
+      const uuid2 = Uuid.generate();
 
       expect(uuid1.toString()).not.toBe(uuid2.toString());
     });