@withwiz/toolkit 0.2.1 → 0.2.3

package/dist/utils/url-normalizer.js

@@ -1,14 +1,198 @@
-import {
-  SUPPORTED_SCHEMES,
-  extractScheme,
-  getUrlType,
-  hasValidScheme,
-  isAppScheme,
-  isWebUrl,
-  normalizeUrl,
-  validateUrl
-} from "../chunk-VWODEQ5C.js";
 import "../chunk-ORMEWXMH.js";
+
+// src/utils/url-normalizer.ts
+var SUPPORTED_SCHEMES = [
+  "http:",
+  "https:",
+  "mailto:",
+  "tel:",
+  "sms:",
+  "ftp:",
+  "ftps:",
+  // 'file:' - 보안상 제거 (로컬 파일 접근 방지)
+  // 'data:' - XSS 공격 벡터로 제거 (CVSS 7.5)
+  // Mobile app schemes
+  "intent:",
+  "market:",
+  "itms:",
+  "itms-apps:",
+  // Social media apps
+  "fb:",
+  "instagram:",
+  "twitter:",
+  "youtube:",
+  "linkedin:",
+  "tiktok:",
+  // Messaging apps
+  "whatsapp:",
+  "telegram:",
+  "line:",
+  "kakaotalk:",
+  "viber:",
+  "wechat:",
+  "slack:",
+  "discord:",
+  // Other apps
+  "spotify:",
+  "zoom:",
+  "skype:",
+  "maps:",
+  "geo:"
+];
+var CUSTOM_SCHEME_PATTERN = /^[a-zA-Z][a-zA-Z0-9+.-]*:/;
+function hasValidScheme(url) {
+  try {
+    const urlObj = new URL(url);
+    const protocol = urlObj.protocol;
+    if (SUPPORTED_SCHEMES.includes(protocol)) {
+      return true;
+    }
+    if (CUSTOM_SCHEME_PATTERN.test(url)) {
+      return true;
+    }
+    return false;
+  } catch (e) {
+    return false;
+  }
+}
+function extractScheme(url) {
+  const match = url.match(/^([a-zA-Z][a-zA-Z0-9+.-]*):\/?\/?/);
+  return match ? match[1] : null;
+}
+function normalizeUrl(url) {
+  if (!url) {
+    return "";
+  }
+  let normalized = url.trim();
+  if (!normalized) {
+    return "";
+  }
+  const scheme = extractScheme(normalized);
+  if (scheme) {
+    return normalized;
+  }
+  if (normalized.startsWith("//")) {
+    return `https:${normalized}`;
+  }
+  return `https://${normalized}`;
+}
+function validateUrl(url, options) {
+  if (!url || !url.trim()) {
+    return {
+      isValid: false,
+      message: "URL\uC744 \uC785\uB825\uD574\uC8FC\uC138\uC694",
+      messageKey: "urlRequired"
+    };
+  }
+  const normalized = (options == null ? void 0 : options.skipNormalization) ? url.trim() : normalizeUrl(url);
+  try {
+    const urlObj = new URL(normalized);
+    const protocol = urlObj.protocol;
+    const isSupported = SUPPORTED_SCHEMES.includes(protocol);
+    const isCustom = CUSTOM_SCHEME_PATTERN.test(normalized);
+    if (!isSupported && !isCustom) {
+      return {
+        isValid: false,
+        message: `\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uD504\uB85C\uD1A0\uCF5C\uC785\uB2C8\uB2E4: ${protocol}`,
+        messageKey: "unsupportedProtocol",
+        messageParams: { protocol }
+      };
+    }
+    if (protocol === "http:" || protocol === "https:") {
+      if (!urlObj.hostname || urlObj.hostname.length < 1) {
+        return {
+          isValid: false,
+          message: "\uC720\uD6A8\uD55C \uB3C4\uBA54\uC778\uC744 \uC785\uB825\uD574\uC8FC\uC138\uC694",
+          messageKey: "invalidDomain"
+        };
+      }
+      if (!urlObj.hostname.includes(".") && urlObj.hostname !== "localhost") {
+        return {
+          isValid: false,
+          message: "\uC720\uD6A8\uD55C \uB3C4\uBA54\uC778 \uD615\uC2DD\uC774 \uC544\uB2D9\uB2C8\uB2E4",
+          messageKey: "invalidDomainFormat"
+        };
+      }
+    }
+    if (protocol === "mailto:") {
+      const email = urlObj.pathname;
+      const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+      if (!emailRegex.test(email)) {
+        return {
+          isValid: false,
+          message: "\uC720\uD6A8\uD55C \uC774\uBA54\uC77C \uC8FC\uC18C\uAC00 \uC544\uB2D9\uB2C8\uB2E4",
+          messageKey: "invalidEmail"
+        };
+      }
+    }
+    if (protocol === "tel:") {
+      const phone = urlObj.pathname;
+      if (!/\d/.test(phone)) {
+        return {
+          isValid: false,
+          message: "\uC720\uD6A8\uD55C \uC804\uD654\uBC88\uD638\uAC00 \uC544\uB2D9\uB2C8\uB2E4",
+          messageKey: "invalidPhone"
+        };
+      }
+    }
+    if (normalized.length > 2048) {
+      return {
+        isValid: false,
+        message: "URL\uC774 \uB108\uBB34 \uAE41\uB2C8\uB2E4 (\uCD5C\uB300 2048\uC790)",
+        messageKey: "urlTooLong"
+      };
+    }
+    return {
+      isValid: true,
+      message: "\uC720\uD6A8\uD55C URL\uC785\uB2C8\uB2E4",
+      messageKey: "validUrl",
+      normalizedUrl: normalized
+    };
+  } catch (error) {
+    return {
+      isValid: false,
+      message: "\uC720\uD6A8\uD55C URL \uD615\uC2DD\uC774 \uC544\uB2D9\uB2C8\uB2E4",
+      messageKey: "invalidUrlFormat"
+    };
+  }
+}
+function isWebUrl(url) {
+  try {
+    const urlObj = new URL(url);
+    return urlObj.protocol === "http:" || urlObj.protocol === "https:";
+  } catch (e) {
+    return false;
+  }
+}
+function isAppScheme(url) {
+  try {
+    const urlObj = new URL(url);
+    return !["http:", "https:", "ftp:", "ftps:", "file:"].includes(urlObj.protocol);
+  } catch (e) {
+    return false;
+  }
+}
+function getUrlType(url) {
+  try {
+    const urlObj = new URL(url);
+    const protocol = urlObj.protocol;
+    if (protocol === "http:" || protocol === "https:") {
+      return "web";
+    }
+    if (protocol === "mailto:") {
+      return "email";
+    }
+    if (protocol === "tel:" || protocol === "sms:") {
+      return "tel";
+    }
+    if (isAppScheme(url)) {
+      return "app";
+    }
+    return "other";
+  } catch (e) {
+    return "other";
+  }
+}
 export {
   SUPPORTED_SCHEMES,
   extractScheme,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@withwiz/toolkit",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Shared utility library for withwiz projects",
   "license": "MIT",
   "private": false,
@@ -82,7 +82,6 @@
     "./utils/ip-utils": "./dist/utils/ip-utils.js",
     "./utils/optimistic-lock": "./dist/utils/optimistic-lock.js",
     "./utils/sanitizer": "./dist/utils/sanitizer.js",
-    "./utils/shared-utils": "./dist/utils/shared-utils.js",
     "./utils/short-code-generator": "./dist/utils/short-code-generator.js",
     "./utils/timezone": "./dist/utils/timezone.js",
     "./utils/type-guards": "./dist/utils/type-guards.js",

package/dist/chunk-5ATB5D6S.js

@@ -1,40 +0,0 @@
-// 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-6C7HQIX4.js

@@ -1,13 +0,0 @@
-// src/error/logging/types.ts
-var ELogLevel = /* @__PURE__ */ ((ELogLevel2) => {
-  ELogLevel2["DEBUG"] = "debug";
-  ELogLevel2["INFO"] = "info";
-  ELogLevel2["WARN"] = "warn";
-  ELogLevel2["ERROR"] = "error";
-  ELogLevel2["CRITICAL"] = "critical";
-  return ELogLevel2;
-})(ELogLevel || {});
-
-export {
-  ELogLevel
-};

package/dist/chunk-6UAYU5NU.js

@@ -1,102 +0,0 @@
-import {
-  AppError
-} from "./chunk-MLGO3HLS.js";
-import {
-  getErrorDisplayInfo
-} from "./chunk-POKGHK3L.js";
-import {
-  ERROR_CODES
-} from "./chunk-Y3OTJH2S.js";
-
-// src/error/hooks/useErrorHandler.ts
-import { useState, useCallback } from "react";
-function useErrorHandler(locale = "ko") {
-  const [errorState, setErrorState] = useState({
-    hasError: false
-  });
-  const handleError = useCallback(
-    (error) => {
-      console.error("[useErrorHandler] Error occurred:", error);
-      if (error instanceof AppError) {
-        const displayInfo2 = getErrorDisplayInfo(error.code, locale);
-        setErrorState({
-          hasError: true,
-          code: error.code,
-          message: error.message,
-          displayInfo: displayInfo2,
-          timestamp: Date.now()
-        });
-        return;
-      }
-      if (error && typeof error === "object" && "error" in error && typeof error.error === "object") {
-        const apiError = error.error;
-        const code = apiError.code || ERROR_CODES.INTERNAL_SERVER_ERROR.code;
-        const displayInfo2 = getErrorDisplayInfo(code, locale);
-        setErrorState({
-          hasError: true,
-          code,
-          message: apiError.message || "Unknown error",
-          displayInfo: displayInfo2,
-          timestamp: Date.now()
-        });
-        return;
-      }
-      if (error instanceof Error) {
-        const displayInfo2 = getErrorDisplayInfo(
-          ERROR_CODES.INTERNAL_SERVER_ERROR.code,
-          locale
-        );
-        setErrorState({
-          hasError: true,
-          code: ERROR_CODES.INTERNAL_SERVER_ERROR.code,
-          message: error.message,
-          displayInfo: displayInfo2,
-          timestamp: Date.now()
-        });
-        return;
-      }
-      const displayInfo = getErrorDisplayInfo(
-        ERROR_CODES.INTERNAL_SERVER_ERROR.code,
-        locale
-      );
-      setErrorState({
-        hasError: true,
-        code: ERROR_CODES.INTERNAL_SERVER_ERROR.code,
-        message: String(error),
-        displayInfo,
-        timestamp: Date.now()
-      });
-    },
-    [locale]
-  );
-  const clearError = useCallback(() => {
-    setErrorState({
-      hasError: false
-    });
-  }, []);
-  const handleAuthError = useCallback(
-    (error, redirectUrl = "/login") => {
-      handleError(error);
-      if (error instanceof AppError) {
-        const httpStatus = Math.floor(error.code / 100);
-        if (httpStatus === 401 || httpStatus === 403) {
-          setTimeout(() => {
-            window.location.href = redirectUrl;
-          }, 1e3);
-        }
-      }
-    },
-    [handleError]
-  );
-  return {
-    errorState,
-    handleError,
-    clearError,
-    handleAuthError,
-    hasError: errorState.hasError
-  };
-}
-
-export {
-  useErrorHandler
-};

package/dist/chunk-7VJNLGAS.js

@@ -1,110 +0,0 @@
-// src/error/recovery/circuit-breaker.ts
-var ECircuitState = /* @__PURE__ */ ((ECircuitState2) => {
-  ECircuitState2["CLOSED"] = "closed";
-  ECircuitState2["OPEN"] = "open";
-  ECircuitState2["HALF_OPEN"] = "half-open";
-  return ECircuitState2;
-})(ECircuitState || {});
-var CircuitBreaker = class {
-  constructor(options = {}) {
-    this.state = "closed" /* CLOSED */;
-    this.failureCount = 0;
-    this.successCount = 0;
-    this.nextAttemptTime = 0;
-    this.options = {
-      failureThreshold: options.failureThreshold || 5,
-      successThreshold: options.successThreshold || 2,
-      timeout: options.timeout || 6e4,
-      onStateChange: options.onStateChange || (() => {
-      }),
-      onError: options.onError || (() => {
-      })
-    };
-  }
-  /**
-   * 함수 실행
-   */
-  async execute(fn) {
-    if (this.state === "open" /* OPEN */) {
-      if (Date.now() < this.nextAttemptTime) {
-        throw new Error("Circuit breaker is OPEN");
-      }
-      this.setState("half-open" /* HALF_OPEN */);
-    }
-    try {
-      const result = await fn();
-      this.onSuccess();
-      return result;
-    } catch (error) {
-      this.onFailure();
-      this.options.onError(error);
-      throw error;
-    }
-  }
-  /**
-   * 성공 처리
-   */
-  onSuccess() {
-    this.failureCount = 0;
-    if (this.state === "half-open" /* HALF_OPEN */) {
-      this.successCount++;
-      if (this.successCount >= this.options.successThreshold) {
-        this.setState("closed" /* CLOSED */);
-        this.successCount = 0;
-      }
-    }
-  }
-  /**
-   * 실패 처리
-   */
-  onFailure() {
-    this.failureCount++;
-    this.successCount = 0;
-    if (this.failureCount >= this.options.failureThreshold) {
-      this.setState("open" /* OPEN */);
-      this.nextAttemptTime = Date.now() + this.options.timeout;
-    }
-  }
-  /**
-   * 상태 변경
-   */
-  setState(newState) {
-    const oldState = this.state;
-    if (oldState !== newState) {
-      this.state = newState;
-      this.options.onStateChange(oldState, newState);
-      console.log(`[CircuitBreaker] State changed: ${oldState} -> ${newState}`);
-    }
-  }
-  /**
-   * 현재 상태 조회
-   */
-  getState() {
-    return this.state;
-  }
-  /**
-   * 상태 초기화
-   */
-  reset() {
-    this.setState("closed" /* CLOSED */);
-    this.failureCount = 0;
-    this.successCount = 0;
-    this.nextAttemptTime = 0;
-  }
-  /**
-   * 메트릭 조회
-   */
-  getMetrics() {
-    return {
-      state: this.state,
-      failureCount: this.failureCount,
-      successCount: this.successCount,
-      nextAttemptTime: this.nextAttemptTime
-    };
-  }
-};
-
-export {
-  ECircuitState,
-  CircuitBreaker
-};

package/dist/chunk-A6EAAWMK.js

@@ -1,50 +0,0 @@
-// src/error/recovery/retry.ts
-function defaultShouldRetry(error) {
-  if (error instanceof Error) {
-    const message = error.message.toLowerCase();
-    return message.includes("network") || message.includes("timeout") || message.includes("econnrefused") || message.includes("enotfound") || message.includes("503") || message.includes("504");
-  }
-  return false;
-}
-async function withRetry(fn, options = {}) {
-  const {
-    maxAttempts = 3,
-    delay = 1e3,
-    exponentialBackoff = true,
-    backoffMultiplier = 2,
-    maxDelay = 3e4,
-    shouldRetry = defaultShouldRetry,
-    onRetry
-  } = options;
-  let lastError;
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    try {
-      return await fn();
-    } catch (error) {
-      lastError = error;
-      if (attempt === maxAttempts) {
-        throw error;
-      }
-      if (!shouldRetry(error, attempt)) {
-        throw error;
-      }
-      onRetry == null ? void 0 : onRetry(error, attempt);
-      let currentDelay = delay;
-      if (exponentialBackoff) {
-        currentDelay = Math.min(
-          delay * Math.pow(backoffMultiplier, attempt - 1),
-          maxDelay
-        );
-      }
-      await sleep(currentDelay);
-    }
-  }
-  throw lastError;
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-export {
-  withRetry
-};

package/dist/chunk-EQYTE7WD.js

@@ -1,139 +0,0 @@
-import {
-  BaseTransport
-} from "./chunk-HGC4CCKB.js";
-
-// src/error/logging/transports/slack.ts
-var LEVEL_COLORS = {
-  ["debug" /* DEBUG */]: "#36a64f",
-  // Green
-  ["info" /* INFO */]: "#2196F3",
-  // Blue
-  ["warn" /* WARN */]: "#FFC107",
-  // Amber
-  ["error" /* ERROR */]: "#F44336",
-  // Red
-  ["critical" /* CRITICAL */]: "#9C27B0"
-  // Purple
-};
-var SlackTransport = class extends BaseTransport {
-  constructor(options = {}) {
-    const webhookUrl = options.webhookUrl || process.env.SLACK_WEBHOOK_URL;
-    super("slack", Boolean(webhookUrl) && options.enabled !== false);
-    this.webhookUrl = webhookUrl;
-    this.minLevel = options.minLevel || "critical" /* CRITICAL */;
-    this.channel = options.channel;
-    this.username = options.username || "Error Logger";
-    this.iconEmoji = options.iconEmoji || ":rotating_light:";
-  }
-  async log(entry) {
-    if (!this.webhookUrl) {
-      return;
-    }
-    if (!this.shouldLog(entry.level)) {
-      return;
-    }
-    try {
-      const payload = this.buildPayload(entry);
-      const response = await fetch(this.webhookUrl, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(payload)
-      });
-      if (!response.ok) {
-        throw new Error(`Slack webhook failed: ${response.statusText}`);
-      }
-    } catch (error) {
-      console.error("[SlackTransport] Failed to send to Slack:", error);
-    }
-  }
-  /**
-   * Slack 메시지 페이로드 생성
-   */
-  buildPayload(entry) {
-    const payload = {
-      username: this.username,
-      icon_emoji: this.iconEmoji
-    };
-    if (this.channel) {
-      payload.channel = this.channel;
-    }
-    const attachment = {
-      color: LEVEL_COLORS[entry.level],
-      title: `${entry.level.toUpperCase()}: ${entry.message}`,
-      timestamp: Math.floor(entry.timestamp.getTime() / 1e3),
-      fields: []
-    };
-    if (entry.context.requestId) {
-      attachment.fields.push({
-        title: "Request ID",
-        value: entry.context.requestId,
-        short: true
-      });
-    }
-    if (entry.context.errorCode) {
-      attachment.fields.push({
-        title: "Error Code",
-        value: entry.context.errorCode,
-        short: true
-      });
-    }
-    if (entry.context.userId) {
-      attachment.fields.push({
-        title: "User ID",
-        value: entry.context.userId,
-        short: true
-      });
-    }
-    if (entry.context.environment) {
-      attachment.fields.push({
-        title: "Environment",
-        value: entry.context.environment,
-        short: true
-      });
-    }
-    if (entry.context.path) {
-      attachment.fields.push({
-        title: "Path",
-        value: entry.context.path,
-        short: false
-      });
-    }
-    if (entry.error && entry.error.stack) {
-      attachment.fields.push({
-        title: "Stack Trace",
-        value: `\`\`\`${this.truncate(entry.error.stack, 1e3)}\`\`\``,
-        short: false
-      });
-    }
-    payload.attachments = [attachment];
-    return payload;
-  }
-  /**
-   * 문자열 자르기
-   */
-  truncate(str, maxLength) {
-    if (str.length <= maxLength) {
-      return str;
-    }
-    return str.substring(0, maxLength) + "...";
-  }
-  /**
-   * 로그 레벨 체크
-   */
-  shouldLog(level) {
-    const LOG_LEVEL_PRIORITY = {
-      ["debug" /* DEBUG */]: 0,
-      ["info" /* INFO */]: 1,
-      ["warn" /* WARN */]: 2,
-      ["error" /* ERROR */]: 3,
-      ["critical" /* CRITICAL */]: 4
-    };
-    return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.minLevel];
-  }
-};
-
-export {
-  SlackTransport
-};