@simplysm/core-common 13.0.75 → 13.0.76

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simplysm/core-common",
-  "version": "13.0.75",
+  "version": "13.0.76",
   "description": "Simplysm package - Core module (common)",
   "author": "simplysm",
   "license": "Apache-2.0",
@@ -28,9 +28,9 @@
     "./dist/index.js"
   ],
   "dependencies": {
-    "@zip.js/zip.js": "^2.8.21",
+    "@zip.js/zip.js": "^2.8.22",
     "consola": "^3.4.2",
-    "fast-xml-parser": "^5.4.1",
+    "fast-xml-parser": "^5.4.2",
     "yaml": "^2.8.2"
   }
 }

package/tests/extensions/array-extension.spec.ts

@@ -2,65 +2,6 @@ import { describe, it, expect } from "vitest";
 import "@simplysm/core-common"; // Enable $ extension
 
 describe("Array prototype extensions", () => {
-  //#region Basic chaining
-
-  describe("Basic chaining", () => {
-    it("Can chain existing array methods", () => {
-      const result = [1, 2, 3, 4, 5].filter((x) => x > 2).map((x) => x * 10);
-
-      expect(result).toEqual([30, 40, 50]);
-    });
-
-    it("Can chain extension methods", () => {
-      const result = [
-        { id: 1, name: "a" },
-        { id: 2, name: "b" },
-      ].toMap((x) => x.id);
-
-      expect(result.get(1)).toEqual({ id: 1, name: "a" });
-      expect(result.get(2)).toEqual({ id: 2, name: "b" });
-    });
-
-    it("Can mix array and extension methods chaining", () => {
-      const users = [
-        { id: 1, name: "Kim", active: true },
-        { id: 2, name: "Lee", active: false },
-        { id: 3, name: "Park", active: true },
-      ];
-
-      const result = users.filter((u) => u.active).toMap((u) => u.id);
-
-      expect(result.size).toBe(2);
-      expect(result.has(1)).toBe(true);
-      expect(result.has(3)).toBe(true);
-      expect(result.has(2)).toBe(false);
-    });
-
-    it("Can chain multiple steps", () => {
-      const result = [1, 2, 3, 4, 5]
-        .filter((x) => x > 1)
-        .map((x) => x * 2)
-        .filter((x) => x < 10)
-        .toMap((x) => x);
-
-      expect(result.size).toBe(3);
-      expect(result.has(4)).toBe(true);
-      expect(result.has(6)).toBe(true);
-      expect(result.has(8)).toBe(true);
-    });
-
-    it("Can access array properties", () => {
-      const arr = [1, 2, 3];
-
-      expect(arr.length).toBe(3);
-      expect(arr[0]).toBe(1);
-      expect(arr[1]).toBe(2);
-      expect(arr[2]).toBe(3);
-    });
-  });
-
-  //#endregion
-
   //#region single
 
   describe("single()", () => {
@@ -85,12 +26,6 @@ describe("Array prototype extensions", () => {
       expect(([] as number[]).single()).toBe(undefined);
       expect(() => [1, 2].single()).toThrow();
     });
-
-    it("Can use single after chaining", () => {
-      const result = [1, 2, 3, 4, 5].filter((x) => x > 3).single((x) => x === 4);
-
-      expect(result).toBe(4);
-    });
   });
 
   //#endregion
@@ -111,14 +46,6 @@ describe("Array prototype extensions", () => {
 
       expect(result).toEqual([2, 4, 6]);
     });
-
-    it("Can use mapAsync after chaining", async () => {
-      const result = await [1, 2, 3, 4, 5]
-        .filter((x) => x > 2)
-        .mapAsync(async (x) => Promise.resolve(x * 10));
-
-      expect(result).toEqual([30, 40, 50]);
-    });
   });
 
   describe("filterAsync()", () => {
@@ -375,61 +302,6 @@ describe("Array prototype extensions", () => {
 
   //#endregion
 
-  //#region ReadonlyArray support
-
-  describe("ReadonlyArray support", () => {
-    it("$ can be used with readonly array", () => {
-      const arr: readonly number[] = [1, 2, 3];
-      const result = arr.filter((x) => x > 1).toMap((x) => x);
-
-      expect(result.size).toBe(2);
-      expect(result.has(2)).toBe(true);
-      expect(result.has(3)).toBe(true);
-    });
-  });
-
-  //#endregion
-
-  //#region Various array method chaining
-
-  describe("Various array method chaining", () => {
-    it("flatMap can be chained", () => {
-      const result = [
-        [1, 2],
-        [3, 4],
-      ]
-        .flatMap((x) => x)
-        .toMap((x) => x);
-
-      expect(result.size).toBe(4);
-    });
-
-    it("slice can be chained", () => {
-      const result = [1, 2, 3, 4, 5].slice(1, 4).toMap((x) => x);
-
-      expect(result.size).toBe(3);
-      expect(result.has(2)).toBe(true);
-      expect(result.has(3)).toBe(true);
-      expect(result.has(4)).toBe(true);
-    });
-
-    it("concat can be chained", () => {
-      const result = [1, 2].concat([3, 4]).toMap((x) => x);
-
-      expect(result.size).toBe(4);
-    });
-
-    it("sort can be chained", () => {
-      const result = [3, 1, 2].sort((a, b) => a - b).toMap((x, i) => i);
-
-      expect(result.get(0)).toBe(1);
-      expect(result.get(1)).toBe(2);
-      expect(result.get(2)).toBe(3);
-    });
-  });
-
-  //#endregion
-
   //#region first, last
 
   describe("first()", () => {
@@ -470,12 +342,6 @@ describe("Array prototype extensions", () => {
       const result = arr.filterExists();
       expect(result).toEqual([1, 2, 3]);
     });
-
-    it("Can be chained", () => {
-      const arr = [1, null, 2, undefined, 3];
-      const result = arr.filterExists().map((x) => x * 2);
-      expect(result).toEqual([2, 4, 6]);
-    });
   });
 
   describe("ofType()", () => {
@@ -582,11 +448,6 @@ describe("Array prototype extensions", () => {
       expect(result).toHaveLength(2);
     });
 
-    it("Can be chained", () => {
-      const result = [1, 2, 2, 3].distinct().map((x) => x * 2);
-      expect(result).toEqual([2, 4, 6]);
-    });
-
     it("Can use custom key with keyFn", () => {
       const arr = [
         { id: 1, name: "a" },
@@ -626,11 +487,6 @@ describe("Array prototype extensions", () => {
       const result = items.orderBy((x) => x.age);
       expect(result.map((x) => x.age)).toEqual([20, 25, 30]);
     });
-
-    it("Can be chained", () => {
-      const result = [3, 1, 2].orderBy().map((x) => x * 2);
-      expect(result).toEqual([2, 4, 6]);
-    });
   });
 
   describe("orderByDesc()", () => {

package/tests/extensions/map-extension.spec.ts

@@ -44,16 +44,6 @@ describe("Map prototype extensions", () => {
       expect(map.get("key")).toBe(50);
     });
 
-    it("Returns existing value if key exists (direct value)", () => {
-      const map = new Map<string, number>();
-      map.set("key", 50);
-
-      const result = map.getOrCreate("key", 100);
-
-      expect(result).toBe(50);
-      expect(map.size).toBe(1);
-    });
-
     it("Can set empty array as default value", () => {
       const map = new Map<string, number[]>();
 
@@ -121,26 +111,6 @@ describe("Map prototype extensions", () => {
 
       expect(map.get("key")).toBe("hello world");
     });
-
-    it("Can update object value", () => {
-      const map = new Map<string, { count: number }>();
-      map.set("key", { count: 5 });
-
-      map.update("key", (v) => ({ count: (v?.count ?? 0) + 1 }));
-
-      expect(map.get("key")).toEqual({ count: 6 });
-    });
-
-    it("Can update multiple times sequentially", () => {
-      const map = new Map<string, number>();
-      map.set("counter", 0);
-
-      map.update("counter", (v) => (v ?? 0) + 1);
-      map.update("counter", (v) => (v ?? 0) + 1);
-      map.update("counter", (v) => (v ?? 0) + 1);
-
-      expect(map.get("counter")).toBe(3);
-    });
   });
 
   //#endregion

package/tests/extensions/set-extension.spec.ts

@@ -22,13 +22,6 @@ describe("Set prototype extensions", () => {
 
       expect(set.size).toBe(4); // 1, 2, 3, 4
     });
-
-    it("Adds multiple items to empty Set", () => {
-      const set = new Set<number>();
-      set.adds(1, 2, 3);
-
-      expect(set.size).toBe(3);
-    });
   });
 
   //#endregion

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

@@ -109,22 +109,6 @@ describe("DateOnly", () => {
       expect(() => DateOnly.parse("invalid-date")).toThrow("Failed to parse date format");
     });
 
-    it("Parses year-end boundary (December 31)", () => {
-      const dateOnly = DateOnly.parse("2024-12-31");
-
-      expect(dateOnly.year).toBe(2024);
-      expect(dateOnly.month).toBe(12);
-      expect(dateOnly.day).toBe(31);
-    });
-
-    it("Parses year-start boundary (January 1)", () => {
-      const dateOnly = DateOnly.parse("2025-01-01");
-
-      expect(dateOnly.year).toBe(2025);
-      expect(dateOnly.month).toBe(1);
-      expect(dateOnly.day).toBe(1);
-    });
-
     it("Parses February 29 in leap year", () => {
       const dateOnly = DateOnly.parse("2024-02-29");
 
@@ -132,14 +116,6 @@ describe("DateOnly", () => {
       expect(dateOnly.month).toBe(2);
       expect(dateOnly.day).toBe(29);
     });
-
-    it("Parses February 28 in leap year", () => {
-      const dateOnly = DateOnly.parse("2024-02-28");
-
-      expect(dateOnly.year).toBe(2024);
-      expect(dateOnly.month).toBe(2);
-      expect(dateOnly.day).toBe(28);
-    });
   });
 
   //#endregion
@@ -147,37 +123,6 @@ describe("DateOnly", () => {
   //#region Getters
 
   describe("Getters", () => {
-    it("Returns year", () => {
-      const dateOnly = new DateOnly(2025, 1, 6);
-      expect(dateOnly.year).toBe(2025);
-    });
-
-    it("Returns month (1-12)", () => {
-      const dateOnly = new DateOnly(2025, 1, 6);
-      expect(dateOnly.month).toBe(1);
-    });
-
-    it("Returns day", () => {
-      const dateOnly = new DateOnly(2025, 1, 6);
-      expect(dateOnly.day).toBe(6);
-    });
-
-    it("Returns tick", () => {
-      const dateOnly = new DateOnly(2025, 1, 6);
-      expect(dateOnly.tick).toBe(new Date(2025, 0, 6).getTime());
-    });
-
-    it("Returns dayOfWeek (Sunday-Saturday: 0-6)", () => {
-      // 2025-01-06 is Monday (1)
-      const dateOnly = new DateOnly(2025, 1, 6);
-      expect(dateOnly.dayOfWeek).toBe(1);
-    });
-
-    it("Returns isValid", () => {
-      const dateOnly = new DateOnly(2025, 1, 6);
-      expect(dateOnly.isValid).toBe(true);
-    });
-
     it("Invalid date returns isValid as false", () => {
       const dateOnly = new DateOnly(NaN);
       expect(dateOnly.isValid).toBe(false);
@@ -257,18 +202,6 @@ describe("DateOnly", () => {
     });
   });
 
-  describe("setDay()", () => {
-    it("Returns new instance with day changed", () => {
-      const dateOnly = new DateOnly(2025, 1, 6);
-      const newDateOnly = dateOnly.setDay(15);
-
-      expect(newDateOnly.year).toBe(2025);
-      expect(newDateOnly.month).toBe(1);
-      expect(newDateOnly.day).toBe(15);
-      expect(dateOnly.day).toBe(6); // original immutable
-    });
-  });
-
   //#endregion
 
   //#region addX methods (immutable)
@@ -379,44 +312,6 @@ describe("DateOnly", () => {
 
   //#endregion
 
-  //#region tick comparison
-
-  describe("tick comparison", () => {
-    it("Same dates have same tick", () => {
-      const d1 = new DateOnly(2025, 3, 15);
-      const d2 = new DateOnly(2025, 3, 15);
-
-      expect(d1.tick).toBe(d2.tick);
-    });
-
-    it("Different dates have different ticks", () => {
-      const d1 = new DateOnly(2025, 3, 15);
-      const d2 = new DateOnly(2025, 3, 16);
-
-      expect(d1.tick).not.toBe(d2.tick);
-    });
-
-    it("Can compare date order by tick", () => {
-      const d1 = new DateOnly(2025, 1, 1);
-      const d2 = new DateOnly(2025, 6, 15);
-      const d3 = new DateOnly(2025, 12, 31);
-
-      expect(d1.tick).toBeLessThan(d2.tick);
-      expect(d2.tick).toBeLessThan(d3.tick);
-    });
-
-    it("Can compare dates with different years by tick", () => {
-      const d2024 = new DateOnly(2024, 12, 31);
-      const d2025 = new DateOnly(2025, 1, 1);
-
-      expect(d2024.tick).toBeLessThan(d2025.tick);
-    });
-  });
-
-  //#endregion
-
-  //#endregion
-
   //#region Week calculation
 
   describe("getWeekSeqOfYear()", () => {

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", () => {