@simplysm/core-common 13.0.76 → 13.0.78

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

@@ -196,6 +196,7 @@ describe("Array prototype extensions", () => {
   describe("diffs()", () => {
     it("Analyzes differences between arrays", () => {
       interface Item {
+        [key: string]: unknown;
         id: number;
         value: string;
       }
@@ -214,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);
     });
   });
@@ -280,6 +281,7 @@ describe("Array prototype extensions", () => {
   describe("merge()", () => {
     it("Merges modified items", () => {
       interface Item {
+        [key: string]: unknown;
         id: number;
         value: string;
       }
@@ -296,7 +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");
+      expect(result.find((r) => r["id"] === 2)?.["value"]).toBe("changed");
     });
   });
 

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());
     });

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

@@ -1,29 +1,22 @@
 import { describe, it, expect } from "vitest";
-import {
-  ArgumentError,
-  bytesConcat as concat,
-  bytesToHex as toHex,
-  bytesFromHex as fromHex,
-  bytesToBase64 as toBase64,
-  bytesFromBase64 as fromBase64,
-} from "@simplysm/core-common";
+import { ArgumentError, bytes } from "@simplysm/core-common";
 
 describe("BytesUtils", () => {
   //#region concat
 
-  describe("concat()", () => {
+  describe("bytes.concat()", () => {
     it("Concatenates multiple Uint8Arrays", () => {
       const arr1 = new Uint8Array([1, 2, 3]);
       const arr2 = new Uint8Array([4, 5]);
       const arr3 = new Uint8Array([6, 7, 8, 9]);
 
-      const result = concat([arr1, arr2, arr3]);
+      const result = bytes.concat([arr1, arr2, arr3]);
 
       expect(result).toEqual(new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9]));
     });
 
     it("Handles empty array", () => {
-      const result = concat([]);
+      const result = bytes.concat([]);
 
       expect(result).toEqual(new Uint8Array([]));
       expect(result.length).toBe(0);
@@ -34,7 +27,7 @@ describe("BytesUtils", () => {
       const arr2 = new Uint8Array([]);
       const arr3 = new Uint8Array([3, 4]);
 
-      const result = concat([arr1, arr2, arr3]);
+      const result = bytes.concat([arr1, arr2, arr3]);
 
       expect(result).toEqual(new Uint8Array([1, 2, 3, 4]));
     });
@@ -44,56 +37,56 @@ describe("BytesUtils", () => {
 
   //#region toHex/fromHex
 
-  describe("toHex()", () => {
+  describe("bytes.toHex()", () => {
     it("Converts Uint8Array to hex string", () => {
-      const bytes = new Uint8Array([0, 1, 15, 16, 255]);
+      const data = new Uint8Array([0, 1, 15, 16, 255]);
 
-      const result = toHex(bytes);
+      const result = bytes.toHex(data);
 
       expect(result).toBe("00010f10ff");
     });
 
     it("Handles empty array", () => {
-      const result = toHex(new Uint8Array([]));
+      const result = bytes.toHex(new Uint8Array([]));
 
       expect(result).toBe("");
     });
 
     it("Handles single byte", () => {
-      expect(toHex(new Uint8Array([0]))).toBe("00");
-      expect(toHex(new Uint8Array([255]))).toBe("ff");
+      expect(bytes.toHex(new Uint8Array([0]))).toBe("00");
+      expect(bytes.toHex(new Uint8Array([255]))).toBe("ff");
     });
   });
 
-  describe("fromHex()", () => {
+  describe("bytes.fromHex()", () => {
     it("Converts hex string to Uint8Array", () => {
-      const result = fromHex("00010f10ff");
+      const result = bytes.fromHex("00010f10ff");
 
       expect(result).toEqual(new Uint8Array([0, 1, 15, 16, 255]));
     });
 
     it("Handles empty string", () => {
-      const result = fromHex("");
+      const result = bytes.fromHex("");
 
       expect(result).toEqual(new Uint8Array([]));
     });
 
     it("Handles uppercase hex", () => {
-      const result = fromHex("FF0A");
+      const result = bytes.fromHex("FF0A");
 
       expect(result).toEqual(new Uint8Array([255, 10]));
     });
 
     it("Throws error for odd-length string", () => {
-      expect(() => fromHex("abc")).toThrow(ArgumentError);
-      expect(() => fromHex("a")).toThrow(ArgumentError);
-      expect(() => fromHex("12345")).toThrow(ArgumentError);
+      expect(() => bytes.fromHex("abc")).toThrow(ArgumentError);
+      expect(() => bytes.fromHex("a")).toThrow(ArgumentError);
+      expect(() => bytes.fromHex("12345")).toThrow(ArgumentError);
     });
 
     it("Throws error for invalid hex characters", () => {
-      expect(() => fromHex("zz")).toThrow(ArgumentError);
-      expect(() => fromHex("gh")).toThrow(ArgumentError);
-      expect(() => fromHex("12g4")).toThrow(ArgumentError);
+      expect(() => bytes.fromHex("zz")).toThrow(ArgumentError);
+      expect(() => bytes.fromHex("gh")).toThrow(ArgumentError);
+      expect(() => bytes.fromHex("12g4")).toThrow(ArgumentError);
     });
   });
 
@@ -104,8 +97,8 @@ describe("BytesUtils", () => {
         original[i] = i;
       }
 
-      const hex = toHex(original);
-      const restored = fromHex(hex);
+      const hex = bytes.toHex(original);
+      const restored = bytes.fromHex(hex);
 
       expect(restored).toEqual(original);
     });
@@ -115,60 +108,60 @@ describe("BytesUtils", () => {
 
   //#region toBase64/fromBase64
 
-  describe("toBase64()", () => {
+  describe("bytes.toBase64()", () => {
     it("Handles empty array", () => {
-      expect(toBase64(new Uint8Array([]))).toBe("");
+      expect(bytes.toBase64(new Uint8Array([]))).toBe("");
     });
 
     it("Converts general data", () => {
-      expect(toBase64(new Uint8Array([72, 101, 108, 108, 111]))).toBe("SGVsbG8=");
+      expect(bytes.toBase64(new Uint8Array([72, 101, 108, 108, 111]))).toBe("SGVsbG8=");
     });
 
     it("Handles large data (1MB) without stack overflow", () => {
       const data = new Uint8Array(1024 * 1024);
-      expect(() => toBase64(data)).not.toThrow();
+      expect(() => bytes.toBase64(data)).not.toThrow();
     });
 
     it("Handles case with no padding needed", () => {
       // Multiple of 3 length - no padding
-      expect(toBase64(new Uint8Array([1, 2, 3]))).toBe("AQID");
+      expect(bytes.toBase64(new Uint8Array([1, 2, 3]))).toBe("AQID");
     });
 
     it("Handles case with single padding needed", () => {
       // Remainder 2 when divided by 3 - 1 padding
-      expect(toBase64(new Uint8Array([1, 2]))).toBe("AQI=");
+      expect(bytes.toBase64(new Uint8Array([1, 2]))).toBe("AQI=");
     });
 
     it("Handles case with double padding needed", () => {
       // Remainder 1 when divided by 3 - 2 padding
-      expect(toBase64(new Uint8Array([1]))).toBe("AQ==");
+      expect(bytes.toBase64(new Uint8Array([1]))).toBe("AQ==");
     });
   });
 
-  describe("fromBase64()", () => {
+  describe("bytes.fromBase64()", () => {
     it("Handles empty string", () => {
-      expect(fromBase64("")).toEqual(new Uint8Array([]));
+      expect(bytes.fromBase64("")).toEqual(new Uint8Array([]));
     });
 
     it("Converts general data", () => {
-      expect(fromBase64("SGVsbG8=")).toEqual(new Uint8Array([72, 101, 108, 108, 111]));
+      expect(bytes.fromBase64("SGVsbG8=")).toEqual(new Uint8Array([72, 101, 108, 108, 111]));
     });
 
     it("Throws error for invalid base64 characters", () => {
-      expect(() => fromBase64("!!invalid!!")).toThrow(ArgumentError);
+      expect(() => bytes.fromBase64("!!invalid!!")).toThrow(ArgumentError);
     });
 
     it("Throws error for invalid base64 length (remainder 1)", () => {
-      expect(() => fromBase64("A")).toThrow(ArgumentError);
-      expect(() => fromBase64("AAAAA")).toThrow(ArgumentError);
+      expect(() => bytes.fromBase64("A")).toThrow(ArgumentError);
+      expect(() => bytes.fromBase64("AAAAA")).toThrow(ArgumentError);
     });
 
     it("Handles base64 without padding", () => {
-      expect(fromBase64("AQID")).toEqual(new Uint8Array([1, 2, 3]));
+      expect(bytes.fromBase64("AQID")).toEqual(new Uint8Array([1, 2, 3]));
     });
 
     it("Handles base64 with whitespace", () => {
-      expect(fromBase64("SGVs bG8=")).toEqual(new Uint8Array([72, 101, 108, 108, 111]));
+      expect(bytes.fromBase64("SGVs bG8=")).toEqual(new Uint8Array([72, 101, 108, 108, 111]));
     });
   });
 
@@ -179,8 +172,8 @@ describe("BytesUtils", () => {
         original[i] = i;
       }
 
-      const base64 = toBase64(original);
-      const restored = fromBase64(base64);
+      const base64 = bytes.toBase64(original);
+      const restored = bytes.fromBase64(base64);
 
       expect(restored).toEqual(original);
     });
@@ -192,8 +185,8 @@ describe("BytesUtils", () => {
           original[i] = (i * 37 + 13) % 256;
         }
 
-        const base64 = toBase64(original);
-        const restored = fromBase64(base64);
+        const base64 = bytes.toBase64(original);
+        const restored = bytes.fromBase64(base64);
 
         expect(restored).toEqual(original);
       }