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

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

@@ -1,230 +0,0 @@
-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";
-
-describe("BytesUtils", () => {
-  //#region concat
-
-  describe("concat()", () => {
-    it("여러 Uint8Array를 연결한다", () => {
-      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]);
-
-      expect(result).toEqual(new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9]));
-    });
-
-    it("빈 배열을 처리한다", () => {
-      const result = concat([]);
-
-      expect(result).toEqual(new Uint8Array([]));
-      expect(result.length).toBe(0);
-    });
-
-    it("단일 배열을 처리한다", () => {
-      const arr = new Uint8Array([1, 2, 3]);
-
-      const result = concat([arr]);
-
-      expect(result).toEqual(new Uint8Array([1, 2, 3]));
-    });
-
-    it("빈 Uint8Array가 포함된 경우 처리한다", () => {
-      const arr1 = new Uint8Array([1, 2]);
-      const arr2 = new Uint8Array([]);
-      const arr3 = new Uint8Array([3, 4]);
-
-      const result = concat([arr1, arr2, arr3]);
-
-      expect(result).toEqual(new Uint8Array([1, 2, 3, 4]));
-    });
-  });
-
-  //#endregion
-
-  //#region toHex/fromHex
-
-  describe("toHex()", () => {
-    it("Uint8Array를 hex 문자열로 변환한다", () => {
-      const bytes = new Uint8Array([0, 1, 15, 16, 255]);
-
-      const result = toHex(bytes);
-
-      expect(result).toBe("00010f10ff");
-    });
-
-    it("빈 배열을 처리한다", () => {
-      const result = toHex(new Uint8Array([]));
-
-      expect(result).toBe("");
-    });
-
-    it("단일 바이트를 처리한다", () => {
-      expect(toHex(new Uint8Array([0]))).toBe("00");
-      expect(toHex(new Uint8Array([255]))).toBe("ff");
-    });
-  });
-
-  describe("fromHex()", () => {
-    it("hex 문자열을 Uint8Array로 변환한다", () => {
-      const result = fromHex("00010f10ff");
-
-      expect(result).toEqual(new Uint8Array([0, 1, 15, 16, 255]));
-    });
-
-    it("빈 문자열을 처리한다", () => {
-      const result = fromHex("");
-
-      expect(result).toEqual(new Uint8Array([]));
-    });
-
-    it("대문자 hex도 처리한다", () => {
-      const result = fromHex("FF0A");
-
-      expect(result).toEqual(new Uint8Array([255, 10]));
-    });
-
-    it("홀수 길이 문자열은 에러를 발생시킨다", () => {
-      expect(() => fromHex("abc")).toThrow(ArgumentError);
-      expect(() => fromHex("a")).toThrow(ArgumentError);
-      expect(() => fromHex("12345")).toThrow(ArgumentError);
-    });
-
-    it("유효하지 않은 hex 문자가 포함되면 에러를 발생시킨다", () => {
-      expect(() => fromHex("zz")).toThrow(ArgumentError);
-      expect(() => fromHex("gh")).toThrow(ArgumentError);
-      expect(() => fromHex("12g4")).toThrow(ArgumentError);
-    });
-  });
-
-  describe("toHex/fromHex 왕복 변환", () => {
-    it("왕복 변환이 일치한다", () => {
-      const original = new Uint8Array([0, 127, 128, 255, 1, 2, 3]);
-
-      const hex = toHex(original);
-      const restored = fromHex(hex);
-
-      expect(restored).toEqual(original);
-    });
-
-    it("모든 바이트 값(0-255)에 대해 왕복 변환이 일치한다", () => {
-      const original = new Uint8Array(256);
-      for (let i = 0; i < 256; i++) {
-        original[i] = i;
-      }
-
-      const hex = toHex(original);
-      const restored = fromHex(hex);
-
-      expect(restored).toEqual(original);
-    });
-  });
-
-  //#endregion
-
-  //#region toBase64/fromBase64
-
-  describe("toBase64()", () => {
-    it("빈 배열을 처리한다", () => {
-      expect(toBase64(new Uint8Array([]))).toBe("");
-    });
-
-    it("일반 데이터를 변환한다", () => {
-      expect(toBase64(new Uint8Array([72, 101, 108, 108, 111]))).toBe("SGVsbG8=");
-    });
-
-    it("대용량 데이터 (1MB)를 스택 오버플로우 없이 처리한다", () => {
-      const data = new Uint8Array(1024 * 1024);
-      expect(() => toBase64(data)).not.toThrow();
-    });
-
-    it("패딩이 필요없는 경우를 처리한다", () => {
-      // 3의 배수 길이 - 패딩 없음
-      expect(toBase64(new Uint8Array([1, 2, 3]))).toBe("AQID");
-    });
-
-    it("단일 패딩이 필요한 경우를 처리한다", () => {
-      // 3으로 나눠 나머지 2 - = 1개
-      expect(toBase64(new Uint8Array([1, 2]))).toBe("AQI=");
-    });
-
-    it("이중 패딩이 필요한 경우를 처리한다", () => {
-      // 3으로 나눠 나머지 1 - == 2개
-      expect(toBase64(new Uint8Array([1]))).toBe("AQ==");
-    });
-  });
-
-  describe("fromBase64()", () => {
-    it("빈 문자열을 처리한다", () => {
-      expect(fromBase64("")).toEqual(new Uint8Array([]));
-    });
-
-    it("일반 데이터를 변환한다", () => {
-      expect(fromBase64("SGVsbG8=")).toEqual(new Uint8Array([72, 101, 108, 108, 111]));
-    });
-
-    it("유효하지 않은 base64 문자가 포함되면 에러를 발생시킨다", () => {
-      expect(() => fromBase64("!!invalid!!")).toThrow(ArgumentError);
-    });
-
-    it("유효하지 않은 base64 길이(나머지 1)면 에러를 발생시킨다", () => {
-      expect(() => fromBase64("A")).toThrow(ArgumentError);
-      expect(() => fromBase64("AAAAA")).toThrow(ArgumentError);
-    });
-
-    it("패딩 없는 base64를 처리한다", () => {
-      expect(fromBase64("AQID")).toEqual(new Uint8Array([1, 2, 3]));
-    });
-
-    it("공백이 포함된 base64를 처리한다", () => {
-      expect(fromBase64("SGVs bG8=")).toEqual(new Uint8Array([72, 101, 108, 108, 111]));
-    });
-  });
-
-  describe("toBase64/fromBase64 왕복 변환", () => {
-    it("왕복 변환이 일치한다", () => {
-      const original = new Uint8Array([0, 127, 128, 255, 1, 2, 3]);
-
-      const base64 = toBase64(original);
-      const restored = fromBase64(base64);
-
-      expect(restored).toEqual(original);
-    });
-
-    it("모든 바이트 값(0-255)에 대해 왕복 변환이 일치한다", () => {
-      const original = new Uint8Array(256);
-      for (let i = 0; i < 256; i++) {
-        original[i] = i;
-      }
-
-      const base64 = toBase64(original);
-      const restored = fromBase64(base64);
-
-      expect(restored).toEqual(original);
-    });
-
-    it("다양한 길이(1~10바이트)에 대해 왕복 변환이 일치한다", () => {
-      for (let len = 1; len <= 10; len++) {
-        const original = new Uint8Array(len);
-        for (let i = 0; i < len; i++) {
-          original[i] = (i * 37 + 13) % 256;
-        }
-
-        const base64 = toBase64(original);
-        const restored = fromBase64(base64);
-
-        expect(restored).toEqual(original);
-      }
-    });
-  });
-
-  //#endregion
-});

package/tests/utils/date-format.spec.ts

@@ -1,371 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { formatDate, normalizeMonth } from "@simplysm/core-common";
-
-describe("formatDateTime", () => {
-  //#region 연도 패턴
-
-  describe("연도 패턴", () => {
-    it("yyyy - 4자리 연도를 출력한다", () => {
-      expect(formatDate("yyyy", { year: 2025 })).toBe("2025");
-    });
-
-    it("yy - 2자리 연도를 출력한다", () => {
-      expect(formatDate("yy", { year: 2025 })).toBe("25");
-      expect(formatDate("yy", { year: 2000 })).toBe("00");
-      expect(formatDate("yy", { year: 1999 })).toBe("99");
-    });
-  });
-
-  //#endregion
-
-  //#region 월 패턴
-
-  describe("월 패턴", () => {
-    it("MM - 2자리 월을 출력한다", () => {
-      expect(formatDate("MM", { month: 1 })).toBe("01");
-      expect(formatDate("MM", { month: 9 })).toBe("09");
-      expect(formatDate("MM", { month: 12 })).toBe("12");
-    });
-
-    it("M - 패딩 없이 월을 출력한다", () => {
-      expect(formatDate("M", { month: 1 })).toBe("1");
-      expect(formatDate("M", { month: 9 })).toBe("9");
-      expect(formatDate("M", { month: 12 })).toBe("12");
-    });
-  });
-
-  //#endregion
-
-  //#region 일 패턴
-
-  describe("일 패턴", () => {
-    it("dd - 2자리 일을 출력한다", () => {
-      expect(formatDate("dd", { day: 1 })).toBe("01");
-      expect(formatDate("dd", { day: 9 })).toBe("09");
-      expect(formatDate("dd", { day: 31 })).toBe("31");
-    });
-
-    it("d - 패딩 없이 일을 출력한다", () => {
-      expect(formatDate("d", { day: 1 })).toBe("1");
-      expect(formatDate("d", { day: 9 })).toBe("9");
-      expect(formatDate("d", { day: 31 })).toBe("31");
-    });
-  });
-
-  //#endregion
-
-  //#region 요일 패턴
-
-  describe("요일 패턴", () => {
-    it("ddd - 요일을 한글로 출력한다", () => {
-      // 2025-01-18은 토요일
-      expect(formatDate("ddd", { year: 2025, month: 1, day: 18 })).toBe("토");
-      // 2025-01-19는 일요일
-      expect(formatDate("ddd", { year: 2025, month: 1, day: 19 })).toBe("일");
-      // 2025-01-20은 월요일
-      expect(formatDate("ddd", { year: 2025, month: 1, day: 20 })).toBe("월");
-    });
-  });
-
-  //#endregion
-
-  //#region 시간 패턴
-
-  describe("시간 패턴", () => {
-    it("hh - 12시간 형식으로 패딩하여 출력한다", () => {
-      expect(formatDate("hh", { hour: 0 })).toBe("12");
-      expect(formatDate("hh", { hour: 1 })).toBe("01");
-      expect(formatDate("hh", { hour: 12 })).toBe("12");
-      expect(formatDate("hh", { hour: 13 })).toBe("01");
-    });
-
-    it("h - 12시간 형식으로 패딩 없이 출력한다", () => {
-      expect(formatDate("h", { hour: 0 })).toBe("12");
-      expect(formatDate("h", { hour: 1 })).toBe("1");
-      expect(formatDate("h", { hour: 9 })).toBe("9");
-      expect(formatDate("h", { hour: 10 })).toBe("10");
-      expect(formatDate("h", { hour: 12 })).toBe("12");
-      expect(formatDate("h", { hour: 13 })).toBe("1");
-      expect(formatDate("h", { hour: 23 })).toBe("11");
-    });
-
-    it("HH - 24시간 형식으로 패딩하여 출력한다", () => {
-      expect(formatDate("HH", { hour: 0 })).toBe("00");
-      expect(formatDate("HH", { hour: 9 })).toBe("09");
-      expect(formatDate("HH", { hour: 23 })).toBe("23");
-    });
-
-    it("H - 24시간 형식으로 패딩 없이 출력한다", () => {
-      expect(formatDate("H", { hour: 0 })).toBe("0");
-      expect(formatDate("H", { hour: 9 })).toBe("9");
-      expect(formatDate("H", { hour: 23 })).toBe("23");
-    });
-
-    it("tt - 오전/오후를 출력한다", () => {
-      expect(formatDate("tt", { hour: 0 })).toBe("오전");
-      expect(formatDate("tt", { hour: 11 })).toBe("오전");
-      expect(formatDate("tt", { hour: 12 })).toBe("오후");
-      expect(formatDate("tt", { hour: 23 })).toBe("오후");
-    });
-  });
-
-  //#endregion
-
-  //#region 분 패턴
-
-  describe("분 패턴", () => {
-    it("mm - 2자리 분을 출력한다", () => {
-      expect(formatDate("mm", { minute: 0 })).toBe("00");
-      expect(formatDate("mm", { minute: 5 })).toBe("05");
-      expect(formatDate("mm", { minute: 59 })).toBe("59");
-    });
-
-    it("m - 패딩 없이 분을 출력한다", () => {
-      expect(formatDate("m", { minute: 0 })).toBe("0");
-      expect(formatDate("m", { minute: 5 })).toBe("5");
-      expect(formatDate("m", { minute: 59 })).toBe("59");
-    });
-  });
-
-  //#endregion
-
-  //#region 초 패턴
-
-  describe("초 패턴", () => {
-    it("ss - 2자리 초를 출력한다", () => {
-      expect(formatDate("ss", { second: 0 })).toBe("00");
-      expect(formatDate("ss", { second: 5 })).toBe("05");
-      expect(formatDate("ss", { second: 59 })).toBe("59");
-    });
-
-    it("s - 패딩 없이 초를 출력한다", () => {
-      expect(formatDate("s", { second: 0 })).toBe("0");
-      expect(formatDate("s", { second: 5 })).toBe("5");
-      expect(formatDate("s", { second: 59 })).toBe("59");
-    });
-  });
-
-  //#endregion
-
-  //#region 밀리초 패턴
-
-  describe("밀리초 패턴", () => {
-    it("fff - 3자리 밀리초를 출력한다", () => {
-      expect(formatDate("fff", { millisecond: 0 })).toBe("000");
-      expect(formatDate("fff", { millisecond: 5 })).toBe("005");
-      expect(formatDate("fff", { millisecond: 50 })).toBe("050");
-      expect(formatDate("fff", { millisecond: 500 })).toBe("500");
-      expect(formatDate("fff", { millisecond: 999 })).toBe("999");
-    });
-
-    it("ff - 2자리 밀리초를 출력한다", () => {
-      expect(formatDate("ff", { millisecond: 0 })).toBe("00");
-      expect(formatDate("ff", { millisecond: 5 })).toBe("00");
-      expect(formatDate("ff", { millisecond: 50 })).toBe("05");
-      expect(formatDate("ff", { millisecond: 500 })).toBe("50");
-      expect(formatDate("ff", { millisecond: 999 })).toBe("99");
-    });
-
-    it("f - 1자리 밀리초를 출력한다", () => {
-      expect(formatDate("f", { millisecond: 0 })).toBe("0");
-      expect(formatDate("f", { millisecond: 5 })).toBe("0");
-      expect(formatDate("f", { millisecond: 100 })).toBe("1");
-      expect(formatDate("f", { millisecond: 500 })).toBe("5");
-      expect(formatDate("f", { millisecond: 999 })).toBe("9");
-    });
-  });
-
-  //#endregion
-
-  //#region 타임존 패턴
-
-  describe("타임존 패턴", () => {
-    describe("양수 오프셋 (동쪽)", () => {
-      it("zzz - +HH:mm 형식으로 출력한다", () => {
-        // UTC+9 (540분)
-        expect(formatDate("zzz", { timezoneOffsetMinutes: 540 })).toBe("+09:00");
-        // UTC+5:30 (330분)
-        expect(formatDate("zzz", { timezoneOffsetMinutes: 330 })).toBe("+05:30");
-      });
-
-      it("zz - +HH 형식으로 출력한다", () => {
-        expect(formatDate("zz", { timezoneOffsetMinutes: 540 })).toBe("+09");
-        expect(formatDate("zz", { timezoneOffsetMinutes: 60 })).toBe("+01");
-      });
-
-      it("z - +H 형식으로 출력한다 (패딩 없음)", () => {
-        expect(formatDate("z", { timezoneOffsetMinutes: 540 })).toBe("+9");
-        expect(formatDate("z", { timezoneOffsetMinutes: 60 })).toBe("+1");
-        expect(formatDate("z", { timezoneOffsetMinutes: 600 })).toBe("+10");
-      });
-    });
-
-    describe("음수 오프셋 (서쪽)", () => {
-      it("zzz - -HH:mm 형식으로 출력한다", () => {
-        // UTC-5 (-300분) - 정수 시간대
-        expect(formatDate("zzz", { timezoneOffsetMinutes: -300 })).toBe("-05:00");
-        // UTC-8 (-480분) - 정수 시간대
-        expect(formatDate("zzz", { timezoneOffsetMinutes: -480 })).toBe("-08:00");
-        // UTC-3:30 (-210분) - Newfoundland Standard Time
-        expect(formatDate("zzz", { timezoneOffsetMinutes: -210 })).toBe("-03:30");
-        // UTC-9:30 (-570분) - Marquesas Islands
-        expect(formatDate("zzz", { timezoneOffsetMinutes: -570 })).toBe("-09:30");
-      });
-
-      it("zz - -HH 형식으로 출력한다", () => {
-        expect(formatDate("zz", { timezoneOffsetMinutes: -300 })).toBe("-05");
-        expect(formatDate("zz", { timezoneOffsetMinutes: -60 })).toBe("-01");
-      });
-
-      it("z - -H 형식으로 출력한다 (패딩 없음)", () => {
-        expect(formatDate("z", { timezoneOffsetMinutes: -300 })).toBe("-5");
-        expect(formatDate("z", { timezoneOffsetMinutes: -60 })).toBe("-1");
-        expect(formatDate("z", { timezoneOffsetMinutes: -720 })).toBe("-12");
-      });
-    });
-
-    describe("UTC (0 오프셋)", () => {
-      it("zzz - +00:00으로 출력한다", () => {
-        expect(formatDate("zzz", { timezoneOffsetMinutes: 0 })).toBe("+00:00");
-      });
-
-      it("zz - +00으로 출력한다", () => {
-        expect(formatDate("zz", { timezoneOffsetMinutes: 0 })).toBe("+00");
-      });
-
-      it("z - +0으로 출력한다", () => {
-        expect(formatDate("z", { timezoneOffsetMinutes: 0 })).toBe("+0");
-      });
-    });
-  });
-
-  //#endregion
-
-  //#region 복합 포맷
-
-  describe("복합 포맷", () => {
-    it("전체 날짜/시간 포맷을 처리한다", () => {
-      const result = formatDate("yyyy-MM-dd HH:mm:ss.fff", {
-        year: 2025,
-        month: 1,
-        day: 18,
-        hour: 14,
-        minute: 30,
-        second: 45,
-        millisecond: 123,
-      });
-      expect(result).toBe("2025-01-18 14:30:45.123");
-    });
-
-    it("12시간 형식 포맷을 처리한다", () => {
-      const result = formatDate("yyyy-MM-dd tt h:mm:ss", {
-        year: 2025,
-        month: 1,
-        day: 18,
-        hour: 14,
-        minute: 5,
-        second: 9,
-      });
-      expect(result).toBe("2025-01-18 오후 2:05:09");
-    });
-
-    it("타임존 포함 포맷을 처리한다", () => {
-      const result = formatDate("yyyy-MM-ddTHH:mm:sszzz", {
-        year: 2025,
-        month: 1,
-        day: 18,
-        hour: 14,
-        minute: 30,
-        second: 0,
-        timezoneOffsetMinutes: 540,
-      });
-      expect(result).toBe("2025-01-18T14:30:00+09:00");
-    });
-  });
-
-  //#endregion
-});
-
-describe("normalizeMonth", () => {
-  //#region 정상 범위
-
-  describe("정상 범위 (1-12)", () => {
-    it("월이 1-12 범위 내면 그대로 반환한다", () => {
-      expect(normalizeMonth(2025, 1, 15)).toEqual({ year: 2025, month: 1, day: 15 });
-      expect(normalizeMonth(2025, 6, 15)).toEqual({ year: 2025, month: 6, day: 15 });
-      expect(normalizeMonth(2025, 12, 15)).toEqual({ year: 2025, month: 12, day: 15 });
-    });
-  });
-
-  //#endregion
-
-  //#region 월 오버플로우
-
-  describe("월 오버플로우 (13 이상)", () => {
-    it("13월은 다음 해 1월이 된다", () => {
-      expect(normalizeMonth(2025, 13, 15)).toEqual({ year: 2026, month: 1, day: 15 });
-    });
-
-    it("14월은 다음 해 2월이 된다", () => {
-      expect(normalizeMonth(2025, 14, 15)).toEqual({ year: 2026, month: 2, day: 15 });
-    });
-
-    it("25월은 2년 후 1월이 된다", () => {
-      expect(normalizeMonth(2025, 25, 15)).toEqual({ year: 2027, month: 1, day: 15 });
-    });
-
-    it("24월은 다음 해 12월이 된다", () => {
-      expect(normalizeMonth(2025, 24, 15)).toEqual({ year: 2026, month: 12, day: 15 });
-    });
-  });
-
-  //#endregion
-
-  //#region 월 언더플로우
-
-  describe("월 언더플로우 (0 이하)", () => {
-    it("0월은 이전 해 12월이 된다", () => {
-      expect(normalizeMonth(2025, 0, 15)).toEqual({ year: 2024, month: 12, day: 15 });
-    });
-
-    it("-1월은 이전 해 11월이 된다", () => {
-      expect(normalizeMonth(2025, -1, 15)).toEqual({ year: 2024, month: 11, day: 15 });
-    });
-
-    it("-11월은 이전 해 1월이 된다", () => {
-      expect(normalizeMonth(2025, -11, 15)).toEqual({ year: 2024, month: 1, day: 15 });
-    });
-
-    it("-12월은 2년 전 12월이 된다", () => {
-      expect(normalizeMonth(2025, -12, 15)).toEqual({ year: 2023, month: 12, day: 15 });
-    });
-
-    it("-13월은 2년 전 11월이 된다", () => {
-      expect(normalizeMonth(2025, -13, 15)).toEqual({ year: 2023, month: 11, day: 15 });
-    });
-  });
-
-  //#endregion
-
-  //#region 일 조정
-
-  describe("일 조정 (대상 월의 마지막 날)", () => {
-    it("31일에서 2월로 변경하면 28일로 조정된다 (평년)", () => {
-      expect(normalizeMonth(2025, 2, 31)).toEqual({ year: 2025, month: 2, day: 28 });
-    });
-
-    it("31일에서 2월로 변경하면 29일로 조정된다 (윤년)", () => {
-      expect(normalizeMonth(2024, 2, 31)).toEqual({ year: 2024, month: 2, day: 29 });
-    });
-
-    it("31일에서 4월로 변경하면 30일로 조정된다", () => {
-      expect(normalizeMonth(2025, 4, 31)).toEqual({ year: 2025, month: 4, day: 30 });
-    });
-
-    it("대상 월의 일수보다 작으면 그대로 유지된다", () => {
-      expect(normalizeMonth(2025, 3, 15)).toEqual({ year: 2025, month: 3, day: 15 });
-    });
-  });
-
-  //#endregion
-});