@simplysm/core-common 13.0.76 → 13.0.78

package/src/types/time.ts

@@ -1,5 +1,5 @@
 import { ArgumentError } from "../errors/argument-error";
-import { convert12To24, formatDate } from "../utils/date-format";
+import { convert12To24, format } from "../utils/date-format";
 
 /**
  * Time class (without date: HH:mm:ss.fff, immutable)
@@ -205,7 +205,7 @@ export class Time {
    * @see dtFormat for supported format strings
    */
   toFormatString(formatStr: string): string {
-    return formatDate(formatStr, {
+    return format(formatStr, {
       hour: this.hour,
       minute: this.minute,
       second: this.second,

package/src/types/uuid.ts

@@ -7,7 +7,7 @@ import { ArgumentError } from "../errors/argument-error";
  * Generates cryptographically secure UUIDs based on crypto.getRandomValues. (Chrome 79+, Node.js compatible)
  *
  * @example
- * const id = Uuid.new();
+ * const id = Uuid.generate();
  * const fromStr = new Uuid("550e8400-e29b-41d4-a716-446655440000");
  */
 export class Uuid {
@@ -47,7 +47,7 @@ export class Uuid {
   }
 
   /** Create new UUID v4 instance */
-  static new(): Uuid {
+  static generate(): Uuid {
     const bytes = new Uint8Array(16);
     crypto.getRandomValues(bytes);
 

package/src/utils/bytes.ts

@@ -5,11 +5,11 @@ import { ArgumentError } from "../errors/argument-error";
  * Uint8Array utility functions (complex operations only)
  *
  * Features:
- * - bytesConcat: Concatenate multiple Uint8Arrays
- * - bytesToHex: Convert Uint8Array to hex string
- * - bytesFromHex: Convert hex string to Uint8Array
- * - bytesToBase64: Convert Uint8Array to base64 string
- * - bytesFromBase64: Convert base64 string to Uint8Array
+ * - concat: Concatenate multiple Uint8Arrays
+ * - toHex: Convert Uint8Array to hex string
+ * - fromHex: Convert hex string to Uint8Array
+ * - toBase64: Convert Uint8Array to base64 string
+ * - fromBase64: Convert base64 string to Uint8Array
  */
 
 /** Lookup table for hex conversion (performance optimization) */
@@ -31,10 +31,10 @@ const BASE64_LOOKUP: number[] = Array.from({ length: 256 }, (_, i) => {
  * @example
  * const a = new Uint8Array([1, 2]);
  * const b = new Uint8Array([3, 4]);
- * bytesConcat([a, b]);
+ * concat([a, b]);
  * // Uint8Array([1, 2, 3, 4])
  */
-export function bytesConcat(arrays: Bytes[]): Bytes {
+export function concat(arrays: Bytes[]): Bytes {
   const total = arrays.reduce((sum, arr) => sum + arr.length, 0);
   const result = new Uint8Array(total);
   let offset = 0;
@@ -50,10 +50,10 @@ export function bytesConcat(arrays: Bytes[]): Bytes {
  * @param bytes Uint8Array to convert
  * @returns Lowercase hex string
  * @example
- * bytesToHex(new Uint8Array([255, 0, 127]));
+ * toHex(new Uint8Array([255, 0, 127]));
  * // "ff007f"
  */
-export function bytesToHex(bytes: Bytes): string {
+export function toHex(bytes: Bytes): string {
   const h = hexTable;
   let result = "";
   for (let i = 0; i < bytes.length; i++) {
@@ -68,10 +68,10 @@ export function bytesToHex(bytes: Bytes): string {
  * @returns Converted Uint8Array
  * @throws {ArgumentError} If odd length or invalid hex characters are present
  * @example
- * bytesFromHex("ff007f");
+ * fromHex("ff007f");
  * // Uint8Array([255, 0, 127])
  */
-export function bytesFromHex(hex: string): Bytes {
+export function fromHex(hex: string): Bytes {
   if (hex.length % 2 !== 0) {
     throw new ArgumentError("Hex string must have even length", { hex });
   }
@@ -90,10 +90,10 @@ export function bytesFromHex(hex: string): Bytes {
  * @param bytes Uint8Array to convert
  * @returns Base64 encoded string
  * @example
- * bytesToBase64(new Uint8Array([72, 101, 108, 108, 111]));
+ * toBase64(new Uint8Array([72, 101, 108, 108, 111]));
  * // "SGVsbG8="
  */
-export function bytesToBase64(bytes: Bytes): string {
+export function toBase64(bytes: Bytes): string {
   if (bytes.length === 0) {
     return "";
   }
@@ -118,10 +118,10 @@ export function bytesToBase64(bytes: Bytes): string {
  * @returns Decoded Uint8Array
  * @throws {ArgumentError} If invalid base64 character is present
  * @example
- * bytesFromBase64("SGVsbG8=");
+ * fromBase64("SGVsbG8=");
  * // Uint8Array([72, 101, 108, 108, 111])
  */
-export function bytesFromBase64(base64: string): Bytes {
+export function fromBase64(base64: string): Bytes {
   // Remove whitespace and normalize padding
   const cleanBase64 = base64.replace(/\s/g, "").replace(/=+$/, "");
 

package/src/utils/date-format.ts

@@ -136,7 +136,7 @@ const weekStrings = ["일", "월", "화", "수", "목", "금", "토"];
  * // "PM 2:30:45"
  * ```
  */
-export function formatDate(
+export function format(
   formatString: string,
   args: {
     year?: number;

package/src/utils/error.ts

@@ -6,6 +6,6 @@
  * @param err - Unknown error from catch block
  * @returns Error message string
  */
-export function errorMessage(err: unknown): string {
+export function message(err: unknown): string {
   return err instanceof Error ? err.message : String(err);
 }

package/src/utils/json.ts

@@ -6,9 +6,9 @@ import { DateTime } from "../types/date-time";
 import { DateOnly } from "../types/date-only";
 import { Time } from "../types/time";
 import { Uuid } from "../types/uuid";
-import { objNullToUndefined } from "./obj";
+import { nullToUndefined } from "./obj";
 import { SdError } from "../errors/sd-error";
-import { bytesToHex, bytesFromHex } from "./bytes";
+import { toHex, fromHex } from "./bytes";
 import { env } from "../env";
 
 interface TypedObject {
@@ -33,7 +33,7 @@ interface TypedObject {
  * - If object has toJSON method, it is called and the result is used (except for custom types like Date, DateTime)
  * - Safe in Worker environments as global prototypes are not modified
  */
-export function jsonStringify(
+export function stringify(
   obj: unknown,
   options?: {
     space?: string | number;
@@ -105,7 +105,7 @@ export function jsonStringify(
       if (options?.redactBytes === true) {
         return { __type__: "Uint8Array", data: "__hidden__" };
       }
-      return { __type__: "Uint8Array", data: bytesToHex(currValue) };
+      return { __type__: "Uint8Array", data: toHex(currValue) };
     }
 
     // Array processing
@@ -171,13 +171,15 @@ export function jsonStringify(
  * Objects with `__type__` and `data` keys are used for type restoration.
  * Be careful if user data contains objects with `{ __type__: "Date" | "DateTime" | "DateOnly" | "Time" | "Uuid" | "Set" | "Map" | "Error" | "Uint8Array", data: ... }`
  * format as they may be unintentionally converted to types.
+ * All JSON null values are converted to undefined.
+ * This is intentional for the simplysm framework's null-free convention.
  *
  * @security In development mode (`__DEV__`), the error message includes the entire JSON string.
  * In production mode, only JSON length is included.
  */
-export function jsonParse<TResult = unknown>(json: string): TResult {
+export function parse<TResult = unknown>(json: string): TResult {
   try {
-    return objNullToUndefined(
+    return nullToUndefined(
       JSON.parse(json, (_key, value: unknown) => {
         if (value != null && typeof value === "object") {
           // Restore types based on __type__ marker
@@ -216,7 +218,7 @@ export function jsonParse<TResult = unknown>(json: string): TResult {
                   "Uint8Array serialized with redactBytes option cannot be restored via parse",
                 );
               }
-              return bytesFromHex(typed.data);
+              return fromHex(typed.data);
             }
           }
         }

package/src/utils/num.ts

@@ -2,18 +2,18 @@
  * Number utility functions
  */
 
-//#region numParseInt / numParseFloat / numParseRoundedInt
+//#region parseInt / parseFloat / parseRoundedInt
 
 /**
  * Parse string to integer
  * Remove non-numeric characters (except 0-9, -, .) before parsing
  *
  * @note Strings with decimal points return only the integer part (e.g., '12.34' → 12).
- *       Use {@link numParseRoundedInt} if rounding is needed.
+ *       Use {@link parseRoundedInt} if rounding is needed.
  * @note Hyphens (-) in the middle of the string are preserved, which may result in unintended negative numbers.
  *       Example: `"가-123나"` → `-123`
  */
-export function numParseInt(text: unknown): number | undefined {
+export function parseInt(text: unknown): number | undefined {
   if (typeof text === "number") return Math.trunc(text);
   if (typeof text !== "string") return undefined;
   const txt = text.replace(/[^0-9.\-]/g, "").trim();
@@ -26,8 +26,8 @@ export function numParseInt(text: unknown): number | undefined {
 /**
  * Parse string to float, then round and return integer
  */
-export function numParseRoundedInt(text: unknown): number | undefined {
-  const float = numParseFloat(text);
+export function parseRoundedInt(text: unknown): number | undefined {
+  const float = parseFloat(text);
   return float !== undefined ? Math.round(float) : undefined;
 }
 
@@ -35,7 +35,7 @@ export function numParseRoundedInt(text: unknown): number | undefined {
  * Parse string to float
  * Remove non-numeric characters before parsing
  */
-export function numParseFloat(text: unknown): number | undefined {
+export function parseFloat(text: unknown): number | undefined {
   if (typeof text === "number") return text;
   if (typeof text !== "string") return undefined;
   const txt = text.replace(/[^0-9.\-]/g, "").trim();
@@ -47,7 +47,7 @@ export function numParseFloat(text: unknown): number | undefined {
 
 //#endregion
 
-//#region numIsNullOrEmpty
+//#region isNullOrEmpty
 
 /**
  * Check undefined, null, 0 (type guard)
@@ -59,7 +59,7 @@ export function numParseFloat(text: unknown): number | undefined {
  * @returns true if undefined, null, or 0
  * @example
  * const count: number | undefined = getValue();
- * if (numIsNullOrEmpty(count)) {
+ * if (isNullOrEmpty(count)) {
  *   // count: 0 | undefined
  *   console.log("Empty");
  * } else {
@@ -67,13 +67,13 @@ export function numParseFloat(text: unknown): number | undefined {
  *   console.log(`Count: ${count}`);
  * }
  */
-export function numIsNullOrEmpty(val: number | undefined): val is 0 | undefined {
+export function isNullOrEmpty(val: number | undefined): val is 0 | undefined {
   return val == null || val === 0;
 }
 
 //#endregion
 
-//#region numFormat
+//#region format
 
 /**
  * Format number to string with thousand separators
@@ -82,15 +82,15 @@ export function numIsNullOrEmpty(val: number | undefined): val is 0 | undefined
  * @param digit.max Maximum decimal places
  * @param digit.min Minimum decimal places (pad with 0 if insufficient)
  * @example
- * numFormat(1234.567, { max: 2 }) // "1,234.57"
- * numFormat(1234, { min: 2 }) // "1,234.00"
+ * format(1234.567, { max: 2 }) // "1,234.57"
+ * format(1234, { min: 2 }) // "1,234.00"
  */
-export function numFormat(val: number, digit?: { max?: number; min?: number }): string;
-export function numFormat(
+export function format(val: number, digit?: { max?: number; min?: number }): string;
+export function format(
   val: number | undefined,
   digit?: { max?: number; min?: number },
 ): string | undefined;
-export function numFormat(
+export function format(
   val: number | undefined,
   digit?: { max?: number; min?: number },
 ): string | undefined {