@simplysm/core-common 14.0.100 → 14.0.102

package/src/errors/not-implemented-error.ts

@@ -5,21 +5,6 @@ import { SdError } from "./sd-error";
  *
  * 아직 구현되지 않은 기능이 호출되었을 때 발생하는 에러.
  * 추상 메서드 스텁, 향후 구현 예정인 분기 등에 사용된다.
- *
- * @example
- * // 추상 메서드 구현 전
- * class BaseService {
- *   process(): void {
- *     throw new NotImplementedError("서브클래스에서 구현 필요");
- *   }
- * }
- *
- * @example
- * // 향후 구현 예정인 분기
- * switch (type) {
- *   case "A": return handleA();
- *   case "B": throw new NotImplementedError(`타입 ${type} 처리`);
- * }
  */
 export class NotImplementedError extends SdError {
   /**

package/src/errors/sd-error.ts

@@ -1,20 +1,6 @@
 /**
  * 트리 구조 조합을 지원하는 에러 클래스
  * ES2024 cause 속성을 활용
- *
- * @example
- * // 원인 에러를 감싸기
- * try {
- *   await fetch(url);
- * } catch (err) {
- *   throw new SdError(err, "API 호출 실패", "사용자 로드 실패");
- * }
- * // 결과 메시지: "사용자 로드 실패 => API 호출 실패 => 원본 에러 메시지"
- *
- * @example
- * // 메시지만으로 생성
- * throw new SdError("잘못된 상태", "처리 불가");
- * // 결과 메시지: "처리 불가 => 잘못된 상태"
  */
 export class SdError extends Error {
   override cause?: Error;

package/src/errors/timeout-error.ts

@@ -5,22 +5,6 @@ import { SdError } from "./sd-error";
  *
  * 대기 시간이 초과되었을 때 발생하는 에러.
  * Wait.until() 같은 비동기 대기 함수에서 최대 시도 횟수를 초과하면 자동으로 발생한다.
- *
- * @example
- * // Wait.until에서 자동 발생
- * try {
- *   await Wait.until(() => isReady, 100, 50); // 100ms 간격, 최대 50회 시도
- * } catch (err) {
- *   if (err instanceof TimeoutError) {
- *     console.log("타임아웃 초과");
- *   }
- * }
- *
- * @example
- * // 직접 발생
- * if (elapsed > maxTime) {
- *   throw new TimeoutError(undefined, "API 응답 대기 초과");
- * }
  */
 export class TimeoutError extends SdError {
   /**

package/src/extensions/arr-ext.types.ts

@@ -131,30 +131,6 @@ export interface ReadonlyArrayExt<TItem> {
    * - parentKey 값이 null/undefined인 항목이 루트가 됨
    * - 내부적으로 toArrayMap을 사용하여 O(n) 복잡도
    * - 원본 항목은 복사되고 children 속성이 추가됨
-   *
-   * @example
-   * ```typescript
-   * interface Item {
-   *   id: number;
-   *   parentId?: number;
-   *   name: string;
-   * }
-   *
-   * const items: Item[] = [
-   *   { id: 1, name: "root" },
-   *   { id: 2, parentId: 1, name: "child1" },
-   *   { id: 3, parentId: 1, name: "child2" },
-   *   { id: 4, parentId: 2, name: "grandchild" },
-   * ];
-   *
-   * const tree = items.toTree("id", "parentId");
-   * // [{ id: 1, name: "root", children: [
-   * //   { id: 2, name: "child1", children: [
-   * //     { id: 4, name: "grandchild", children: [] }
-   * //   ]},
-   * //   { id: 3, name: "child2", children: [] }
-   * // ]}]
-   * ```
    */
   toTree<K extends keyof TItem, P extends keyof TItem>(
     keyProp: K,

package/src/extensions/map-ext.ts

@@ -11,21 +11,6 @@ declare global {
      * **주의**: V 타입이 함수인 경우 (예: `Map<string, () => void>`),
      * 함수를 두 번째 인자로 직접 전달하면 팩토리로 인식되어 호출됨.
      * 함수 자체를 값으로 저장하려면 팩토리로 감싸야 함.
-     *
-     * @example
-     * ```typescript
-     * // 일반 값
-     * map.getOrCreate("key", 0);
-     * map.getOrCreate("key", []);
-     *
-     * // 팩토리 함수 (비용이 큰 연산에 사용)
-     * map.getOrCreate("key", () => expensiveComputation());
-     *
-     * // 함수를 값으로 저장
-     * const fnMap = new Map<string, () => void>();
-     * const myFn = () => console.log("hello");
-     * fnMap.getOrCreate("key", () => myFn);  // 팩토리로 감싸기
-     * ```
      */
     getOrCreate(key: K, newValue: V): V;
     getOrCreate(key: K, newValueFn: () => V): V;
@@ -39,18 +24,6 @@ declare global {
      * @remarks
      * key가 존재하지 않아도 updateFn이 호출되어 새 값이 설정됨.
      * 기존 값 기반 계산(카운터 증가, array에 추가 등)에 유용함.
-     *
-     * @example
-     * ```typescript
-     * const countMap = new Map<string, number>();
-     *
-     * // 카운터 증가
-     * countMap.update("key", (v) => (v ?? 0) + 1);
-     *
-     * // array에 항목 추가
-     * const arrayMap = new Map<string, string[]>();
-     * arrayMap.update("key", (v) => [...(v ?? []), "item"]);
-     * ```
      */
     update(key: K, updateFn: (v: V | undefined) => V): void;
   }

package/src/extensions/set-ext.ts

@@ -18,18 +18,6 @@ declare global {
      *
      * @remarks
      * addOrDel 매개변수로 조건부 추가/제거를 간결하게 표현할 수 있음.
-     *
-     * @example
-     * ```typescript
-     * const set = new Set<number>([1, 2, 3]);
-     *
-     * set.toggle(2);  // 2가 있으므로 제거 → {1, 3}
-     * set.toggle(4);  // 4가 없으므로 추가 → {1, 3, 4}
-     *
-     * // 조건부 토글
-     * const isAdmin = true;
-     * set.toggle(5, isAdmin ? "add" : "del");  // 강제 추가
-     * ```
      */
     toggle(value: T, addOrDel?: "add" | "del"): this;
   }

package/src/features/debounce-queue.ts

@@ -9,16 +9,6 @@
  * 실행 중에 추가된 요청은 디바운스 지연 없이 현재 실행이
  * 완료된 직후 즉시 처리됨. 이는 실행 완료 전에 도착한
  * 요청을 놓치지 않기 위한 의도적인 설계임.
- *
- * @example
- * const queue = new DebounceQueue(300); // 300ms 지연
- * queue.run(() => console.log("1")); // 무시됨
- * queue.run(() => console.log("2")); // 무시됨
- * queue.run(() => console.log("3")); // 300ms 후 실행
- *
- * @example
- * // 에러 처리
- * queue.on("error", (err) => console.error(err));
  */
 import { SdError } from "../errors/sd-error";
 import { EventEmitter } from "./event-emitter";

package/src/features/event-emitter.ts

@@ -5,20 +5,6 @@
  * 내부적으로 EventTarget을 사용하여 구현됨.
  *
  * @typeParam TEvents 이벤트 타입 맵. key는 이벤트 이름, value는 이벤트 데이터 타입
- *
- * @example
- * interface MyEvents {
- *   data: string;
- *   error: Error;
- *   done: void;
- * }
- *
- * class MyEmitter extends EventEmitter<MyEvents> {}
- *
- * const emitter = new MyEmitter();
- * emitter.on("data", (data) => console.log(data)); // data: string
- * emitter.emit("data", "hello");
- * emitter.emit("done"); // void 타입은 인자 없이 호출
  */
 export class EventEmitter<
   TEvents extends { [K in keyof TEvents]: unknown } = Record<string, unknown>,

package/src/features/serial-queue.ts

@@ -4,16 +4,6 @@
  * 큐에 추가된 함수들은 순차적으로 실행됨.
  * 하나의 작업이 완료된 후에야 다음 작업이 시작됨.
  * 에러가 발생해도 후속 작업은 계속 실행됨.
- *
- * @example
- * const queue = new SerialQueue();
- * queue.run(async () => { await fetch("/api/1"); });
- * queue.run(async () => { await fetch("/api/2"); }); // 1 완료 후 실행
- * queue.run(async () => { await fetch("/api/3"); }); // 2 완료 후 실행
- *
- * @example
- * // 에러 처리
- * queue.on("error", (err) => console.error(err));
  */
 import { SdError } from "../errors/sd-error";
 import { EventEmitter } from "./event-emitter";

package/src/types/date-only.ts

@@ -6,11 +6,6 @@ import { format, normalizeMonth } from "../utils/date-format";
  *
  * 시간 정보 없이 날짜만 저장하는 불변 클래스.
  * 로컬 타임존 기준으로 동작함.
- *
- * @example
- * const today = new DateOnly();
- * const specific = new DateOnly(2025, 1, 15);
- * const parsed = DateOnly.parse("2025-01-15");
  */
 export class DateOnly {
   private static readonly _MS_PER_DAY = 24 * 60 * 60 * 1000;
@@ -99,12 +94,6 @@ export class DateOnly {
    * @param weekStartDay 주 시작 요일 (0=일요일, 1=월요일, ..., 6=토요일). 기본값: 1(월요일)
    * @param minDaysInFirstWeek 첫 번째 주로 간주되기 위한 최소 일수 (1~7). 기본값: 4 (ISO 8601 표준)
    * @returns 이 날짜가 포함된 주의 기준 연도와 월
-   *
-   * @example
-   * // ISO 8601 표준 (월요일 시작, 첫 주 최소 4일)
-   * new DateOnly(2024, 1, 1).getBaseYearMonthSeqForWeekSeq(1, 4)
-   * // 미국식 (일요일 시작, 첫 주 최소 1일)
-   * new DateOnly(2024, 1, 1).getBaseYearMonthSeqForWeekSeq(0, 1)
    */
   getBaseYearMonthSeqForWeekSeq(weekStartDay: number = 1, minDaysInFirstWeek: number = 4) {
     // 주 시작 요일 기준 요일 인덱스 계산 (0 = 주 시작 요일)
@@ -155,13 +144,6 @@ export class DateOnly {
    * @param weekStartDay 주 시작 요일 (0=일요일, 1=월요일, ..., 6=토요일). 기본값: 1(월요일)
    * @param minDaysInFirstWeek 첫 번째 주로 간주되기 위한 최소 일수 (1~7). 기본값: 4 (ISO 8601 표준)
    * @returns 해당 연도와 그 연도 내의 주차 번호
-   *
-   * @example
-   * // ISO 8601 표준 (월요일 시작, 첫 주 최소 4일)
-   * new DateOnly(2025, 1, 6).getWeekSeqOfYear(); // { year: 2025, weekSeq: 2 }
-   *
-   * // 미국식 (일요일 시작, 첫 주 최소 1일)
-   * new DateOnly(2025, 1, 1).getWeekSeqOfYear(0, 1); // { year: 2025, weekSeq: 1 }
    */
   getWeekSeqOfYear(
     weekStartDay: number = 1,
@@ -186,13 +168,6 @@ export class DateOnly {
    * @param weekStartDay 주 시작 요일 (0=일요일, 1=월요일, ..., 6=토요일). 기본값: 1(월요일)
    * @param minDaysInFirstWeek 첫 번째 주로 간주되기 위한 최소 일수 (1~7). 기본값: 4 (ISO 8601 표준)
    * @returns 연도, 월, 해당 월 내의 주차 번호
-   *
-   * @example
-   * // ISO 8601 표준 (월요일 시작, 첫 주 최소 4일)
-   * new DateOnly(2025, 1, 15).getWeekSeqOfMonth(); // { year: 2025, monthSeq: 1, weekSeq: 3 }
-   *
-   * // 미국식 (일요일 시작, 첫 주 최소 1일)
-   * new DateOnly(2025, 1, 15).getWeekSeqOfMonth(0, 1); // { year: 2025, monthSeq: 1, weekSeq: 3 }
    */
   getWeekSeqOfMonth(
     weekStartDay: number = 1,
@@ -219,13 +194,6 @@ export class DateOnly {
    * @param weekStartDay 주 시작 요일 (0=일요일, 1=월요일, ..., 6=토요일). 기본값: 1(월요일)
    * @param minDaysInFirstWeek 첫 번째 주로 간주되기 위한 최소 일수 (1~7). 기본값: 4 (ISO 8601 표준)
    * @returns 지정된 주의 시작 날짜
-   *
-   * @example
-   * // 2025년 2주차 시작 날짜 (ISO 8601 표준)
-   * DateOnly.getDateByYearWeekSeq({ year: 2025, weekSeq: 2 }); // 2025-01-06 (월요일)
-   *
-   * // 2025년 1월 3주차 시작 날짜
-   * DateOnly.getDateByYearWeekSeq({ year: 2025, month: 1, weekSeq: 3 }); // 2025-01-13 (월요일)
    */
   static getDateByYearWeekSeq(
     arg: { year: number; month?: number; weekSeq: number },

package/src/types/date-time.ts

@@ -6,11 +6,6 @@ import { convert12To24, format, normalizeMonth } from "../utils/date-format";
  *
  * JavaScript Date 객체를 래핑하여 불변성과 편리한 API를 제공.
  * 밀리초 정밀도를 지원하고 로컬 타임존 기준으로 동작함.
- *
- * @example
- * const now = new DateTime();
- * const specific = new DateTime(2025, 1, 15, 10, 30, 0);
- * const parsed = DateTime.parse("2025-01-15 10:30:00");
  */
 export class DateTime {
   readonly date: Date;
@@ -65,13 +60,6 @@ export class DateTime {
    * @param str DateTime 문자열
    * @returns 파싱된 DateTime 인스턴스
    * @throws ArgumentError 지원하지 않는 형식인 경우
-   *
-   * @example
-   * DateTime.parse("2025-01-15 10:30:00")     // yyyy-MM-dd HH:mm:ss
-   * DateTime.parse("2025-01-15 10:30:00.123") // yyyy-MM-dd HH:mm:ss.fff
-   * DateTime.parse("20250115103000")          // yyyyMMddHHmmss
-   * DateTime.parse("2025-01-15 AM 10:30:00")  // yyyy-MM-dd AM/PM HH:mm:ss
-   * DateTime.parse("2025-01-15T10:30:00Z")    // ISO 8601
    */
   static parse(str: string): DateTime {
     const parsedTick = Date.parse(str);

package/src/types/lazy-gc-map.ts

@@ -6,14 +6,6 @@ import { createLogger } from "../features/logger";
  *
  * @note 사용 후 반드시 dispose()를 호출해야 함.
  *       그렇지 않으면 GC 타이머가 계속 실행되어 메모리 누수 발생.
- *
- * @example
- * const map = new LazyGcMap({ gcInterval: 10000, expireTime: 60000 });
- * try {
- *   // ... 사용
- * } finally {
- *   map.dispose();
- * }
  */
 export class LazyGcMap<TKey, TValue> {
   private static readonly _logger = createLogger("LazyGcMap");

package/src/types/time.ts

@@ -6,11 +6,6 @@ import { convert12To24, format } from "../utils/date-format";
  *
  * 날짜 정보 없이 시간만 저장하는 불변 클래스.
  * 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;
@@ -60,12 +55,6 @@ export class 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("AM 10:30:00")        // AM/PM HH:mm:ss
-   * Time.parse("2025-01-15T10:30:00") // ISO 8601 (extract time part only)
    */
   static parse(str: string): Time {
     const match1 = /(AM|PM) ([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2})(\.([0-9]{1,3}))?$/i.exec(str);

package/src/types/uuid.ts

@@ -5,10 +5,6 @@ import { ArgumentError } from "../errors/argument-error";
  * UUID v4 클래스
  *
  * crypto.getRandomValues 기반으로 암호학적으로 안전한 UUID를 생성. (Chrome 79+, Node.js 호환)
- *
- * @example
- * const id = Uuid.generate();
- * const fromStr = new Uuid("550e8400-e29b-41d4-a716-446655440000");
  */
 export class Uuid {
   // 0x00 ~ 0xFF에 대한 hex 문자열 사전 계산 (256개 항목)

package/src/utils/bytes.ts

@@ -28,11 +28,6 @@ const BASE64_LOOKUP: number[] = Array.from({ length: 256 }, (_, i) => {
  * 여러 Uint8Array 결합
  * @param arrays 결합할 Uint8Array 배열
  * @returns 결합된 새 Uint8Array
- * @example
- * const a = new Uint8Array([1, 2]);
- * const b = new Uint8Array([3, 4]);
- * concat([a, b]);
- * // Uint8Array([1, 2, 3, 4])
  */
 export function concat(arrays: Bytes[]): Bytes {
   const total = arrays.reduce((sum, arr) => sum + arr.length, 0);
@@ -49,9 +44,6 @@ export function concat(arrays: Bytes[]): Bytes {
  * hex 문자열로 변환
  * @param bytes 변환할 Uint8Array
  * @returns 소문자 hex 문자열
- * @example
- * toHex(new Uint8Array([255, 0, 127]));
- * // "ff007f"
  */
 export function toHex(bytes: Bytes): string {
   const h = hexTable;
@@ -67,9 +59,6 @@ export function toHex(bytes: Bytes): string {
  * @param hex 변환할 hex 문자열 (대소문자 허용)
  * @returns 변환된 Uint8Array
  * @throws {ArgumentError} 홀수 길이이거나 유효하지 않은 hex 문자가 포함된 경우
- * @example
- * fromHex("ff007f");
- * // Uint8Array([255, 0, 127])
  */
 export function fromHex(hex: string): Bytes {
   if (hex.length % 2 !== 0) {
@@ -89,9 +78,6 @@ export function fromHex(hex: string): Bytes {
  * Bytes를 base64 문자열로 변환
  * @param bytes 변환할 Uint8Array
  * @returns Base64 인코딩된 문자열
- * @example
- * toBase64(new Uint8Array([72, 101, 108, 108, 111]));
- * // "SGVsbG8="
  */
 export function toBase64(bytes: Bytes): string {
   if (bytes.length === 0) {
@@ -117,9 +103,6 @@ export function toBase64(bytes: Bytes): string {
  * @param base64 변환할 base64 문자열
  * @returns 디코딩된 Uint8Array
  * @throws {ArgumentError} 유효하지 않은 base64 문자가 포함된 경우
- * @example
- * fromBase64("SGVsbG8=");
- * // Uint8Array([72, 101, 108, 108, 111])
  */
 export function fromBase64(base64: string): Bytes {
   // 공백 제거 및 패딩 정규화

package/src/utils/date-format.ts

@@ -16,10 +16,6 @@ export interface DtNormalizedMonth {
  * @param month 설정할 월 (1-12 범위 밖의 값 허용)
  * @param day 기준 일
  * @returns 정규화된 연도, 월, 일
- *
- * @example
- * normalizeMonth(2025, 13, 15) // { year: 2026, month: 1, day: 15 }
- * normalizeMonth(2025, 2, 31)  // { year: 2025, month: 2, day: 28 }
  */
 export function normalizeMonth(year: number, month: number, day: number): DtNormalizedMonth {
   // 월 오버플로우/언더플로우 정규화
@@ -123,18 +119,6 @@ const weekStrings = ["일", "월", "화", "수", "목", "금", "토"];
  * | zzz | 타임존 오프셋 (±HH:mm) | +09:00 |
  * | zz | 타임존 오프셋 (±HH) | +09 |
  * | z | 타임존 오프셋 (±H) | +9 |
- *
- * @example
- * ```typescript
- * formatDate("yyyy-MM-dd", { year: 2024, month: 3, day: 15 });
- * // "2024-03-15"
- *
- * formatDate("yyyy-M-d (ddd)", { year: 2024, month: 3, day: 15 });
- * // "2024-3-15 (Fri)"
- *
- * formatDate("tt h:mm:ss", { hour: 14, minute: 30, second: 45 });
- * // "PM 2:30:45"
- * ```
  */
 export function format(
   formatString: string,

package/src/utils/num.ts

@@ -59,15 +59,6 @@ export function parseFloat(text: unknown): number | undefined {
  *
  * @param val 검사할 값
  * @returns undefined, null, 또는 0이면 true
- * @example
- * const count: number | undefined = getValue();
- * if (isNullOrEmpty(count)) {
- *   // count: 0 | undefined
- *   console.log("Empty");
- * } else {
- *   // count: number (non-zero value)
- *   console.log(`Count: ${count}`);
- * }
  */
 export function isNullOrEmpty(val: number | undefined): val is 0 | undefined {
   return val == null || val === 0;
@@ -83,9 +74,6 @@ export function isNullOrEmpty(val: number | undefined): val is 0 | undefined {
  * @param digit 소수점 옵션
  * @param digit.max 최대 소수점 자릿수
  * @param digit.min 최소 소수점 자릿수 (부족하면 0으로 채움)
- * @example
- * format(1234.567, { max: 2 }) // "1,234.57"
- * format(1234, { min: 2 }) // "1,234.00"
  */
 export function format(val: number, digit?: { max?: number; min?: number }): string;
 export function format(

package/src/utils/obj.ts

@@ -153,9 +153,7 @@ export interface EqualOptions {
  * @param target 비교 대상 2
  * @param options 비교 옵션
  * @param options.topLevelIncludes 비교할 key 목록. 지정 시 해당 key만 비교 (최상위 레벨에만 적용)
- *   @example `{ topLevelIncludes: ["id", "name"] }` - id와 name key만 비교
  * @param options.topLevelExcludes 비교에서 제외할 key 목록 (최상위 레벨에만 적용)
- *   @example `{ topLevelExcludes: ["updatedAt"] }` - updatedAt key를 제외하고 비교
  * @param options.ignoreArrayIndex array 순서를 무시할지 여부. true면 O(n²) 복잡도
  * @param options.shallow 얕은 비교 여부. true면 1단계만 비교 (참조 비교)
  *
@@ -549,14 +547,6 @@ export interface Merge3KeyOptions {
  *   - `excludes`: 비교에서 제외할 하위 key 목록
  *   - `ignoreArrayIndex`: array 순서를 무시할지 여부
  * @returns conflict: 충돌 발생 여부, result: 병합 결과
- *
- * @example
- * const { conflict, result } = merge3(
- *   { a: 1, b: 2 },  // source
- *   { a: 1, b: 1 },  // origin
- *   { a: 2, b: 1 },  // target
- * );
- * // conflict: false, result: { a: 2, b: 2 }
  */
 export function merge3<
   S extends Record<string, unknown>,
@@ -601,10 +591,6 @@ export function merge3<
  * @param item 원본 객체
  * @param omitKeys 제외할 key 배열
  * @returns 지정된 key가 제외된 새 객체
- * @example
- * const user = { name: "Alice", age: 30, email: "alice@example.com" };
- * omit(user, ["email"]);
- * // { name: "Alice", age: 30 }
  */
 export function omit<T extends Record<string, unknown>, K extends keyof T>(
   item: T,
@@ -625,10 +611,6 @@ export function omit<T extends Record<string, unknown>, K extends keyof T>(
  * @param item 원본 객체
  * @param omitKeyFn key를 받아 제외 여부를 반환하는 함수 (true면 제외)
  * @returns 조건에 맞는 key가 제외된 새 객체
- * @example
- * const data = { name: "Alice", _internal: "secret", age: 30 };
- * omitByFilter(data, (key) => key.startsWith("_"));
- * // { name: "Alice", age: 30 }
  */
 export function omitByFilter<T extends Record<string, unknown>>(
   item: T,
@@ -648,10 +630,6 @@ export function omitByFilter<T extends Record<string, unknown>>(
  * @param item 원본 객체
  * @param keys 선택할 key 배열
  * @returns 지정된 key만 포함된 새 객체
- * @example
- * const user = { name: "Alice", age: 30, email: "alice@example.com" };
- * pick(user, ["name", "age"]);
- * // { name: "Alice", age: 30 }
  */
 export function pick<T extends Record<string, unknown>, K extends keyof T>(
   item: T,
@@ -692,7 +670,6 @@ function getChainSplits(chain: string): (string | number)[] {
 
 /**
  * 체인 경로로 값 조회
- * @example getChainValue(obj, "a.b[0].c")
  */
 export function getChainValue(obj: unknown, chain: string, optional: true): unknown | undefined;
 export function getChainValue(obj: unknown, chain: string): unknown;
@@ -721,7 +698,6 @@ export function getChainValue(
  * @param depth 하강 깊이 (1 이상)
  * @param optional true이면 중간에 null/undefined를 만나도 에러 없이 undefined 반환
  * @throws ArgumentError depth가 1 미만인 경우
- * @example getChainValueByDepth({ parent: { parent: { name: 'a' } } }, 'parent', 2) => { name: 'a' }
  */
 export function getChainValueByDepth<TObject, TKey extends keyof TObject>(
   obj: TObject,
@@ -756,7 +732,6 @@ export function getChainValueByDepth<TObject, TKey extends keyof TObject>(
 
 /**
  * 체인 경로로 값 설정
- * @example setChainValue(obj, "a.b[0].c", value)
  */
 export function setChainValue(obj: unknown, chain: string, value: unknown): void {
   const splits = getChainSplits(chain);
@@ -776,7 +751,6 @@ export function setChainValue(obj: unknown, chain: string, value: unknown): void
 
 /**
  * 체인 경로로 값 삭제
- * @example deleteChainValue(obj, "a.b[0].c")
  */
 export function deleteChainValue(obj: unknown, chain: string): void {
   const splits = getChainSplits(chain);
@@ -882,7 +856,6 @@ function nullToUndefinedImpl<TObject>(obj: TObject, seen: WeakSet<object>): TObj
 /**
  * 평탄화된 객체를 중첩 객체로 변환
  * @internal
- * @example unflatten({ "a.b.c": 1 }) => { a: { b: { c: 1 } } }
  */
 export function unflatten(flatObj: Record<string, unknown>): Record<string, unknown> {
   const result: Record<string, unknown> = {};
@@ -914,7 +887,6 @@ export function unflatten(flatObj: Record<string, unknown>): Record<string, unkn
 
 /**
  * undefined를 가진 속성을 optional로 변환
- * @example { a: string; b: string | undefined } → { a: string; b?: string | undefined }
  */
 export type UndefToOptional<TObject> = {
   [K in keyof TObject as undefined extends TObject[K] ? K : never]?: TObject[K];
@@ -922,7 +894,6 @@ export type UndefToOptional<TObject> = {
 
 /**
  * optional 속성을 필수 + undefined 유니온으로 변환
- * @example { a: string; b?: string } → { a: string; b: string | undefined }
  */
 export type OptionalToUndef<TObject> = {
   [K in keyof TObject]-?: {} extends Pick<TObject, K> ? TObject[K] | undefined : TObject[K];
@@ -964,16 +935,6 @@ type Entries<TObject> = { [K in keyof TObject]: [K, TObject[K]] }[keyof TObject]
  * @param obj 변환할 객체
  * @param fn 변환 함수 (key, value) => [newKey, newValue]
  * @returns key와 value가 변환된 새 객체
- * @example
- * const colors = { primary: "255, 0, 0", secondary: "0, 255, 0" };
- *
- * // 값만 변환
- * map(colors, (key, rgb) => [null, `rgb(${rgb})`]);
- * // { primary: "rgb(255, 0, 0)", secondary: "rgb(0, 255, 0)" }
- *
- * // key와 값 모두 변환
- * map(colors, (key, rgb) => [`${key}Light`, `rgb(${rgb})`]);
- * // { primaryLight: "rgb(255, 0, 0)", secondaryLight: "rgb(0, 255, 0)" }
  */
 export function map<TSource extends object, TNewKey extends string, TNewValue>(
   obj: TSource,

package/src/utils/primitive.ts

@@ -13,12 +13,6 @@ import type { PrimitiveTypeMap, PrimitiveTypeStr } from "../common.types";
  * @param value 타입을 추론할 값
  * @returns 값에 해당하는 PrimitiveTypeStr
  * @throws ArgumentError 지원하지 않는 타입인 경우
- *
- * @example
- * getPrimitiveTypeStr("hello") // "string"
- * getPrimitiveTypeStr(123) // "number"
- * getPrimitiveTypeStr(new DateTime()) // "DateTime"
- * getPrimitiveTypeStr(new Uint8Array()) // "Bytes"
  */
 export function typeStr(value: PrimitiveTypeMap[PrimitiveTypeStr]): PrimitiveTypeStr {
   if (typeof value === "string") return "string";