@withwiz/toolkit 0.1.0

package/dist/chunk-YJ3TLEW3.js

@@ -0,0 +1,100 @@
+import {
+  BaseTransport
+} from "./chunk-HGC4CCKB.js";
+
+// src/error/logging/transports/file.ts
+var FileTransport = class extends BaseTransport {
+  constructor(options = {}) {
+    const isServer = typeof window === "undefined";
+    super("file", isServer && options.enabled !== false);
+    this.fs = null;
+    this.path = null;
+    this.filePath = options.filePath || "./logs/error.log";
+    this.maxSize = options.maxSize || 10 * 1024 * 1024;
+    this.maxFiles = options.maxFiles || 5;
+    if (isServer) {
+      this.loadModules();
+    }
+  }
+  /**
+   * 모듈 로드 (동적 import)
+   */
+  async loadModules() {
+    try {
+      this.fs = await import("fs");
+      this.path = await import("path");
+    } catch (error) {
+      console.error("[FileTransport] Failed to load fs/path modules:", error);
+      this.disable();
+    }
+  }
+  async log(entry) {
+    if (!this.fs || !this.path) {
+      return;
+    }
+    try {
+      const dir = this.path.dirname(this.filePath);
+      if (!this.fs.existsSync(dir)) {
+        this.fs.mkdirSync(dir, { recursive: true });
+      }
+      const logLine = this.format(entry);
+      await this.rotateIfNeeded();
+      this.fs.appendFileSync(this.filePath, logLine + "\n", "utf8");
+    } catch (error) {
+      console.error("[FileTransport] Failed to write log:", error);
+    }
+  }
+  /**
+   * 로그 포맷팅 (JSON Lines)
+   */
+  format(entry) {
+    const logObject = {
+      timestamp: entry.timestamp.toISOString(),
+      level: entry.level,
+      message: entry.message,
+      context: entry.context,
+      error: entry.error ? {
+        message: entry.error.message,
+        stack: entry.error.stack
+      } : void 0
+    };
+    return JSON.stringify(logObject);
+  }
+  /**
+   * 파일 rotation
+   */
+  async rotateIfNeeded() {
+    if (!this.fs || !this.path) {
+      return;
+    }
+    try {
+      if (!this.fs.existsSync(this.filePath)) {
+        return;
+      }
+      const stats = this.fs.statSync(this.filePath);
+      if (stats.size < this.maxSize) {
+        return;
+      }
+      const ext = this.path.extname(this.filePath);
+      const base = this.filePath.slice(0, -ext.length);
+      for (let i = this.maxFiles - 1; i >= 1; i--) {
+        const oldPath = `${base}.${i}${ext}`;
+        const newPath = `${base}.${i + 1}${ext}`;
+        if (this.fs.existsSync(oldPath)) {
+          if (i === this.maxFiles - 1) {
+            this.fs.unlinkSync(oldPath);
+          } else {
+            this.fs.renameSync(oldPath, newPath);
+          }
+        }
+      }
+      this.fs.renameSync(this.filePath, `${base}.1${ext}`);
+    } catch (error) {
+      console.error("[FileTransport] Failed to rotate log file:", error);
+    }
+  }
+};
+
+export {
+  FileTransport
+};

package/dist/chunk-YJWLWUFK.js

@@ -0,0 +1,105 @@
+import {
+  cn
+} from "./chunk-62FLBG6B.js";
+
+// src/components/ui/Pagination.tsx
+import { ChevronLeft, ChevronRight, MoreHorizontal } from "lucide-react";
+import { jsx, jsxs } from "react/jsx-runtime";
+function Pagination({ children, className }) {
+  return /* @__PURE__ */ jsx(
+    "nav",
+    {
+      className: cn("mx-auto flex w-full justify-center", className),
+      role: "navigation",
+      "aria-label": "pagination",
+      children
+    }
+  );
+}
+function PaginationContent({ children, className }) {
+  return /* @__PURE__ */ jsx("ul", { className: cn("flex flex-row items-center gap-1", className), children });
+}
+function PaginationItem({ children, className }) {
+  return /* @__PURE__ */ jsx("li", { className: cn("", className), children });
+}
+function PaginationLink({
+  children,
+  href,
+  onClick,
+  isActive = false,
+  className
+}) {
+  return /* @__PURE__ */ jsx(
+    "a",
+    {
+      href,
+      onClick,
+      className: cn(
+        "inline-flex items-center justify-center whitespace-nowrap rounded-md text-sm font-medium ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50",
+        isActive ? "h-10 px-4 bg-primary text-primary-foreground" : "h-10 px-4 hover:bg-accent hover:text-accent-foreground",
+        className
+      ),
+      children
+    }
+  );
+}
+function PaginationPrevious({
+  href,
+  onClick,
+  className,
+  children
+}) {
+  return /* @__PURE__ */ jsxs(
+    "a",
+    {
+      href,
+      onClick,
+      className: cn(
+        "inline-flex items-center justify-center whitespace-nowrap rounded-md text-sm font-medium ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 h-10 px-4 hover:bg-accent hover:text-accent-foreground",
+        className
+      ),
+      children: [
+        /* @__PURE__ */ jsx(ChevronLeft, { className: "h-4 w-4" }),
+        /* @__PURE__ */ jsx("span", { className: "ml-2", children: children || "Previous" })
+      ]
+    }
+  );
+}
+function PaginationNext({
+  href,
+  onClick,
+  className,
+  children
+}) {
+  return /* @__PURE__ */ jsxs(
+    "a",
+    {
+      href,
+      onClick,
+      className: cn(
+        "inline-flex items-center justify-center whitespace-nowrap rounded-md text-sm font-medium ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 h-10 px-4 hover:bg-accent hover:text-accent-foreground",
+        className
+      ),
+      children: [
+        /* @__PURE__ */ jsx("span", { className: "mr-2", children: children || "Next" }),
+        /* @__PURE__ */ jsx(ChevronRight, { className: "h-4 w-4" })
+      ]
+    }
+  );
+}
+function PaginationEllipsis({ className }) {
+  return /* @__PURE__ */ jsxs("span", { className: cn("flex h-10 w-10 items-center justify-center", className), children: [
+    /* @__PURE__ */ jsx(MoreHorizontal, { className: "h-4 w-4" }),
+    /* @__PURE__ */ jsx("span", { className: "sr-only", children: "More pages" })
+  ] });
+}
+
+export {
+  Pagination,
+  PaginationContent,
+  PaginationItem,
+  PaginationLink,
+  PaginationPrevious,
+  PaginationNext,
+  PaginationEllipsis
+};

package/dist/chunk-Z4D4CMDA.js

@@ -0,0 +1,488 @@
+import {
+  DEFAULT_INMEMORY_CONFIG
+} from "./chunk-SS56XFLI.js";
+import {
+  logger
+} from "./chunk-EZR55KV2.js";
+import {
+  __spreadProps,
+  __spreadValues
+} from "./chunk-ORMEWXMH.js";
+
+// src/cache/inmemory-cache-manager.ts
+var InMemoryCacheManager = class _InMemoryCacheManager {
+  constructor(prefix, config) {
+    this.accessOrder = [];
+    this.currentMemoryBytes = 0;
+    this.cleanupTimer = null;
+    this.prefix = prefix;
+    this.cache = /* @__PURE__ */ new Map();
+    this.config = __spreadValues(__spreadValues({}, DEFAULT_INMEMORY_CONFIG), config);
+    this.metrics = {
+      hits: 0,
+      misses: 0,
+      evictions: 0,
+      expirations: 0,
+      totalRequests: 0,
+      hitRate: 0
+    };
+    this.startCleanupTimer();
+    logger.debug("[InMemoryCache] Initialized", {
+      prefix,
+      maxSize: this.config.maxSize,
+      maxMemoryMB: this.config.maxMemoryMB,
+      evictionPolicy: this.config.evictionPolicy
+    });
+  }
+  // ============================================================================
+  // Public Methods (CacheManager 인터페이스와 동일)
+  // ============================================================================
+  /**
+   * 캐시에서 값 조회
+   */
+  async get(key) {
+    const fullKey = this.getFullKey(key);
+    this.metrics.totalRequests++;
+    const entry = this.cache.get(fullKey);
+    if (!entry) {
+      this.metrics.misses++;
+      this.updateHitRate();
+      logger.debug(`[Cache:M] miss: ${fullKey}`);
+      return null;
+    }
+    if (this.isExpired(entry)) {
+      this.deleteEntry(fullKey);
+      this.metrics.misses++;
+      this.metrics.expirations++;
+      this.updateHitRate();
+      logger.debug(`[Cache:M] miss (expired): ${fullKey}`);
+      return null;
+    }
+    entry.accessedAt = Date.now();
+    this.updateAccessOrder(fullKey);
+    this.metrics.hits++;
+    this.updateHitRate();
+    logger.debug(`[Cache:M] hit: ${fullKey}`, {
+      key: fullKey,
+      prefix: this.prefix
+    });
+    return entry.value;
+  }
+  /**
+   * 캐시에 값 저장
+   */
+  async set(key, value, ttl) {
+    const fullKey = this.getFullKey(key);
+    const actualTTL = ttl != null ? ttl : this.config.defaultTTL;
+    const size = this.estimateSize(value);
+    while (this.needsEviction(size)) {
+      this.evict();
+    }
+    const existingEntry = this.cache.get(fullKey);
+    if (existingEntry) {
+      this.currentMemoryBytes -= existingEntry.size;
+      this.removeFromAccessOrder(fullKey);
+    }
+    const now = Date.now();
+    const entry = {
+      value,
+      expiresAt: now + actualTTL * 1e3,
+      size,
+      accessedAt: now,
+      createdAt: now
+    };
+    this.cache.set(fullKey, entry);
+    this.accessOrder.push(fullKey);
+    this.currentMemoryBytes += size;
+  }
+  /**
+   * 캐시에서 항목 삭제
+   */
+  async delete(key) {
+    const fullKey = this.getFullKey(key);
+    this.deleteEntry(fullKey);
+    logger.debug("[InMemoryCache] Cache deleted", {
+      key: fullKey,
+      prefix: this.prefix
+    });
+  }
+  /**
+   * 패턴 매칭으로 캐시 삭제
+   * 간단한 glob 패턴 지원 (* 와일드카드)
+   */
+  async deletePattern(pattern) {
+    const fullPattern = this.getFullKey(pattern);
+    const regex = this.patternToRegex(fullPattern);
+    const keysToDelete = [];
+    for (const key of this.cache.keys()) {
+      if (regex.test(key)) {
+        keysToDelete.push(key);
+      }
+    }
+    for (const key of keysToDelete) {
+      this.deleteEntry(key);
+    }
+    logger.debug("[InMemoryCache] Pattern deleted", {
+      pattern: fullPattern,
+      deletedCount: keysToDelete.length,
+      prefix: this.prefix
+    });
+  }
+  /**
+   * 키 존재 여부 확인
+   */
+  async exists(key) {
+    const fullKey = this.getFullKey(key);
+    const entry = this.cache.get(fullKey);
+    if (!entry) {
+      return false;
+    }
+    if (this.isExpired(entry)) {
+      this.deleteEntry(fullKey);
+      return false;
+    }
+    return true;
+  }
+  /**
+   * 값 증가 (카운터용)
+   */
+  async increment(key, value = 1) {
+    const fullKey = this.getFullKey(key);
+    const entry = this.cache.get(fullKey);
+    let currentValue = 0;
+    if (entry && !this.isExpired(entry)) {
+      currentValue = typeof entry.value === "number" ? entry.value : 0;
+    }
+    const newValue = currentValue + value;
+    await this.set(key, newValue);
+    return newValue;
+  }
+  /**
+   * TTL 설정/갱신
+   */
+  async expire(key, ttl) {
+    const fullKey = this.getFullKey(key);
+    const entry = this.cache.get(fullKey);
+    if (entry) {
+      entry.expiresAt = Date.now() + ttl * 1e3;
+    }
+  }
+  /**
+   * 전체 캐시 초기화
+   */
+  clear() {
+    this.cache.clear();
+    this.accessOrder = [];
+    this.currentMemoryBytes = 0;
+    logger.info("[InMemoryCache] Cache cleared", { prefix: this.prefix });
+  }
+  /**
+   * 리소스 정리 (서버 종료 시 호출)
+   */
+  destroy() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+    this.clear();
+    logger.info("[InMemoryCache] Instance destroyed", { prefix: this.prefix });
+  }
+  // ============================================================================
+  // Metrics & Stats
+  // ============================================================================
+  /**
+   * 캐시 메트릭 조회
+   */
+  getMetrics() {
+    return __spreadValues({}, this.metrics);
+  }
+  /**
+   * 캐시 통계 조회
+   */
+  getStats() {
+    const memoryUsageMB = this.currentMemoryBytes / (1024 * 1024);
+    const maxMemoryBytes = this.config.maxMemoryMB * 1024 * 1024;
+    return {
+      itemCount: this.cache.size,
+      memoryUsageMB: Math.round(memoryUsageMB * 100) / 100,
+      maxSize: this.config.maxSize,
+      maxMemoryMB: this.config.maxMemoryMB,
+      utilizationPercent: Math.round(this.cache.size / this.config.maxSize * 100),
+      memoryUtilizationPercent: Math.round(this.currentMemoryBytes / maxMemoryBytes * 100)
+    };
+  }
+  /**
+   * 연결 상태 조회 (인메모리는 항상 연결됨)
+   */
+  getConnectionStatus() {
+    return {
+      isConnected: true,
+      type: "memory",
+      prefix: this.prefix
+    };
+  }
+  /**
+   * 연결 체크 (인메모리는 항상 true)
+   */
+  async checkConnection() {
+    return true;
+  }
+  /**
+   * 설정 조회
+   */
+  getConfig() {
+    return __spreadProps(__spreadValues({}, this.config), {
+      prefix: this.prefix
+    });
+  }
+  // ============================================================================
+  // Private Methods
+  // ============================================================================
+  /**
+   * 전체 키 생성 (prefix 포함)
+   */
+  getFullKey(key) {
+    return `${this.prefix}:${key}`;
+  }
+  /**
+   * 항목 만료 여부 확인
+   */
+  isExpired(entry) {
+    return Date.now() > entry.expiresAt;
+  }
+  /**
+   * 항목 삭제 (내부용)
+   */
+  deleteEntry(fullKey) {
+    const entry = this.cache.get(fullKey);
+    if (entry) {
+      this.currentMemoryBytes -= entry.size;
+      this.cache.delete(fullKey);
+      this.removeFromAccessOrder(fullKey);
+    }
+  }
+  /**
+   * 메모리 크기 추정
+   * JSON 직렬화 크기 * 2 (UTF-16) + 객체 오버헤드
+   */
+  estimateSize(value) {
+    try {
+      const jsonSize = JSON.stringify(value).length;
+      return jsonSize * 2 + 100;
+    } catch (e) {
+      return 200;
+    }
+  }
+  /**
+   * eviction 필요 여부 확인
+   */
+  needsEviction(newItemSize) {
+    const maxMemoryBytes = this.config.maxMemoryMB * 1024 * 1024;
+    return this.cache.size >= this.config.maxSize || this.currentMemoryBytes + newItemSize > maxMemoryBytes;
+  }
+  /**
+   * 교체 정책에 따른 항목 제거
+   */
+  evict() {
+    if (this.cache.size === 0) {
+      return;
+    }
+    for (const [key, entry] of this.cache) {
+      if (this.isExpired(entry)) {
+        this.deleteEntry(key);
+        this.metrics.evictions++;
+        this.metrics.expirations++;
+        return;
+      }
+    }
+    switch (this.config.evictionPolicy) {
+      case "lru":
+        this.evictLRU();
+        break;
+      case "fifo":
+        this.evictFIFO();
+        break;
+      case "ttl":
+        this.evictTTL();
+        break;
+      default:
+        this.evictLRU();
+    }
+    this.metrics.evictions++;
+  }
+  /**
+   * LRU 교체: 가장 오래 접근되지 않은 항목 제거
+   */
+  evictLRU() {
+    const lruKey = this.accessOrder.shift();
+    if (lruKey) {
+      this.deleteEntry(lruKey);
+      logger.debug("[InMemoryCache] LRU eviction", {
+        evictedKey: lruKey,
+        prefix: this.prefix
+      });
+    }
+  }
+  /**
+   * FIFO 교체: 가장 먼저 들어온 항목 제거
+   */
+  evictFIFO() {
+    let oldestKey = null;
+    let oldestTime = Infinity;
+    for (const [key, entry] of this.cache) {
+      if (entry.createdAt < oldestTime) {
+        oldestTime = entry.createdAt;
+        oldestKey = key;
+      }
+    }
+    if (oldestKey) {
+      this.deleteEntry(oldestKey);
+      logger.debug("[InMemoryCache] FIFO eviction", {
+        evictedKey: oldestKey,
+        prefix: this.prefix
+      });
+    }
+  }
+  /**
+   * TTL 교체: 가장 빨리 만료될 항목 제거
+   */
+  evictTTL() {
+    let nearestExpiryKey = null;
+    let nearestExpiryTime = Infinity;
+    for (const [key, entry] of this.cache) {
+      if (entry.expiresAt < nearestExpiryTime) {
+        nearestExpiryTime = entry.expiresAt;
+        nearestExpiryKey = key;
+      }
+    }
+    if (nearestExpiryKey) {
+      this.deleteEntry(nearestExpiryKey);
+      logger.debug("[InMemoryCache] TTL eviction", {
+        evictedKey: nearestExpiryKey,
+        prefix: this.prefix
+      });
+    }
+  }
+  /**
+   * 접근 순서 업데이트 (LRU용)
+   */
+  updateAccessOrder(key) {
+    const index = this.accessOrder.indexOf(key);
+    if (index !== -1) {
+      this.accessOrder.splice(index, 1);
+    }
+    this.accessOrder.push(key);
+  }
+  /**
+   * 접근 순서에서 제거
+   */
+  removeFromAccessOrder(key) {
+    const index = this.accessOrder.indexOf(key);
+    if (index !== -1) {
+      this.accessOrder.splice(index, 1);
+    }
+  }
+  /**
+   * 히트율 업데이트
+   */
+  updateHitRate() {
+    if (this.metrics.totalRequests > 0) {
+      this.metrics.hitRate = Math.round(this.metrics.hits / this.metrics.totalRequests * 1e4) / 100;
+    }
+  }
+  /**
+   * glob 패턴을 정규식으로 변환
+   */
+  patternToRegex(pattern) {
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+    return new RegExp(`^${escaped}$`);
+  }
+  /**
+   * 만료 항목 정리 타이머 시작
+   */
+  startCleanupTimer() {
+    if (this.cleanupTimer) {
+      return;
+    }
+    this.cleanupTimer = setInterval(() => {
+      this.cleanupExpired();
+    }, this.config.cleanupInterval);
+    if (this.cleanupTimer.unref) {
+      this.cleanupTimer.unref();
+    }
+  }
+  /**
+   * 만료된 항목 일괄 정리
+   */
+  cleanupExpired() {
+    const now = Date.now();
+    let cleanedCount = 0;
+    for (const [key, entry] of this.cache) {
+      if (now > entry.expiresAt) {
+        this.deleteEntry(key);
+        this.metrics.expirations++;
+        cleanedCount++;
+      }
+    }
+    if (cleanedCount > 0) {
+      logger.debug("[InMemoryCache] Expired items cleaned", {
+        cleanedCount,
+        remainingCount: this.cache.size,
+        prefix: this.prefix
+      });
+    }
+  }
+  // ============================================================================
+  // Static Factory (globalThis 사용으로 프로세스 레벨 싱글톤 보장)
+  // ============================================================================
+  /**
+   * 전역 인스턴스 맵 가져오기 (HMR 안전)
+   */
+  static getGlobalInstances() {
+    if (!globalThis.__inMemoryCacheManagerInstances) {
+      globalThis.__inMemoryCacheManagerInstances = /* @__PURE__ */ new Map();
+    }
+    return globalThis.__inMemoryCacheManagerInstances;
+  }
+  /**
+   * 싱글톤 인스턴스 가져오기
+   */
+  static getInstance(prefix, config) {
+    const instances = _InMemoryCacheManager.getGlobalInstances();
+    if (!instances.has(prefix)) {
+      instances.set(prefix, new _InMemoryCacheManager(prefix, config));
+    }
+    return instances.get(prefix);
+  }
+  /**
+   * 모든 인스턴스 종료
+   */
+  static destroyAll() {
+    const instances = _InMemoryCacheManager.getGlobalInstances();
+    for (const instance of instances.values()) {
+      instance.destroy();
+    }
+    instances.clear();
+  }
+  /**
+   * 인스턴스 초기화 (테스트용)
+   */
+  static clearInstances() {
+    _InMemoryCacheManager.getGlobalInstances().clear();
+  }
+  /**
+   * 모든 인스턴스의 통계 조회
+   */
+  static getAllStats() {
+    const stats = {};
+    const instances = _InMemoryCacheManager.getGlobalInstances();
+    for (const [prefix, instance] of instances) {
+      stats[prefix] = instance.getStats();
+    }
+    return stats;
+  }
+};
+
+export {
+  InMemoryCacheManager
+};