@simplysm/core-common 13.0.75 → 13.0.77

package/src/utils/path.ts

@@ -11,7 +11,7 @@
  * Combine paths (path.join replacement)
  * @note Supports POSIX style paths only (slash `/`)
  */
-export function pathJoin(...segments: string[]): string {
+export function join(...segments: string[]): string {
   return segments
     .map((s, i) => (i === 0 ? s.replace(/\/+$/, "") : s.replace(/^\/+|\/+$/g, "")))
     .filter(Boolean)
@@ -21,7 +21,7 @@ export function pathJoin(...segments: string[]): string {
 /**
  * Extract filename (path.basename replacement)
  */
-export function pathBasename(filePath: string, ext?: string): string {
+export function basename(filePath: string, ext?: string): string {
   const name = filePath.split("/").pop() ?? "";
   if (ext != null && ext !== "" && name.endsWith(ext)) {
     return name.slice(0, -ext.length);
@@ -33,7 +33,7 @@ export function pathBasename(filePath: string, ext?: string): string {
  * Extract file extension (path.extname replacement)
  * @note Hidden files (e.g., `.gitignore`) return empty string (same as Node.js path.extname)
  */
-export function pathExtname(filePath: string): string {
+export function extname(filePath: string): string {
   const name = filePath.split("/").pop() ?? "";
   const dotIndex = name.lastIndexOf(".");
   return dotIndex > 0 ? name.slice(dotIndex) : "";

package/src/utils/primitive.ts

@@ -20,7 +20,7 @@ import type { PrimitiveTypeMap, PrimitiveTypeStr } from "../common.types";
  * getPrimitiveTypeStr(new DateTime()) // "DateTime"
  * getPrimitiveTypeStr(new Uint8Array()) // "Bytes"
  */
-export function getPrimitiveTypeStr(value: PrimitiveTypeMap[PrimitiveTypeStr]): PrimitiveTypeStr {
+export function typeStr(value: PrimitiveTypeMap[PrimitiveTypeStr]): PrimitiveTypeStr {
   if (typeof value === "string") return "string";
   if (typeof value === "number") return "number";
   if (typeof value === "boolean") return "boolean";

package/src/utils/str.ts

@@ -28,10 +28,10 @@ const suffixTable = {
  *   - `"라"`: 이라/라 (ira/ra - copula particle)
  *
  * @example
- * koreanGetSuffix("Apple", "을") // "를"
- * koreanGetSuffix("책", "이") // "이"
+ * getKoreanSuffix("Apple", "을") // "를"
+ * getKoreanSuffix("책", "이") // "이"
  */
-export function koreanGetSuffix(
+export function getKoreanSuffix(
   text: string,
   type: "을" | "은" | "이" | "와" | "랑" | "로" | "라",
 ): string {
@@ -147,10 +147,10 @@ const fullWidthCharRegex = new RegExp(`[${Object.keys(fullWidthCharMap).join("")
  * - Full-width parentheses (（） → ())
  *
  * @example
- * strReplaceFullWidth("Ａ１２３") // "A123"
- * strReplaceFullWidth("（株）") // "(株)"
+ * replaceFullWidth("Ａ１２３") // "A123"
+ * replaceFullWidth("（株）") // "(株)"
  */
-export function strReplaceFullWidth(str: string): string {
+export function replaceFullWidth(str: string): string {
   return str.replace(fullWidthCharRegex, (char) => fullWidthCharMap[char] ?? char);
 }
 
@@ -164,7 +164,7 @@ export function strReplaceFullWidth(str: string): string {
  * @example "hello_world" → "HelloWorld"
  * @example "hello.world" → "HelloWorld"
  */
-export function strToPascalCase(str: string): string {
+export function toPascalCase(str: string): string {
   return str
     .replace(/[-._][a-z]/g, (m) => m[1].toUpperCase())
     .replace(/^[a-z]/, (m) => m.toUpperCase());
@@ -176,7 +176,7 @@ export function strToPascalCase(str: string): string {
  * @example "hello_world" → "helloWorld"
  * @example "HelloWorld" → "helloWorld"
  */
-export function strToCamelCase(str: string): string {
+export function toCamelCase(str: string): string {
   return str
     .replace(/[-._][a-z]/g, (m) => m[1].toUpperCase())
     .replace(/^[A-Z]/, (m) => m.toLowerCase());
@@ -192,7 +192,7 @@ export function strToCamelCase(str: string): string {
  * @example "Hello-World" → "hello--world" (existing separators are preserved)
  * @example "XMLParser" → "x-m-l-parser" (consecutive uppercase letters are separated)
  */
-export function strToKebabCase(str: string): string {
+export function toKebabCase(str: string): string {
   return toCaseWithSeparator(str, "-");
 }
 
@@ -206,7 +206,7 @@ export function strToKebabCase(str: string): string {
  * @example "Hello_World" → "hello__world" (existing separators are preserved)
  * @example "XMLParser" → "x_m_l_parser" (consecutive uppercase letters are separated)
  */
-export function strToSnakeCase(str: string): string {
+export function toSnakeCase(str: string): string {
   return toCaseWithSeparator(str, "_");
 }
 
@@ -228,7 +228,7 @@ function toCaseWithSeparator(str: string, separator: string): string {
  *
  * @example
  * const name: string | undefined = getValue();
- * if (strIsNullOrEmpty(name)) {
+ * if (isNullOrEmpty(name)) {
  *   // name: "" | undefined
  *   console.log("Name is empty");
  * } else {
@@ -236,7 +236,7 @@ function toCaseWithSeparator(str: string, separator: string): string {
  *   console.log(`Name: ${name}`);
  * }
  */
-export function strIsNullOrEmpty(str: string | undefined): str is "" | undefined {
+export function isNullOrEmpty(str: string | undefined): str is "" | undefined {
   return str == null || str === "";
 }
 
@@ -249,11 +249,11 @@ export function strIsNullOrEmpty(str: string | undefined): str is "" | undefined
  * @returns A new string with the insertion applied
  *
  * @example
- * strInsert("Hello World", 5, ","); // "Hello, World"
- * strInsert("abc", 0, "X"); // "Xabc"
- * strInsert("abc", 3, "X"); // "abcX"
+ * insert("Hello World", 5, ","); // "Hello, World"
+ * insert("abc", 0, "X"); // "Xabc"
+ * insert("abc", 3, "X"); // "abcX"
  */
-export function strInsert(str: string, index: number, insertString: string): string {
+export function insert(str: string, index: number, insertString: string): string {
   return str.substring(0, index) + insertString + str.substring(index);
 }
 

package/src/utils/transferable.ts

@@ -32,7 +32,7 @@ type Transferable = ArrayBuffer;
  * worker.postMessage(result, transferList);
  *
  * // Receive data from Worker
- * const decoded = transferableDecode(event.data);
+ * const decoded = decode(event.data);
  */
 
 //#region encode
@@ -43,7 +43,7 @@ type Transferable = ArrayBuffer;
  *
  * @throws TypeError if circular reference is detected
  */
-export function transferableEncode(obj: unknown): {
+export function encode(obj: unknown): {
   result: unknown;
   transferList: Transferable[];
 } {
@@ -204,7 +204,7 @@ function encodeImpl(
  * Convert serialized objects to objects using Simplysm types
  * Deserialize data received from a Worker
  */
-export function transferableDecode(obj: unknown): unknown {
+export function decode(obj: unknown): unknown {
   if (obj == null) return obj;
 
   // 1. Restore special types from tagged objects
@@ -239,22 +239,22 @@ export function transferableDecode(obj: unknown): unknown {
       err.stack = errorData.stack;
 
       if (errorData.code !== undefined) err.code = errorData.code;
-      if (errorData.cause !== undefined) (err as Error).cause = transferableDecode(errorData.cause);
-      if (errorData.detail !== undefined) err.detail = transferableDecode(errorData.detail);
+      if (errorData.cause !== undefined) (err as Error).cause = decode(errorData.cause);
+      if (errorData.detail !== undefined) err.detail = decode(errorData.detail);
       return err;
     }
   }
 
   // 2. Array recursion
   if (Array.isArray(obj)) {
-    return obj.map((item) => transferableDecode(item));
+    return obj.map((item) => decode(item));
   }
 
   // 3. Map recursion
   if (obj instanceof Map) {
     const newMap = new Map<unknown, unknown>();
     for (const [k, v] of obj) {
-      newMap.set(transferableDecode(k), transferableDecode(v));
+      newMap.set(decode(k), decode(v));
     }
     return newMap;
   }
@@ -263,7 +263,7 @@ export function transferableDecode(obj: unknown): unknown {
   if (obj instanceof Set) {
     const newSet = new Set<unknown>();
     for (const v of obj) {
-      newSet.add(transferableDecode(v));
+      newSet.add(decode(v));
     }
     return newSet;
   }
@@ -273,7 +273,7 @@ export function transferableDecode(obj: unknown): unknown {
     const record = obj as Record<string, unknown>;
     const result: Record<string, unknown> = {};
     for (const key of Object.keys(record)) {
-      result[key] = transferableDecode(record[key]);
+      result[key] = decode(record[key]);
     }
     return result;
   }

package/src/utils/wait.ts

@@ -15,7 +15,7 @@ import { TimeoutError } from "../errors/timeout-error";
  * await waitUntil(() => someCondition, 100, 3);
  * @throws TimeoutError when maximum number of attempts is exceeded
  */
-export async function waitUntil(
+export async function until(
   forwarder: () => boolean | Promise<boolean>,
   milliseconds?: number,
   maxCount?: number,
@@ -27,7 +27,7 @@ export async function waitUntil(
       throw new TimeoutError(count);
     }
 
-    await waitTime(milliseconds ?? 100);
+    await time(milliseconds ?? 100);
   }
 }
 
@@ -35,6 +35,6 @@ export async function waitUntil(
  * Wait for a specified amount of time
  * @param millisecond Wait time (ms)
  */
-export async function waitTime(millisecond: number): Promise<void> {
+export async function time(millisecond: number): Promise<void> {
   return new Promise<void>((resolve) => setTimeout(resolve, millisecond));
 }

package/src/utils/xml.ts

@@ -19,7 +19,7 @@ import { XMLBuilder, XMLParser } from "fast-xml-parser";
  * xmlParse('<root id="1"><item>hello</item></root>');
  * // { root: { $: { id: "1" }, item: [{ _: "hello" }] } }
  */
-export function xmlParse(str: string, options?: { stripTagPrefix?: boolean }): unknown {
+export function parse(str: string, options?: { stripTagPrefix?: boolean }): unknown {
   const result = new XMLParser({
     ignoreAttributes: false,
     attributeNamePrefix: "",
@@ -53,7 +53,7 @@ export function xmlParse(str: string, options?: { stripTagPrefix?: boolean }): u
  * });
  * // '<root id="1"><item>hello</item><item>world</item></root>'
  */
-export function xmlStringify(obj: unknown, options?: XmlBuilderOptions): string {
+export function stringify(obj: unknown, options?: XmlBuilderOptions): string {
   return new XMLBuilder({
     ignoreAttributes: false,
     attributeNamePrefix: "",

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()", () => {
@@ -269,6 +196,7 @@ describe("Array prototype extensions", () => {
   describe("diffs()", () => {
     it("Analyzes differences between arrays", () => {
       interface Item {
+        [key: string]: unknown;
         id: number;
         value: string;
       }
@@ -287,13 +215,13 @@ describe("Array prototype extensions", () => {
 
       const result = source.diffs(target, { keys: ["id"] });
 
-      const deleted = result.find((d) => d.source?.id === 1);
+      const deleted = result.find((d) => d.source?.["id"] === 1);
       expect(deleted?.target).toBe(undefined);
 
-      const updated = result.find((d) => d.source?.id === 3);
-      expect(updated?.target?.value).toBe("changed");
+      const updated = result.find((d) => d.source?.["id"] === 3);
+      expect(updated?.target?.["value"]).toBe("changed");
 
-      const inserted = result.find((d) => d.target?.id === 4);
+      const inserted = result.find((d) => d.target?.["id"] === 4);
       expect(inserted?.source).toBe(undefined);
     });
   });
@@ -353,6 +281,7 @@ describe("Array prototype extensions", () => {
   describe("merge()", () => {
     it("Merges modified items", () => {
       interface Item {
+        [key: string]: unknown;
         id: number;
         value: string;
       }
@@ -369,62 +298,7 @@ describe("Array prototype extensions", () => {
       const result = source.merge(target, { keys: ["id"] });
 
       expect(result).toHaveLength(2);
-      expect(result.find((r) => r.id === 2)?.value).toBe("changed");
-    });
-  });
-
-  //#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);
+      expect(result.find((r) => r["id"] === 2)?.["value"]).toBe("changed");
     });
   });
 
@@ -470,12 +344,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 +450,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 +489,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()", () => {