@simplysm/core-common 13.0.0-beta.2 → 13.0.0-beta.21

package/src/types/time.ts

@@ -1,210 +0,0 @@
-import { ArgumentError } from "../errors/argument-error";
-import { convert12To24, formatDate } from "../utils/date-format";
-
-/**
- * 시간 클래스 (날짜제외: HH:mm:ss.fff, 불변)
- *
- * 날짜 정보 없이 시간만 저장하는 불변 클래스이다.
- * 24시간을 초과하거나 음수인 경우 자동으로 정규화된다.
- *
- * @example
- * const now = new Time();
- * const specific = new Time(10, 30, 0);
- * const parsed = Time.parse("10:30:00");
- */
-export class Time {
-  private static readonly MS_PER_DAY = 24 * 60 * 60 * 1000;
-
-  private readonly _tick: number;
-
-  /** 현재 시간으로 생성 */
-  constructor();
-  /** 시분초밀리초로 생성 */
-  constructor(hour: number, minute: number, second?: number, millisecond?: number);
-  /** tick (밀리초)으로 생성 */
-  constructor(tick: number);
-  /** Date 객체에서 시간 부분만 추출하여 생성 */
-  constructor(date: Date);
-  constructor(arg1?: number | Date, arg2?: number, arg3?: number, arg4?: number) {
-    if (arg1 === undefined) {
-      const now = new Date();
-      this._tick =
-        (now.getMilliseconds() +
-          now.getSeconds() * 1000 +
-          now.getMinutes() * 60 * 1000 +
-          now.getHours() * 60 * 60 * 1000) %
-        Time.MS_PER_DAY;
-    } else if (arg2 !== undefined) {
-      let tick =
-        ((arg4 ?? 0) + (arg3 ?? 0) * 1000 + arg2 * 60 * 1000 + (arg1 as number) * 60 * 60 * 1000) % Time.MS_PER_DAY;
-      if (tick < 0) tick += Time.MS_PER_DAY;
-      this._tick = tick;
-    } else if (arg1 instanceof Date) {
-      this._tick =
-        (arg1.getMilliseconds() +
-          arg1.getSeconds() * 1000 +
-          arg1.getMinutes() * 60 * 1000 +
-          arg1.getHours() * 60 * 60 * 1000) %
-        Time.MS_PER_DAY;
-    } else {
-      let tick = arg1 % Time.MS_PER_DAY;
-      if (tick < 0) tick += Time.MS_PER_DAY;
-      this._tick = tick;
-    }
-  }
-
-  /**
-   * 문자열을 파싱하여 Time 인스턴스를 생성
-   *
-   * @param str 시간 문자열
-   * @returns 파싱된 Time 인스턴스
-   * @throws ArgumentError 지원하지 않는 형식인 경우
-   *
-   * @example
-   * Time.parse("10:30:00")           // HH:mm:ss
-   * Time.parse("10:30:00.123")       // HH:mm:ss.fff
-   * Time.parse("오전 10:30:00")       // 오전/오후 HH:mm:ss
-   * Time.parse("2025-01-15T10:30:00") // ISO 8601 (시간 부분만 추출)
-   */
-  static parse(str: string): Time {
-    const match1 = /(오전|오후) ([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2})(\.([0-9]{1,3}))?$/.exec(str);
-    if (match1 != null) {
-      const rawHour = Number(match1[2]);
-      const isPM = match1[1] === "오후";
-      const hour = convert12To24(rawHour, isPM);
-      return new Time(hour, Number(match1[3]), Number(match1[4]), Number(match1[6] ? match1[6].padEnd(3, "0") : "0"));
-    }
-
-    const match2 = /([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2})(\.([0-9]{1,3}))?$/.exec(str);
-    if (match2 != null) {
-      return new Time(
-        Number(match2[1]),
-        Number(match2[2]),
-        Number(match2[3]),
-        Number(match2[5] ? match2[5].padEnd(3, "0") : "0"),
-      );
-    }
-
-    // ISO 8601 형식 (예: 2025-01-15T10:30:00.123Z, 2025-01-15T10:30:00+09:00)
-    // Date 객체를 사용하여 타임존 변환 처리
-    const isoMatch = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.exec(str);
-    if (isoMatch != null) {
-      const date = new Date(str);
-      if (!Number.isNaN(date.getTime())) {
-        return new Time(date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
-      }
-    }
-
-    throw new ArgumentError(
-      `시간 형식을 파싱할 수 없습니다. 지원 형식: 'HH:mm:ss', 'HH:mm:ss.fff', '오전/오후 HH:mm:ss', ISO 8601`,
-      { input: str },
-    );
-  }
-
-  //#region Getters (읽기 전용)
-
-  get hour(): number {
-    return Math.floor(this._tick / (60 * 60 * 1000));
-  }
-
-  get minute(): number {
-    return Math.floor(this._tick / (60 * 1000)) % 60;
-  }
-
-  get second(): number {
-    return Math.floor(this._tick / 1000) % 60;
-  }
-
-  get millisecond(): number {
-    return this._tick % 1000;
-  }
-
-  get tick(): number {
-    return this._tick;
-  }
-
-  /** 시간 세팅이 제대로 되었는지 여부 */
-  get isValid(): boolean {
-    return !Number.isNaN(this._tick);
-  }
-
-  //#endregion
-
-  //#region 불변 변환 메서드 (새 인스턴스 반환)
-
-  /** 지정된 시로 새 인스턴스 반환 */
-  setHour(hour: number): Time {
-    return new Time(hour, this.minute, this.second, this.millisecond);
-  }
-
-  /** 지정된 분으로 새 인스턴스 반환 */
-  setMinute(minute: number): Time {
-    return new Time(this.hour, minute, this.second, this.millisecond);
-  }
-
-  /** 지정된 초로 새 인스턴스 반환 */
-  setSecond(second: number): Time {
-    return new Time(this.hour, this.minute, second, this.millisecond);
-  }
-
-  /** 지정된 밀리초로 새 인스턴스 반환 */
-  setMillisecond(millisecond: number): Time {
-    return new Time(this.hour, this.minute, this.second, millisecond);
-  }
-
-  //#endregion
-
-  //#region 산술 메서드 (새 인스턴스 반환)
-
-  /** 지정된 시간을 더한 새 인스턴스 반환 (24시간 순환) */
-  addHours(hours: number): Time {
-    let newTick = (this._tick + hours * 60 * 60 * 1000) % Time.MS_PER_DAY;
-    if (newTick < 0) newTick += Time.MS_PER_DAY;
-    return new Time(newTick);
-  }
-
-  /** 지정된 분을 더한 새 인스턴스 반환 (24시간 순환) */
-  addMinutes(minutes: number): Time {
-    let newTick = (this._tick + minutes * 60 * 1000) % Time.MS_PER_DAY;
-    if (newTick < 0) newTick += Time.MS_PER_DAY;
-    return new Time(newTick);
-  }
-
-  /** 지정된 초를 더한 새 인스턴스 반환 (24시간 순환) */
-  addSeconds(seconds: number): Time {
-    let newTick = (this._tick + seconds * 1000) % Time.MS_PER_DAY;
-    if (newTick < 0) newTick += Time.MS_PER_DAY;
-    return new Time(newTick);
-  }
-
-  /** 지정된 밀리초를 더한 새 인스턴스 반환 (24시간 순환) */
-  addMilliseconds(milliseconds: number): Time {
-    let newTick = (this._tick + milliseconds) % Time.MS_PER_DAY;
-    if (newTick < 0) newTick += Time.MS_PER_DAY;
-    return new Time(newTick);
-  }
-
-  //#endregion
-
-  //#region 포맷팅
-
-  /**
-   * 지정된 포맷으로 문자열 변환
-   * @param format 포맷 문자열
-   * @see dtFormat 지원 포맷 문자열 참조
-   */
-  toFormatString(formatStr: string): string {
-    return formatDate(formatStr, {
-      hour: this.hour,
-      minute: this.minute,
-      second: this.second,
-      millisecond: this.millisecond,
-    });
-  }
-
-  toString(): string {
-    return this.toFormatString("HH:mm:ss.fff");
-  }
-
-  //#endregion
-}

package/src/types/uuid.ts

@@ -1,113 +0,0 @@
-import type { Bytes } from "../common.types";
-import { ArgumentError } from "../errors/argument-error";
-
-/**
- * UUID v4 클래스
- *
- * crypto.getRandomValues 기반으로 암호학적으로 안전한 UUID를 생성한다. (Chrome 79+, Node.js 공용)
- *
- * @example
- * const id = Uuid.new();
- * const fromStr = new Uuid("550e8400-e29b-41d4-a716-446655440000");
- */
-export class Uuid {
-  // 0x00 ~ 0xFF에 대한 hex 문자열 미리 계산 (256개)
-  private static readonly _hexTable: string[] = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
-
-  private static readonly _uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-
-  /** 16바이트 배열을 UUID 문자열로 변환 */
-  private static _bytesToUuidStr(bytes: Uint8Array): string {
-    const h = Uuid._hexTable;
-    return (
-      h[bytes[0]] +
-      h[bytes[1]] +
-      h[bytes[2]] +
-      h[bytes[3]] +
-      "-" +
-      h[bytes[4]] +
-      h[bytes[5]] +
-      "-" +
-      h[bytes[6]] +
-      h[bytes[7]] +
-      "-" +
-      h[bytes[8]] +
-      h[bytes[9]] +
-      "-" +
-      h[bytes[10]] +
-      h[bytes[11]] +
-      h[bytes[12]] +
-      h[bytes[13]] +
-      h[bytes[14]] +
-      h[bytes[15]]
-    );
-  }
-
-  /** 새 UUID v4 인스턴스 생성 */
-  static new(): Uuid {
-    const bytes = new Uint8Array(16);
-    crypto.getRandomValues(bytes);
-
-    // UUID v4 설정
-    bytes[6] = (bytes[6] & 0x0f) | 0x40;
-    bytes[8] = (bytes[8] & 0x3f) | 0x80;
-
-    return new Uuid(Uuid._bytesToUuidStr(bytes));
-  }
-
-  /**
-   * 16바이트 Uint8Array에서 UUID 생성
-   * @param bytes 16바이트 배열
-   * @throws {ArgumentError} 바이트 크기가 16이 아닌 경우
-   */
-  static fromBytes(bytes: Bytes): Uuid {
-    if (bytes.length !== 16) {
-      throw new ArgumentError("UUID 바이트 크기는 16이어야 합니다.", { length: bytes.length });
-    }
-
-    return new Uuid(Uuid._bytesToUuidStr(bytes));
-  }
-
-  private readonly _uuid: string;
-
-  /**
-   * @param uuid UUID 문자열 (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx 형식)
-   * @throws {ArgumentError} 형식이 올바르지 않은 경우
-   */
-  constructor(uuid: string) {
-    if (!Uuid._uuidRegex.test(uuid)) {
-      throw new ArgumentError("UUID 형식이 올바르지 않습니다.", { uuid });
-    }
-    this._uuid = uuid;
-  }
-
-  /** UUID를 문자열로 변환 */
-  toString(): string {
-    return this._uuid;
-  }
-
-  /** UUID를 16바이트 Uint8Array로 변환 */
-  toBytes(): Bytes {
-    const u = this._uuid;
-    // UUID 형식: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx (8-4-4-4-12)
-    // 하이픈 위치: 8, 13, 18, 23
-    return new Uint8Array([
-      Number.parseInt(u.substring(0, 2), 16),
-      Number.parseInt(u.substring(2, 4), 16),
-      Number.parseInt(u.substring(4, 6), 16),
-      Number.parseInt(u.substring(6, 8), 16),
-      Number.parseInt(u.substring(9, 11), 16),
-      Number.parseInt(u.substring(11, 13), 16),
-      Number.parseInt(u.substring(14, 16), 16),
-      Number.parseInt(u.substring(16, 18), 16),
-      Number.parseInt(u.substring(19, 21), 16),
-      Number.parseInt(u.substring(21, 23), 16),
-      Number.parseInt(u.substring(24, 26), 16),
-      Number.parseInt(u.substring(26, 28), 16),
-      Number.parseInt(u.substring(28, 30), 16),
-      Number.parseInt(u.substring(30, 32), 16),
-      Number.parseInt(u.substring(32, 34), 16),
-      Number.parseInt(u.substring(34, 36), 16),
-    ]);
-  }
-}

package/src/utils/bytes.ts

@@ -1,160 +0,0 @@
-import type { Bytes } from "../common.types";
-import { ArgumentError } from "../errors/argument-error";
-
-/**
- * Uint8Array 유틸리티 함수 (복잡한 연산만)
- *
- * 기능:
- * - bytesConcat: 여러 Uint8Array 연결
- * - bytesToHex: Uint8Array를 hex 문자열로 변환
- * - bytesFromHex: hex 문자열을 Uint8Array로 변환
- * - bytesToBase64: Uint8Array를 base64 문자열로 변환
- * - bytesFromBase64: base64 문자열을 Uint8Array로 변환
- */
-
-/** hex 변환용 룩업 테이블 (성능 최적화) */
-const hexTable: string[] = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
-
-/** base64 인코딩 테이블 */
-const BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
-/** base64 디코딩 룩업 테이블 (O(1) 조회, 모든 바이트 값 커버) */
-const BASE64_LOOKUP: number[] = Array.from({ length: 256 }, (_, i) => {
-  const idx = BASE64_CHARS.indexOf(String.fromCharCode(i));
-  return idx === -1 ? 0 : idx;
-});
-
-/**
- * 여러 Uint8Array 연결
- * @param arrays 연결할 Uint8Array 배열
- * @returns 연결된 새 Uint8Array
- * @example
- * const a = new Uint8Array([1, 2]);
- * const b = new Uint8Array([3, 4]);
- * bytesConcat([a, b]);
- * // Uint8Array([1, 2, 3, 4])
- */
-export function bytesConcat(arrays: Bytes[]): Bytes {
-  const total = arrays.reduce((sum, arr) => sum + arr.length, 0);
-  const result = new Uint8Array(total);
-  let offset = 0;
-  for (const arr of arrays) {
-    result.set(arr, offset);
-    offset += arr.length;
-  }
-  return result;
-}
-
-/**
- * hex 문자열로 변환
- * @param bytes 변환할 Uint8Array
- * @returns 소문자 hex 문자열
- * @example
- * bytesToHex(new Uint8Array([255, 0, 127]));
- * // "ff007f"
- */
-export function bytesToHex(bytes: Bytes): string {
-  const h = hexTable;
-  let result = "";
-  for (let i = 0; i < bytes.length; i++) {
-    result += h[bytes[i]];
-  }
-  return result;
-}
-
-/**
- * hex 문자열에서 Uint8Array로 변환
- * @param hex 변환할 hex 문자열 (소문자/대문자 모두 허용)
- * @returns 변환된 Uint8Array
- * @throws {ArgumentError} 홀수 길이 또는 유효하지 않은 hex 문자가 포함된 경우
- * @example
- * bytesFromHex("ff007f");
- * // Uint8Array([255, 0, 127])
- */
-export function bytesFromHex(hex: string): Bytes {
-  if (hex.length % 2 !== 0) {
-    throw new ArgumentError("hex 문자열은 짝수 길이여야 합니다", { hex });
-  }
-  if (hex.length > 0 && !/^[0-9a-fA-F]+$/.test(hex)) {
-    throw new ArgumentError("유효하지 않은 hex 문자가 포함되어 있습니다", { hex });
-  }
-  const bytes = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < bytes.length; i++) {
-    bytes[i] = Number.parseInt(hex.substring(i * 2, i * 2 + 2), 16);
-  }
-  return bytes;
-}
-
-/**
- * Bytes를 base64 문자열로 변환
- * @param bytes 변환할 Uint8Array
- * @returns base64 인코딩된 문자열
- * @example
- * bytesToBase64(new Uint8Array([72, 101, 108, 108, 111]));
- * // "SGVsbG8="
- */
-export function bytesToBase64(bytes: Bytes): string {
-  if (bytes.length === 0) {
-    return "";
-  }
-
-  let result = "";
-  const len = bytes.length;
-  for (let i = 0; i < len; i += 3) {
-    const b1 = bytes[i];
-    const b2 = i + 1 < len ? bytes[i + 1] : 0;
-    const b3 = i + 2 < len ? bytes[i + 2] : 0;
-    result += BASE64_CHARS[b1 >> 2];
-    result += BASE64_CHARS[((b1 & 3) << 4) | (b2 >> 4)];
-    result += i + 1 < len ? BASE64_CHARS[((b2 & 15) << 2) | (b3 >> 6)] : "=";
-    result += i + 2 < len ? BASE64_CHARS[b3 & 63] : "=";
-  }
-  return result;
-}
-
-/**
- * base64 문자열을 Bytes로 변환
- * @param base64 변환할 base64 문자열
- * @returns 디코딩된 Uint8Array
- * @throws {ArgumentError} 유효하지 않은 base64 문자가 포함된 경우
- * @example
- * bytesFromBase64("SGVsbG8=");
- * // Uint8Array([72, 101, 108, 108, 111])
- */
-export function bytesFromBase64(base64: string): Bytes {
-  // 공백 제거 및 패딩 정규화
-  const cleanBase64 = base64.replace(/\s/g, "").replace(/=+$/, "");
-
-  // 빈 문자열 처리
-  if (cleanBase64.length === 0) {
-    return new Uint8Array(0);
-  }
-
-  // 유효성 검사: 문자
-  if (!/^[A-Za-z0-9+/]+$/.test(cleanBase64)) {
-    throw new ArgumentError("유효하지 않은 base64 문자가 포함되어 있습니다", { base64: base64.substring(0, 20) });
-  }
-
-  // 유효성 검사: 길이 (패딩 제거 후 나머지가 1이면 유효하지 않음)
-  if (cleanBase64.length % 4 === 1) {
-    throw new ArgumentError("유효하지 않은 base64 길이입니다", { length: cleanBase64.length });
-  }
-
-  const len = cleanBase64.length;
-  const byteLen = Math.floor((len * 3) / 4);
-  const bytes = new Uint8Array(byteLen);
-
-  let byteIdx = 0;
-  for (let i = 0; i < len; i += 4) {
-    const c1 = BASE64_LOOKUP[cleanBase64.charCodeAt(i)];
-    const c2 = i + 1 < len ? BASE64_LOOKUP[cleanBase64.charCodeAt(i + 1)] : 0;
-    const c3 = i + 2 < len ? BASE64_LOOKUP[cleanBase64.charCodeAt(i + 2)] : 0;
-    const c4 = i + 3 < len ? BASE64_LOOKUP[cleanBase64.charCodeAt(i + 3)] : 0;
-
-    bytes[byteIdx++] = (c1 << 2) | (c2 >> 4);
-    if (byteIdx < byteLen) bytes[byteIdx++] = ((c2 & 15) << 4) | (c3 >> 2);
-    if (byteIdx < byteLen) bytes[byteIdx++] = ((c3 & 3) << 6) | c4;
-  }
-
-  return bytes;
-}