@simplysm/core-node 13.0.0-beta.1

package/README.md

@@ -0,0 +1,375 @@
+# @simplysm/core-node
+
+A Node.js-specific utility package for the Simplysm framework. It provides path handling, file system operations, file change detection, and type-safe Worker thread wrappers.
+
+## Requirements
+
+- Node.js 20.11+ (requires `import.meta.filename`/`import.meta.dirname` support)
+
+## Installation
+
+```bash
+npm install @simplysm/core-node
+# or
+pnpm add @simplysm/core-node
+```
+
+## Main Modules
+
+### Path Utilities (`utils/path`)
+
+Provides path conversion, normalization, comparison, and filtering functions.
+
+| Function/Type | Description |
+|---------------|-------------|
+| `NormPath` | A branded type created by `pathNorm()`. Represents a normalized absolute path. |
+| `pathPosix(...args)` | Converts to POSIX-style path (replaces backslashes with slashes). |
+| `pathNorm(...paths)` | Normalizes paths and returns as `NormPath`. Converts to absolute path and normalizes with platform-specific separators. |
+| `pathIsChildPath(childPath, parentPath)` | Checks if `childPath` is a child path of `parentPath`. Returns `false` for identical paths. |
+| `pathChangeFileDirectory(filePath, fromDir, toDir)` | Changes the directory of a file path. Throws an error if the file is not within `fromDir`. |
+| `pathGetBasenameWithoutExt(filePath)` | Returns the filename (basename) without extension. |
+| `pathFilterByTargets(files, targets, cwd)` | Filters files based on target path list. Returns `files` as-is if `targets` is an empty array. |
+
+```typescript
+import {
+  pathPosix,
+  pathNorm,
+  pathIsChildPath,
+  pathChangeFileDirectory,
+  pathGetBasenameWithoutExt,
+  pathFilterByTargets,
+} from "@simplysm/core-node";
+
+// Convert to POSIX-style path
+pathPosix("C:\\Users\\test"); // "C:/Users/test"
+pathPosix("src", "index.ts"); // "src/index.ts"
+
+// Normalize path (convert to absolute path)
+const normPath = pathNorm("src", "index.ts"); // Returns NormPath type
+
+// Check child path relationship
+pathIsChildPath("/a/b/c", "/a/b"); // true
+pathIsChildPath("/a/b", "/a/b/c"); // false
+pathIsChildPath("/a/b", "/a/b");   // false (same path)
+
+// Change file directory
+pathChangeFileDirectory("/a/b/c.txt", "/a", "/x"); // "/x/b/c.txt"
+
+// Return filename without extension
+pathGetBasenameWithoutExt("file.txt");             // "file"
+pathGetBasenameWithoutExt("/path/to/file.spec.ts"); // "file.spec"
+
+// Filter files by target paths
+const files = ["/proj/src/a.ts", "/proj/src/b.ts", "/proj/tests/c.ts"];
+pathFilterByTargets(files, ["src"], "/proj");
+// ["/proj/src/a.ts", "/proj/src/b.ts"]
+```
+
+---
+
+### File System Utilities (`utils/fs`)
+
+Provides functions for reading, writing, deleting, copying, and searching files and directories. Most functions come in both async and sync (`Sync` suffix) versions.
+
+#### Existence Check
+
+| Function | Description |
+|----------|-------------|
+| `fsExists(targetPath)` | Asynchronously checks if a file or directory exists. |
+| `fsExistsSync(targetPath)` | Synchronously checks if a file or directory exists. |
+
+#### Directory Creation
+
+| Function | Description |
+|----------|-------------|
+| `fsMkdir(targetPath)` | Asynchronously creates a directory (recursive). |
+| `fsMkdirSync(targetPath)` | Synchronously creates a directory (recursive). |
+
+#### Deletion
+
+| Function | Description |
+|----------|-------------|
+| `fsRm(targetPath)` | Asynchronously deletes a file or directory. Retries up to 6 times (500ms intervals) for transient errors like file locks. |
+| `fsRmSync(targetPath)` | Synchronously deletes a file or directory. Fails immediately without retries. |
+
+#### Copy
+
+| Function | Description |
+|----------|-------------|
+| `fsCopy(sourcePath, targetPath, filter?)` | Asynchronously copies a file or directory. Can filter copy targets with a `filter` function. Does nothing if `sourcePath` doesn't exist. |
+| `fsCopySync(sourcePath, targetPath, filter?)` | Synchronously copies a file or directory. |
+
+#### File Reading
+
+| Function | Description |
+|----------|-------------|
+| `fsRead(targetPath)` | Asynchronously reads a file as a UTF-8 string. |
+| `fsReadSync(targetPath)` | Synchronously reads a file as a UTF-8 string. |
+| `fsReadBuffer(targetPath)` | Asynchronously reads a file as a Buffer. |
+| `fsReadBufferSync(targetPath)` | Synchronously reads a file as a Buffer. |
+| `fsReadJson<T>(targetPath)` | Asynchronously reads a JSON file (uses `jsonParse`). |
+| `fsReadJsonSync<T>(targetPath)` | Synchronously reads a JSON file (uses `jsonParse`). |
+
+#### File Writing
+
+| Function | Description |
+|----------|-------------|
+| `fsWrite(targetPath, data)` | Asynchronously writes a file. Automatically creates parent directories if they don't exist. `data` is `string` or `Uint8Array`. |
+| `fsWriteSync(targetPath, data)` | Synchronously writes a file. Automatically creates parent directories. |
+| `fsWriteJson(targetPath, data, options?)` | Asynchronously writes a JSON file (uses `jsonStringify`). Can specify `replacer` and `space` in `options`. |
+| `fsWriteJsonSync(targetPath, data, options?)` | Synchronously writes a JSON file. |
+
+#### Directory Reading
+
+| Function | Description |
+|----------|-------------|
+| `fsReaddir(targetPath)` | Asynchronously reads directory contents. |
+| `fsReaddirSync(targetPath)` | Synchronously reads directory contents. |
+
+#### File Information
+
+| Function | Description |
+|----------|-------------|
+| `fsStat(targetPath)` | Asynchronously retrieves file/directory information (follows symbolic links). |
+| `fsStatSync(targetPath)` | Synchronously retrieves file/directory information (follows symbolic links). |
+| `fsLstat(targetPath)` | Asynchronously retrieves file/directory information (symbolic link itself). |
+| `fsLstatSync(targetPath)` | Synchronously retrieves file/directory information (symbolic link itself). |
+
+#### Glob Search
+
+| Function | Description |
+|----------|-------------|
+| `fsGlob(pattern, options?)` | Asynchronously searches for files with a glob pattern. Returns an array of absolute paths of matched files. |
+| `fsGlobSync(pattern, options?)` | Synchronously searches for files with a glob pattern. |
+
+#### Other Utilities
+
+| Function | Description |
+|----------|-------------|
+| `fsClearEmptyDirectory(dirPath)` | Recursively deletes empty directories under the specified directory. |
+| `fsFindAllParentChildPaths(childGlob, fromPath, rootPath?)` | Traverses parent directories from the start path toward the root, asynchronously searching with a glob pattern. |
+| `fsFindAllParentChildPathsSync(childGlob, fromPath, rootPath?)` | Synchronous version of the above. |
+
+```typescript
+import {
+  fsExists,
+  fsRead,
+  fsWrite,
+  fsReadJson,
+  fsWriteJson,
+  fsStat,
+  fsLstat,
+  fsReaddir,
+  fsGlob,
+  fsMkdir,
+  fsRm,
+  fsCopy,
+  fsClearEmptyDirectory,
+  fsFindAllParentChildPaths,
+  fsReadBuffer,
+} from "@simplysm/core-node";
+
+// Check existence
+if (await fsExists("/path/to/file.txt")) {
+  // ...
+}
+
+// Read/write files
+const content = await fsRead("/path/to/file.txt");
+await fsWrite("/path/to/output.txt", "content"); // Automatically creates parent directories
+
+// Read binary files
+const buffer = await fsReadBuffer("/path/to/file.bin");
+
+// Read/write JSON files (uses JsonConvert)
+interface Config { port: number; host: string }
+const config = await fsReadJson<Config>("/path/to/config.json");
+await fsWriteJson("/path/to/output.json", data, { space: 2 });
+
+// Retrieve file information
+const stat = await fsStat("/path/to/file.txt");   // Follows symbolic links
+const lstat = await fsLstat("/path/to/link");      // Symbolic link itself
+
+// Read directory
+const entries = await fsReaddir("/path/to/dir");
+
+// Search files with glob pattern
+const tsFiles = await fsGlob("**/*.ts");
+
+// Create/delete directories
+await fsMkdir("/path/to/dir"); // recursive
+await fsRm("/path/to/target");
+
+// Recursively delete empty directories
+await fsClearEmptyDirectory("/path/to/dir");
+
+// Copy files/directories (exclude node_modules with filter function)
+await fsCopy("/src", "/dest", (path) => !path.includes("node_modules"));
+
+// Traverse parent directories and glob search
+const configs = await fsFindAllParentChildPaths(
+  "package.json",
+  "/proj/src/sub",
+  "/proj",
+);
+```
+
+> It's recommended to use async functions except when async cannot be used (e.g., in constructors). Sync functions block the event loop and can cause performance degradation.
+
+---
+
+### FsWatcher (`features/fs-watcher`)
+
+A chokidar-based file system change detection wrapper. It merges events that occur within a short time and invokes callbacks.
+
+| API | Description |
+|-----|-------------|
+| `FsWatcher.watch(paths, options?)` | Starts file watching (static, async). Waits until chokidar's `ready` event and returns an `FsWatcher` instance. |
+| `watcher.onChange(opt, cb)` | Registers a file change event handler. Set event merge wait time (ms) with `opt.delay`. Supports chaining. |
+| `watcher.close()` | Stops file watching. |
+| `FsWatcherEvent` | Event type: `"add"` \| `"addDir"` \| `"change"` \| `"unlink"` \| `"unlinkDir"` |
+| `FsWatcherChangeInfo` | Change information interface. Has `event: FsWatcherEvent` and `path: NormPath` fields. |
+
+**Event Merge Strategy:**
+
+When multiple events occur for the same file within a short time, only the final state is delivered.
+
+| Previous Event | New Event | Result |
+|----------------|-----------|--------|
+| `add` | `change` | `add` (modification right after creation is treated as creation) |
+| `add` | `unlink` | Deleted (immediate deletion after creation is treated as no change) |
+| `unlink` | `add` / `change` | `add` (recreation after deletion) |
+| `unlinkDir` | `addDir` | `addDir` (directory recreation) |
+| Others | - | Overwritten with the latest event |
+
+```typescript
+import { FsWatcher } from "@simplysm/core-node";
+
+// Start file watching
+const watcher = await FsWatcher.watch(["src/**/*.ts"]);
+
+// Register change event handler (merge events within 300ms)
+watcher.onChange({ delay: 300 }, (changes) => {
+  for (const { path, event } of changes) {
+    console.log(`${event}: ${path}`);
+    // event: "add" | "addDir" | "change" | "unlink" | "unlinkDir"
+  }
+});
+
+// Stop watching
+await watcher.close();
+```
+
+---
+
+### Worker (`worker/`)
+
+Provides a type-safe Worker wrapper based on Node.js `worker_threads`. Using Proxy, you can call worker methods as if calling them directly, and custom events are also supported.
+
+| API | Description |
+|-----|-------------|
+| `Worker.create<TModule>(filePath, opt?)` | Creates a type-safe Worker Proxy. `filePath` is a `file://` URL or absolute path. |
+| `createWorker<TMethods, TEvents>(methods)` | Worker factory used inside worker threads. Registers method objects and returns a sender that can send events. |
+| `WorkerModule` | Module type interface used for type inference in `Worker.create<typeof import("./worker")>()`. |
+| `WorkerProxy<TModule>` | Proxy type returned by `Worker.create()`. Provides promisified methods, `on()`, `off()`, `terminate()`. |
+| `PromisifyMethods<T>` | Utility type that wraps method return values in `Promise`. |
+| `WorkerRequest` | Worker internal request message interface. |
+| `WorkerResponse` | Worker internal response message type (`"return"` \| `"error"` \| `"event"` \| `"log"`). |
+
+**Basic Usage (without events):**
+
+```typescript
+// worker.ts - worker file
+import { createWorker } from "@simplysm/core-node";
+
+export default createWorker({
+  add: (a: number, b: number) => a + b,
+  multiply: (a: number, b: number) => a * b,
+});
+
+// main.ts - main thread
+import { Worker } from "@simplysm/core-node";
+import type * as MyWorker from "./worker";
+import path from "path";
+
+const worker = Worker.create<typeof MyWorker>(
+  path.resolve(import.meta.dirname, "./worker.ts"),
+);
+
+const sum = await worker.add(10, 20);      // 30
+const product = await worker.multiply(3, 4); // 12
+
+await worker.terminate();
+```
+
+**Worker with Events:**
+
+```typescript
+// worker.ts
+import { createWorker } from "@simplysm/core-node";
+
+interface MyEvents {
+  progress: number;
+}
+
+// sender is defined below, but is referenced at function execution time due to closure
+const methods = {
+  calculate: (a: number, b: number) => {
+    sender.send("progress", 50);
+    const result = a + b;
+    sender.send("progress", 100);
+    return result;
+  },
+};
+
+const sender = createWorker<typeof methods, MyEvents>(methods);
+export default sender;
+
+// main.ts
+import { Worker } from "@simplysm/core-node";
+import type * as MyWorker from "./worker";
+import path from "path";
+
+const worker = Worker.create<typeof MyWorker>(
+  path.resolve(import.meta.dirname, "./worker.ts"),
+);
+
+// Register event listener
+worker.on("progress", (percent) => {
+  console.log(`Progress: ${percent}%`);
+});
+
+const result = await worker.calculate(10, 20); // 30
+
+// Remove event listener
+const listener = (percent: number) => { /* ... */ };
+worker.on("progress", listener);
+worker.off("progress", listener);
+
+await worker.terminate();
+```
+
+---
+
+## Important Notes
+
+- All functions throw errors wrapped in `SdError` to include path information.
+- `fsRm` (async) retries up to 6 times (500ms intervals) for transient errors like file locks, but `fsRmSync` (sync) fails immediately without retries.
+- In `fsCopy`/`fsCopySync`, the `filter` function is not applied to the top-level `sourcePath`, and returning `false` for a directory skips that directory and all its children.
+- `FsWatcher` internally enforces `ignoreInitial: true`. If you pass `ignoreInitial: false`, the callback will be called with an empty array on the first `onChange` call, but the actual initial file list will not be included.
+- Worker automatically runs TypeScript worker files through `tsx` in development environment (`.ts` files). In production environment (`.js`), it creates Workers directly.
+- This package depends on `@simplysm/core-common` and uses `jsonParse`/`jsonStringify` for JSON processing.
+
+## Dependencies
+
+| Package | Purpose |
+|---------|---------|
+| `@simplysm/core-common` | Common utilities (`SdError`, `jsonParse`, `jsonStringify`, `EventEmitter`, `DebounceQueue`, etc.) |
+| `chokidar` | File system change detection (`FsWatcher`) |
+| `consola` | Logging |
+| `glob` | Glob pattern file search (`fsGlob`, `fsGlobSync`) |
+| `tsx` | Running TypeScript worker files in development environment |
+
+## License
+
+Apache-2.0

package/dist/core-common/src/common.types.d.ts

@@ -0,0 +1,74 @@
+import { DateTime } from "./types/date-time";
+import { DateOnly } from "./types/date-only";
+import { Time } from "./types/time";
+import { Uuid } from "./types/uuid";
+/**
+ * Buffer 대신 사용하는 바이너리 타입
+ */
+export type Bytes = Uint8Array;
+/**
+ * Primitive 타입 매핑
+ * orm-common과 공유
+ */
+export type PrimitiveTypeMap = {
+    string: string;
+    number: number;
+    boolean: boolean;
+    DateTime: DateTime;
+    DateOnly: DateOnly;
+    Time: Time;
+    Uuid: Uuid;
+    Bytes: Bytes;
+};
+/**
+ * Primitive 타입 문자열 키
+ */
+export type PrimitiveTypeStr = keyof PrimitiveTypeMap;
+/**
+ * Primitive 타입 유니온
+ */
+export type PrimitiveType = PrimitiveTypeMap[PrimitiveTypeStr] | undefined;
+/**
+ * 깊은 Partial 타입
+ *
+ * 객체의 모든 속성을 재귀적으로 선택적(optional)으로 만듭니다.
+ * Primitive 타입(string, number, boolean 등)은 그대로 유지하고,
+ * 객체/배열 타입만 재귀적으로 Partial을 적용합니다.
+ *
+ * @example
+ * ```typescript
+ * interface User {
+ *   name: string;
+ *   profile: {
+ *     age: number;
+ *     address: { city: string };
+ *   };
+ * }
+ *
+ * // 모든 깊이의 속성이 선택적이 됨
+ * const partial: DeepPartial<User> = {
+ *   profile: { address: {} }
+ * };
+ * ```
+ */
+export type DeepPartial<T> = Partial<{
+    [K in keyof T]: T[K] extends PrimitiveType ? T[K] : DeepPartial<T[K]>;
+}>;
+/**
+ * 생성자 타입
+ *
+ * 클래스 생성자를 타입으로 표현할 때 사용합니다.
+ * 주로 의존성 주입, 팩토리 패턴, instanceof 체크 등에서 활용됩니다.
+ *
+ * @example
+ * function create<T>(ctor: Type<T>): T {
+ *   return new ctor();
+ * }
+ *
+ * class MyClass { name = "test"; }
+ * const instance = create(MyClass); // MyClass 인스턴스
+ */
+export interface Type<T> extends Function {
+    new (...args: unknown[]): T;
+}
+//# sourceMappingURL=common.types.d.ts.map

package/dist/core-common/src/common.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.types.d.ts","sourceRoot":"","sources":["../../../../core-common/src/common.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AACpC,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAIpC;;GAEG;AACH,MAAM,MAAM,KAAK,GAAG,UAAU,CAAC;AAM/B;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,QAAQ,CAAC;IACnB,QAAQ,EAAE,QAAQ,CAAC;IACnB,IAAI,EAAE,IAAI,CAAC;IACX,IAAI,EAAE,IAAI,CAAC;IACX,KAAK,EAAE,KAAK,CAAC;CACd,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,gBAAgB,CAAC;AAEtD;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,gBAAgB,CAAC,gBAAgB,CAAC,GAAG,SAAS,CAAC;AAM3E;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,OAAO,CAAC;KAClC,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,aAAa,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACtE,CAAC,CAAC;AAEH;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,IAAI,CAAC,CAAC,CAAE,SAAQ,QAAQ;IACvC,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC;CAC7B"}

package/dist/core-common/src/env.d.ts

@@ -0,0 +1,6 @@
+export declare const env: {
+    DEV: boolean;
+    VER?: string;
+    [key: string]: unknown;
+};
+//# sourceMappingURL=env.d.ts.map

package/dist/core-common/src/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../../../core-common/src/env.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,GAAG,EAAE;IAChB,GAAG,EAAE,OAAO,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CAKxB,CAAC"}

package/dist/core-common/src/errors/argument-error.d.ts

@@ -0,0 +1,25 @@
+import { SdError } from "./sd-error";
+/**
+ * 인수 오류
+ *
+ * 잘못된 인수를 받았을 때 발생시키는 에러이다.
+ * 인수 객체를 YAML 형식으로 메시지에 포함하여 디버깅을 용이하게 한다.
+ *
+ * @example
+ * // 인수 객체만 전달
+ * throw new ArgumentError({ userId: 123, name: null });
+ * // 결과 메시지: "인수가 잘못되었습니다.\n\nuserId: 123\nname: null"
+ *
+ * @example
+ * // 커스텀 메시지와 인수 객체 전달
+ * throw new ArgumentError("유효하지 않은 사용자", { userId: 123 });
+ * // 결과 메시지: "유효하지 않은 사용자\n\nuserId: 123"
+ */
+export declare class ArgumentError extends SdError {
+    /** 기본 메시지("인수가 잘못되었습니다.")와 함께 인수 객체를 YAML 형식으로 출력 */
+    constructor(argObj: Record<string, unknown>);
+    /** 커스텀 메시지와 함께 인수 객체를 YAML 형식으로 출력 */
+    constructor(message: string, argObj: Record<string, unknown>);
+    constructor(arg1: Record<string, unknown> | string, arg2?: Record<string, unknown>);
+}
+//# sourceMappingURL=argument-error.d.ts.map

package/dist/core-common/src/errors/argument-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"argument-error.d.ts","sourceRoot":"","sources":["../../../../../core-common/src/errors/argument-error.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAErC;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,aAAc,SAAQ,OAAO;IACxC,qDAAqD;gBACzC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC3C,sCAAsC;gBAC1B,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;gBAChD,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAYnF"}

package/dist/core-common/src/errors/not-implemented-error.d.ts

@@ -0,0 +1,29 @@
+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 declare class NotImplementedError extends SdError {
+    /**
+     * @param message 추가 설명 메시지
+     */
+    constructor(message?: string);
+}
+//# sourceMappingURL=not-implemented-error.d.ts.map

package/dist/core-common/src/errors/not-implemented-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"not-implemented-error.d.ts","sourceRoot":"","sources":["../../../../../core-common/src/errors/not-implemented-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,mBAAoB,SAAQ,OAAO;IAC9C;;OAEG;gBACS,OAAO,CAAC,EAAE,MAAM;CAI7B"}

package/dist/core-common/src/errors/sd-error.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 오류의 Tree 구조 구성이 가능한 오류 클래스
+ * ES2024 cause 속성 활용
+ *
+ * @example
+ * // 원인 에러를 감싸서 생성
+ * try {
+ *   await fetch(url);
+ * } catch (err) {
+ *   throw new SdError(err, "API 호출 실패", "사용자 로드 실패");
+ * }
+ * // 결과 메시지: "사용자 로드 실패 => API 호출 실패 => 원본 에러 메시지"
+ *
+ * @example
+ * // 메시지만으로 생성
+ * throw new SdError("잘못된 상태", "처리 불가");
+ * // 결과 메시지: "처리 불가 => 잘못된 상태"
+ */
+export declare class SdError extends Error {
+    cause?: Error;
+    /** 원인 에러를 감싸서 생성. 메시지는 역순으로 연결됨 (상위 메시지 => 하위 메시지 => 원인 메시지) */
+    constructor(cause: Error, ...messages: string[]);
+    /** 메시지만으로 생성. 메시지는 역순으로 연결됨 (상위 메시지 => 하위 메시지) */
+    constructor(...messages: string[]);
+    constructor(arg1?: unknown, ...messages: string[]);
+}
+//# sourceMappingURL=sd-error.d.ts.map

package/dist/core-common/src/errors/sd-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sd-error.d.ts","sourceRoot":"","sources":["../../../../../core-common/src/errors/sd-error.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,OAAQ,SAAQ,KAAK;IACvB,KAAK,CAAC,EAAE,KAAK,CAAC;IAEvB,gEAAgE;gBACpD,KAAK,EAAE,KAAK,EAAE,GAAG,QAAQ,EAAE,MAAM,EAAE;IAC/C,kDAAkD;gBACtC,GAAG,QAAQ,EAAE,MAAM,EAAE;gBACrB,IAAI,CAAC,EAAE,OAAO,EAAE,GAAG,QAAQ,EAAE,MAAM,EAAE;CA2BlD"}

package/dist/core-common/src/errors/timeout-error.d.ts

@@ -0,0 +1,31 @@
+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 declare class TimeoutError extends SdError {
+    /**
+     * @param count 시도 횟수
+     * @param message 추가 메시지
+     */
+    constructor(count?: number, message?: string);
+}
+//# sourceMappingURL=timeout-error.d.ts.map

package/dist/core-common/src/errors/timeout-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeout-error.d.ts","sourceRoot":"","sources":["../../../../../core-common/src/errors/timeout-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,YAAa,SAAQ,OAAO;IACvC;;;OAGG;gBACS,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM;CAM7C"}

package/dist/core-common/src/extensions/arr-ext.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Array 확장 메서드
+ *
+ * @remarks 각 메서드의 TSDoc은 타입 정의 파일(arr-ext.types.ts) 참조
+ */
+import "./map-ext";
+import type { ReadonlyArrayExt, MutableArrayExt } from "./arr-ext.types";
+declare global {
+    interface ReadonlyArray<T> extends ReadonlyArrayExt<T> {
+    }
+    interface Array<T> extends ReadonlyArrayExt<T>, MutableArrayExt<T> {
+    }
+}
+export type { ArrayDiffsResult, ArrayDiffs2Result, TreeArray, ComparableType } from "./arr-ext.types";
+//# sourceMappingURL=arr-ext.d.ts.map

package/dist/core-common/src/extensions/arr-ext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arr-ext.d.ts","sourceRoot":"","sources":["../../../../../core-common/src/extensions/arr-ext.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,WAAW,CAAC;AAUnB,OAAO,KAAK,EACV,gBAAgB,EAChB,eAAe,EAIhB,MAAM,iBAAiB,CAAC;AA2uBzB,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,aAAa,CAAC,CAAC,CAAE,SAAQ,gBAAgB,CAAC,CAAC,CAAC;KAAG;IACzD,UAAU,KAAK,CAAC,CAAC,CAAE,SAAQ,gBAAgB,CAAC,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC;KAAG;CACtE;AAID,YAAY,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/core-common/src/extensions/arr-ext.helpers.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Array 확장 헬퍼 함수
+ */
+import type { ComparableType } from "./arr-ext.types";
+/**
+ * DateTime, DateOnly, Time을 비교 가능한 primitive 값으로 변환
+ */
+export declare function toComparable(value: ComparableType): string | number | boolean | undefined;
+/**
+ * 정렬을 위한 비교 함수
+ *
+ * @param pp 비교 대상 1
+ * @param pn 비교 대상 2
+ * @param desc true: 내림차순, false: 오름차순
+ * @returns 음수: pp가 앞, 0: 같음, 양수: pn이 앞
+ * @note null/undefined 값은 오름차순 시 앞으로, 내림차순 시 뒤로 정렬됨
+ */
+export declare function compareForOrder(pp: ComparableType, pn: ComparableType, desc: boolean): number;
+//# sourceMappingURL=arr-ext.helpers.d.ts.map

package/dist/core-common/src/extensions/arr-ext.helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arr-ext.helpers.d.ts","sourceRoot":"","sources":["../../../../../core-common/src/extensions/arr-ext.helpers.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAKzF;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,cAAc,EAAE,EAAE,EAAE,cAAc,EAAE,IAAI,EAAE,OAAO,GAAG,MAAM,CAuB7F"}