@withwiz/toolkit 0.1.0

package/dist/chunk-4DPSCTX4.js

@@ -0,0 +1,212 @@
+import {
+  runCommand,
+  runMacCommand
+} from "./chunk-KWTBD4CM.js";
+import {
+  logger
+} from "./chunk-EZR55KV2.js";
+
+// src/system/disk.ts
+async function getDiskInfo() {
+  try {
+    const platform = process.platform;
+    if (platform === "darwin") {
+      return await getMacDiskInfo();
+    } else {
+      return await getLinuxDiskInfo();
+    }
+  } catch (error) {
+    logger.error("Disk info fetch error:", error);
+    throw error;
+  }
+}
+function normalizeToGB(sizeStr) {
+  const match = sizeStr.match(/^([\d.]+)\s*([KMGTP])?i?[Bb]?$/i);
+  if (!match) return sizeStr;
+  const value = parseFloat(match[1]);
+  const unit = (match[2] || "").toUpperCase();
+  let gbValue;
+  switch (unit) {
+    case "K":
+      gbValue = value / (1024 * 1024);
+      break;
+    case "M":
+      gbValue = value / 1024;
+      break;
+    case "G":
+      gbValue = value;
+      break;
+    case "T":
+      gbValue = value * 1024;
+      break;
+    case "P":
+      gbValue = value * 1024 * 1024;
+      break;
+    default:
+      gbValue = value / (1024 * 1024 * 1024);
+  }
+  if (gbValue >= 1e3) {
+    return `${(gbValue / 1024).toFixed(1)} TB`;
+  }
+  return `${gbValue.toFixed(1)} GB`;
+}
+async function getMacDiskInfo() {
+  try {
+    try {
+      const apfsOutput = await runMacCommand("diskutil apfs list 2>/dev/null");
+      const capacityCeilingMatch = apfsOutput.match(/Size \(Capacity Ceiling\):\s+([\d.]+)\s+B\s+\(([\d.]+)\s+GB\)/);
+      const capacityInUseMatch = apfsOutput.match(/Capacity In Use By Volumes:\s+([\d.]+)\s+B\s+\(([\d.]+)\s+GB\)\s+\(([\d.]+)% used\)/);
+      const capacityFreeMatch = apfsOutput.match(/Capacity Not Allocated:\s+([\d.]+)\s+B\s+\(([\d.]+)\s+GB\)/);
+      if (capacityCeilingMatch && capacityInUseMatch && capacityFreeMatch) {
+        const totalGB = parseFloat(capacityCeilingMatch[2]);
+        const usedGB = parseFloat(capacityInUseMatch[2]);
+        const availableGB = parseFloat(capacityFreeMatch[2]);
+        const percent = parseFloat(capacityInUseMatch[3]);
+        return {
+          total: `${totalGB.toFixed(1)} GB`,
+          used: `${usedGB.toFixed(1)} GB`,
+          available: `${availableGB.toFixed(1)} GB`,
+          percent: Math.round(percent)
+        };
+      }
+    } catch (apfsError) {
+      logger.debug("diskutil apfs list failed:", apfsError);
+    }
+    try {
+      const dfOutput = await runMacCommand("df -h /System/Volumes/Data 2>/dev/null || df -h /");
+      const lines = dfOutput.split("\n");
+      for (const line of lines) {
+        if (line.includes("/dev/")) {
+          const parts = line.split(/\s+/);
+          if (parts.length >= 5) {
+            const total = normalizeToGB(parts[1]);
+            const used = normalizeToGB(parts[2]);
+            const available = normalizeToGB(parts[3]);
+            const percentStr = parts[4].replace("%", "");
+            const percent = parseInt(percentStr) || 0;
+            return { total, used, available, percent };
+          }
+        }
+      }
+    } catch (dfError) {
+      logger.debug("df fallback failed:", dfError);
+    }
+    try {
+      const diskutilOutput = await runMacCommand("diskutil info / | grep -E 'Total Size|Container Total Space'");
+      const totalMatch = diskutilOutput.match(/(\d+(?:\.\d+)?)\s+(B|KB|MB|GB|TB)/);
+      if (totalMatch) {
+        const size = parseFloat(totalMatch[1]);
+        const unit = totalMatch[2];
+        let totalGB = size;
+        switch (unit) {
+          case "B":
+            totalGB = size / (1024 * 1024 * 1024);
+            break;
+          case "KB":
+            totalGB = size / (1024 * 1024);
+            break;
+          case "MB":
+            totalGB = size / 1024;
+            break;
+          case "GB":
+            totalGB = size;
+            break;
+          case "TB":
+            totalGB = size * 1024;
+            break;
+        }
+        const percent = 70;
+        const usedGB = Math.round(totalGB * (percent / 100));
+        const availableGB = Math.round(totalGB - usedGB);
+        return {
+          total: `${Math.round(totalGB)} GB`,
+          used: `${usedGB} GB`,
+          available: `${availableGB} GB`,
+          percent
+        };
+      }
+    } catch (diskutilError) {
+      logger.debug("diskutil info fallback failed:", diskutilError);
+    }
+    throw new Error("Disk info parsing failed");
+  } catch (error) {
+    logger.debug("macOS disk info fetch failed:", error);
+    throw error;
+  }
+}
+async function getLinuxDiskInfo() {
+  try {
+    const dfOutput = await runCommand("df -h /");
+    const lines = dfOutput.split("\n");
+    for (const line of lines) {
+      if (line.includes("/dev/")) {
+        const parts = line.split(/\s+/);
+        if (parts.length >= 5) {
+          const total = normalizeToGB(parts[1]);
+          const used = normalizeToGB(parts[2]);
+          const available = normalizeToGB(parts[3]);
+          const percentStr = parts[4].replace("%", "");
+          const percent = parseInt(percentStr) || 0;
+          return { total, used, available, percent };
+        }
+      }
+    }
+    try {
+      const mountOutput = await runCommand("cat /proc/mounts | grep ' / '");
+      const mountParts = mountOutput.trim().split(/\s+/);
+      if (mountParts.length >= 2) {
+        const device = mountParts[0];
+        const deviceName = device.split("/").pop();
+        if (deviceName) {
+          const diskstatsOutput = await runCommand(`cat /proc/diskstats | grep '${deviceName}'`);
+          const diskParts = diskstatsOutput.trim().split(/\s+/);
+          if (diskParts.length >= 14) {
+            const totalBlocks = parseInt(diskParts[2]) || 0;
+            const totalBytes = totalBlocks * 512;
+            const percent = 60;
+            const totalGB = Math.round(totalBytes / (1024 * 1024 * 1024));
+            const usedGB = Math.round(totalGB * (percent / 100));
+            const availableGB = Math.round(totalGB - usedGB);
+            return {
+              total: `${totalGB} GB`,
+              used: `${usedGB} GB`,
+              available: `${availableGB} GB`,
+              percent
+            };
+          }
+        }
+      }
+    } catch (procError) {
+      logger.debug("/proc fallback failed:", procError);
+    }
+    throw new Error("Disk info parsing failed");
+  } catch (error) {
+    logger.debug("Linux disk info fetch failed:", error);
+    try {
+      const lsblkOutput = await runCommand("lsblk -b -o SIZE,MOUNTPOINT 2>/dev/null | grep -E '\\s+/$' | head -1");
+      const parts = lsblkOutput.trim().split(/\s+/);
+      if (parts.length >= 1) {
+        const sizeBytes = parseInt(parts[0]) || 0;
+        const totalGB = Math.round(sizeBytes / (1024 * 1024 * 1024));
+        if (totalGB > 0) {
+          const percent = 60;
+          const usedGB = Math.round(totalGB * (percent / 100));
+          const availableGB = Math.round(totalGB - usedGB);
+          return {
+            total: `${totalGB} GB`,
+            used: `${usedGB} GB`,
+            available: `${availableGB} GB`,
+            percent
+          };
+        }
+      }
+    } catch (lsblkError) {
+      logger.debug("lsblk fallback failed:", lsblkError);
+    }
+    throw new Error("All disk info retrieval methods failed.");
+  }
+}
+
+export {
+  getDiskInfo
+};

package/dist/chunk-4KJXENRM.js

@@ -0,0 +1,64 @@
+import {
+  cache,
+  geoCache
+} from "./chunk-AIHQBQ3E.js";
+
+// src/cache/cache-invalidation.ts
+var invalidateCache = {
+  /**
+   * 기본 캐시에서 단일 키 삭제
+   * @param key - 삭제할 캐시 키
+   */
+  byKey: async (key) => {
+    await cache.delete(key);
+  },
+  /**
+   * 기본 캐시에서 패턴으로 삭제
+   * @param pattern - 삭제할 캐시 키 패턴 (예: "user:*")
+   */
+  byPattern: async (pattern) => {
+    await cache.deletePattern(pattern);
+  },
+  /**
+   * GeoIP 캐시에서 단일 키 삭제
+   * @param key - 삭제할 캐시 키
+   */
+  geoByKey: async (key) => {
+    await geoCache.delete(key);
+  },
+  /**
+   * GeoIP 캐시에서 패턴으로 삭제
+   * @param pattern - 삭제할 캐시 키 패턴
+   */
+  geoByPattern: async (pattern) => {
+    await geoCache.deletePattern(pattern);
+  },
+  /**
+   * 기본 캐시 전체 삭제
+   */
+  all: async () => {
+    await cache.deletePattern("*");
+  },
+  /**
+   * GeoIP 캐시 전체 삭제
+   */
+  allGeo: async () => {
+    await geoCache.deletePattern("*");
+  }
+};
+async function deleteFromCache(cacheManager, key) {
+  await cacheManager.delete(key);
+}
+async function deletePatternFromCache(cacheManager, pattern) {
+  await cacheManager.deletePattern(pattern);
+}
+async function deletePatternFromMultipleCaches(cacheManagers, pattern) {
+  await Promise.all(cacheManagers.map((cm) => cm.deletePattern(pattern)));
+}
+
+export {
+  invalidateCache,
+  deleteFromCache,
+  deletePatternFromCache,
+  deletePatternFromMultipleCaches
+};

package/dist/chunk-4NWJ3WCZ.js

@@ -0,0 +1,28 @@
+import {
+  BaseGeoIPProvider
+} from "./chunk-AHDPGRXS.js";
+
+// src/geolocation/providers/maxmind-provider.ts
+var MaxMindProvider = class extends BaseGeoIPProvider {
+  constructor() {
+    super(...arguments);
+    this.name = "maxmind";
+    this.rateLimit = 5e4;
+    // 분당 50000회 요청 제한 (엔터프라이즈 플랜 기준)
+    this.timeout = 2e3;
+  }
+  // 2초 타임아웃
+  url(ip) {
+    return "";
+  }
+  parseResponse(data) {
+    return null;
+  }
+  isAvailable() {
+    return !!process.env.MAXMIND_LICENSE_KEY;
+  }
+};
+
+export {
+  MaxMindProvider
+};

package/dist/chunk-4ODT3Q4A.js

@@ -0,0 +1,86 @@
+import {
+  logger
+} from "./chunk-EZR55KV2.js";
+import {
+  __spreadValues
+} from "./chunk-ORMEWXMH.js";
+
+// src/middleware/middleware-chain.ts
+var MiddlewareChain = class {
+  constructor(options = {}) {
+    this.middlewares = [];
+    this.options = __spreadValues({
+      continueOnError: false,
+      timeout: 3e4
+    }, options);
+  }
+  /**
+   * 미들웨어 추가
+   */
+  use(middleware) {
+    this.middlewares.push(middleware);
+    return this;
+  }
+  /**
+   * 체인 실행
+   *
+   * @param context - API 컨텍스트
+   * @param handler - 최종 핸들러 함수
+   * @param props - Next.js 동적 라우트 파라미터 (params 등)
+   */
+  async execute(context, handler, props) {
+    let index = 0;
+    const next = async () => {
+      if (index >= this.middlewares.length) {
+        return await handler(context, props);
+      }
+      const middleware = this.middlewares[index++];
+      try {
+        if (this.options.timeout) {
+          return await this.withTimeout(
+            middleware(context, next),
+            this.options.timeout
+          );
+        }
+        return await middleware(context, next);
+      } catch (error) {
+        if (this.options.continueOnError) {
+          logger.error("[MiddlewareChain] Error in middleware:", error);
+          return await next();
+        }
+        throw error;
+      }
+    };
+    return await next();
+  }
+  /**
+   * 타임아웃 처리
+   */
+  async withTimeout(promise, timeoutMs) {
+    return Promise.race([
+      promise,
+      new Promise(
+        (_, reject) => setTimeout(
+          () => reject(new Error(`Timeout after ${timeoutMs}ms`)),
+          timeoutMs
+        )
+      )
+    ]);
+  }
+  /**
+   * 미들웨어 개수 반환
+   */
+  get length() {
+    return this.middlewares.length;
+  }
+  /**
+   * 체인 초기화
+   */
+  clear() {
+    this.middlewares = [];
+  }
+};
+
+export {
+  MiddlewareChain
+};

package/dist/chunk-5ATB5D6S.js

@@ -0,0 +1,40 @@
+// src/utils/short-code-generator.ts
+function generateShortCode(length = 8) {
+  if (!Number.isInteger(length) || length <= 0) {
+    throw new Error("length must be a positive integer");
+  }
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return result;
+}
+async function generateUniqueShortCode(options = {}) {
+  const {
+    length = 8,
+    maxAttempts = 100,
+    checkDuplicate
+  } = options;
+  let shortCode;
+  let attempts = 0;
+  do {
+    shortCode = generateShortCode(length);
+    attempts++;
+    if (checkDuplicate) {
+      const isDuplicate = await checkDuplicate(shortCode);
+      if (!isDuplicate) break;
+    } else {
+      break;
+    }
+    if (attempts >= maxAttempts) {
+      throw new Error("Failed to generate unique shortCode after multiple attempts");
+    }
+  } while (true);
+  return shortCode;
+}
+
+export {
+  generateShortCode,
+  generateUniqueShortCode
+};

package/dist/chunk-62FLBG6B.js

@@ -0,0 +1,34 @@
+// src/utils/client/client-utils.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+async function copyToClipboard(text) {
+  try {
+    if (navigator.clipboard && window.isSecureContext) {
+      await navigator.clipboard.writeText(text);
+      return true;
+    } else {
+      const textArea = document.createElement("textarea");
+      textArea.value = text;
+      textArea.style.position = "fixed";
+      textArea.style.left = "-999999px";
+      textArea.style.top = "-999999px";
+      document.body.appendChild(textArea);
+      textArea.focus();
+      textArea.select();
+      const result = document.execCommand("copy");
+      textArea.remove();
+      return result;
+    }
+  } catch (error) {
+    console.error("Failed to copy to clipboard:", error);
+    return false;
+  }
+}
+
+export {
+  cn,
+  copyToClipboard
+};

package/dist/chunk-62Q7DN5G.js

@@ -0,0 +1,25 @@
+import {
+  LocaleDetector
+} from "./chunk-XHZ5L4FO.js";
+
+// src/middleware/init-request.ts
+import { randomUUID } from "crypto";
+var initRequestMiddleware = async (context, next) => {
+  if (!context.requestId) {
+    context.requestId = randomUUID();
+  }
+  if (!context.locale) {
+    context.locale = LocaleDetector.detectServer(context.request);
+  }
+  if (!context.startTime) {
+    context.startTime = Date.now();
+  }
+  if (!context.metadata) {
+    context.metadata = {};
+  }
+  return await next();
+};
+
+export {
+  initRequestMiddleware
+};