@withwiz/toolkit 0.1.0

package/dist/chunk-EEUBKZV4.js

@@ -0,0 +1,54 @@
+import {
+  enMessages
+} from "./chunk-N4YGR5WH.js";
+import {
+  koMessages
+} from "./chunk-KXAWBFJN.js";
+
+// src/error/messages/index.ts
+var messageRegistry = {
+  ko: koMessages,
+  en: enMessages,
+  ja: koMessages
+  // Fallback to Korean for now
+};
+var defaultMessages = {
+  ko: {
+    title: "\uBB38\uC81C\uAC00 \uBC1C\uC0DD\uD588\uC5B4\uC694",
+    description: "\uC608\uC0C1\uCE58 \uBABB\uD55C \uC624\uB958\uAC00 \uBC1C\uC0DD\uD588\uC2B5\uB2C8\uB2E4.",
+    action: "\uC7A0\uC2DC \uD6C4 \uB2E4\uC2DC \uC2DC\uB3C4\uD574 \uC8FC\uC138\uC694."
+  },
+  en: {
+    title: "Something went wrong",
+    description: "An unexpected error occurred.",
+    action: "Please try again later."
+  },
+  ja: {
+    title: "\u554F\u984C\u304C\u767A\u751F\u3057\u307E\u3057\u305F",
+    description: "\u4E88\u671F\u3057\u306A\u3044\u30A8\u30E9\u30FC\u304C\u767A\u751F\u3057\u307E\u3057\u305F\u3002",
+    action: "\u3057\u3070\u3089\u304F\u3057\u3066\u304B\u3089\u3082\u3046\u4E00\u5EA6\u304A\u8A66\u3057\u304F\u3060\u3055\u3044\u3002"
+  }
+};
+function getErrorMessage(code, locale = "ko") {
+  const messages = messageRegistry[locale] || messageRegistry.ko;
+  return messages[code] || defaultMessages[locale] || defaultMessages.ko;
+}
+function getAllMessages(locale = "ko") {
+  return messageRegistry[locale] || messageRegistry.ko;
+}
+function hasMessage(code, locale = "ko") {
+  const messages = messageRegistry[locale] || messageRegistry.ko;
+  return code in messages;
+}
+var supportedLocales = ["ko", "en", "ja"];
+function isLocaleSupported(locale) {
+  return supportedLocales.includes(locale);
+}
+
+export {
+  getErrorMessage,
+  getAllMessages,
+  hasMessage,
+  supportedLocales,
+  isLocaleSupported
+};

package/dist/chunk-EQYTE7WD.js

@@ -0,0 +1,139 @@
+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
+};

package/dist/chunk-EUQATJLI.js

@@ -0,0 +1,180 @@
+// src/utils/type-guards.ts
+function isNotNull(value) {
+  return value !== null;
+}
+function isDefined(value) {
+  return value !== void 0;
+}
+function isPresent(value) {
+  return value !== null && value !== void 0;
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isNumber(value) {
+  return typeof value === "number" && !isNaN(value);
+}
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isValidEmail(value) {
+  if (typeof value !== "string") return false;
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(value);
+}
+function isValidUrl(value) {
+  if (typeof value !== "string") return false;
+  try {
+    new URL(value);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function isIPv4(value) {
+  if (typeof value !== "string") return false;
+  const ipv4Regex = /^(\d{1,3}\.){3}\d{1,3}$/;
+  if (!ipv4Regex.test(value)) return false;
+  const parts = value.split(".");
+  return parts.every((part) => {
+    const num = parseInt(part, 10);
+    return num >= 0 && num <= 255;
+  });
+}
+function isIPv6(value) {
+  if (typeof value !== "string") return false;
+  const ipv6Regex = /^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$|^(([0-9a-fA-F]{1,4}:)*)?::([0-9a-fA-F]{1,4}:)*[0-9a-fA-F]{1,4}$/;
+  return ipv6Regex.test(value);
+}
+function isIPAddress(value) {
+  return isIPv4(value) || isIPv6(value);
+}
+function isValidDate(value) {
+  return value instanceof Date && !isNaN(value.getTime());
+}
+function isISODateString(value) {
+  if (typeof value !== "string") return false;
+  const date = new Date(value);
+  return !isNaN(date.getTime()) && value === date.toISOString();
+}
+function isDateParseable(value) {
+  if (value instanceof Date) return isValidDate(value);
+  if (typeof value === "number") return !isNaN(new Date(value).getTime());
+  if (typeof value === "string") return !isNaN(new Date(value).getTime());
+  return false;
+}
+function isSortOrder(value) {
+  return value === "asc" || value === "desc";
+}
+function isApiSuccessResponse(response) {
+  return response.success === true;
+}
+function isApiErrorResponse(response) {
+  return response.success === false;
+}
+function isValidJSON(value) {
+  if (typeof value !== "string") return false;
+  try {
+    JSON.parse(value);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function isJSONSerializable(value) {
+  try {
+    JSON.stringify(value);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function isEmptyString(value) {
+  return value === "";
+}
+function isEmptyArray(value) {
+  return Array.isArray(value) && value.length === 0;
+}
+function isEmptyObject(value) {
+  return isObject(value) && Object.keys(value).length === 0;
+}
+function isEmpty(value) {
+  if (value === null || value === void 0) return true;
+  if (isEmptyString(value)) return true;
+  if (isEmptyArray(value)) return true;
+  if (isEmptyObject(value)) return true;
+  return false;
+}
+var type_guards_default = {
+  // Utility Types
+  isNotNull,
+  isDefined,
+  isPresent,
+  isString,
+  isNumber,
+  isBoolean,
+  isObject,
+  isArray,
+  isFunction,
+  // Validation
+  isValidEmail,
+  isValidUrl,
+  isIPv4,
+  isIPv6,
+  isIPAddress,
+  isValidDate,
+  isISODateString,
+  isDateParseable,
+  // Sort Order
+  isSortOrder,
+  // API Response
+  isApiSuccessResponse,
+  isApiErrorResponse,
+  // JSON
+  isValidJSON,
+  isJSONSerializable,
+  // Empty checks
+  isEmptyString,
+  isEmptyArray,
+  isEmptyObject,
+  isEmpty
+};
+
+export {
+  isNotNull,
+  isDefined,
+  isPresent,
+  isString,
+  isNumber,
+  isBoolean,
+  isObject,
+  isArray,
+  isFunction,
+  isValidEmail,
+  isValidUrl,
+  isIPv4,
+  isIPv6,
+  isIPAddress,
+  isValidDate,
+  isISODateString,
+  isDateParseable,
+  isSortOrder,
+  isApiSuccessResponse,
+  isApiErrorResponse,
+  isValidJSON,
+  isJSONSerializable,
+  isEmptyString,
+  isEmptyArray,
+  isEmptyObject,
+  isEmpty,
+  type_guards_default
+};

package/dist/chunk-EZC6ETFW.js

@@ -0,0 +1,80 @@
+import {
+  getTimezoneOffset,
+  getUserTimezone
+} from "./chunk-TRBKJ7JT.js";
+import {
+  __spreadProps,
+  __spreadValues
+} from "./chunk-ORMEWXMH.js";
+
+// src/hooks/useTimezone.ts
+import { useState, useEffect, useCallback } from "react";
+function useTimezone() {
+  const [timezoneInfo, setTimezoneInfo] = useState({
+    timezone: "UTC",
+    offset: 0,
+    offsetFormatted: "+00:00"
+  });
+  const [isLoading, setIsLoading] = useState(true);
+  useEffect(() => {
+    try {
+      const timezone = getUserTimezone();
+      const offset = getTimezoneOffset();
+      const offsetFormatted = formatOffset(offset);
+      setTimezoneInfo({
+        timezone,
+        offset,
+        offsetFormatted
+      });
+    } catch (error) {
+      console.warn("Cannot get timezone information:", error);
+      setTimezoneInfo({
+        timezone: "UTC",
+        offset: 0,
+        offsetFormatted: "+00:00"
+      });
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  const formatOffset = useCallback((offsetMinutes) => {
+    const absOffset = Math.abs(offsetMinutes);
+    const hours = Math.floor(absOffset / 60);
+    const minutes = absOffset % 60;
+    const sign = offsetMinutes <= 0 ? "+" : "-";
+    return `${sign}${hours.toString().padStart(2, "0")}:${minutes.toString().padStart(2, "0")}`;
+  }, []);
+  const refreshTimezone = useCallback(() => {
+    try {
+      const timezone = getUserTimezone();
+      const offset = getTimezoneOffset();
+      const offsetFormatted = formatOffset(offset);
+      setTimezoneInfo({
+        timezone,
+        offset,
+        offsetFormatted
+      });
+    } catch (error) {
+      console.error("Failed to refresh timezone information:", error);
+    }
+  }, [formatOffset]);
+  return __spreadProps(__spreadValues({}, timezoneInfo), {
+    isLoading,
+    refreshTimezone
+  });
+}
+function useSimpleTimezone() {
+  const { timezone, offsetFormatted, isLoading } = useTimezone();
+  return {
+    timezone,
+    offsetFormatted,
+    isLoading,
+    // 간단한 표시용
+    display: `${timezone} (${offsetFormatted})`
+  };
+}
+
+export {
+  useTimezone,
+  useSimpleTimezone
+};

package/dist/chunk-EZR55KV2.js

@@ -0,0 +1,249 @@
+import {
+  __spreadProps,
+  __spreadValues
+} from "./chunk-ORMEWXMH.js";
+
+// src/logger/logger.ts
+import fs from "fs";
+import winston from "winston";
+import DailyRotateFile from "winston-daily-rotate-file";
+if (typeof process !== "undefined" && process.setMaxListeners) {
+  if (!globalThis.__maxListenersSet) {
+    process.setMaxListeners(20);
+    globalThis.__maxListenersSet = true;
+  }
+}
+var { combine, timestamp, printf, colorize } = winston.format;
+var {
+  LOG_DIR = "./logs",
+  LOG_FILE = "app.log",
+  LOG_PATH = "",
+  LOG_FILE_ENABLED = "true",
+  LOG_CONSOLE_ENABLED = "true",
+  LOG_LEVEL = "info"
+} = process.env;
+var colors = {
+  error: "red",
+  warn: "yellow",
+  info: "green",
+  http: "magenta",
+  debug: "blue"
+};
+winston.addColors(colors);
+var isTestEnv = process.env.NODE_ENV === "test" || process.env.JEST_WORKER_ID !== void 0;
+var isBuildTime = process.env.NEXT_PHASE === "phase-production-build" || process.argv.some((arg) => arg.includes("build"));
+var canWriteToLogDir = (() => {
+  if (isTestEnv || isBuildTime) return false;
+  try {
+    const logDir = LOG_PATH || LOG_DIR;
+    if (fs.existsSync(logDir)) {
+      fs.accessSync(logDir, fs.constants.W_OK);
+      return true;
+    }
+    fs.mkdirSync(logDir, { recursive: true });
+    return true;
+  } catch (e) {
+    return false;
+  }
+})();
+var fileLoggingEnabled = !isTestEnv && !isBuildTime && canWriteToLogDir && LOG_FILE_ENABLED === "true";
+var consoleLoggingEnabled = LOG_CONSOLE_ENABLED === "true";
+var datePatternString = "YYYY-MM-DD";
+var logLevel = LOG_LEVEL;
+var transports = [];
+var logFormat = combine(
+  timestamp({ format: "YYYY-MM-DD HH:mm:ss:ms" }),
+  printf((info) => {
+    if (info.stack) {
+      return `${info.level}: ${info.timestamp} ${info.message} 
+ Error Stack: ${info.stack}`;
+    }
+    const winstonStandardKeys = ["level", "message", "timestamp", "stack", "splat", "symbol"];
+    const metaKeys = Object.keys(info).filter((key) => !winstonStandardKeys.includes(key));
+    const rawLevel = info.level.replace(/\u001b\[\d+m/g, "");
+    const isInfoLevel = rawLevel === "info";
+    if (metaKeys.length > 0) {
+      const meta = {};
+      metaKeys.forEach((key) => {
+        meta[key] = info[key];
+      });
+      const metaStr = isInfoLevel ? JSON.stringify(meta) : JSON.stringify(meta, null, 2);
+      return `${info.level}: ${info.timestamp} ${info.message} ${metaStr}`;
+    }
+    if (info.meta && typeof info.meta === "object") {
+      const metaStr = isInfoLevel ? JSON.stringify(info.meta) : JSON.stringify(info.meta, null, 2);
+      return `${info.level}: ${info.timestamp} ${info.message} ${metaStr}`;
+    }
+    return `${info.level}: ${info.timestamp} ${info.message}`;
+  })
+);
+var consoleOpts = {
+  handleExceptions: true,
+  // level: process.env.NODE_ENV === 'production' ? 'error' : 'debug',
+  format: combine(
+    colorize({ all: true }),
+    timestamp({ format: "YYYY-MM-DD HH:mm:ss:ms" })
+  )
+};
+if (consoleLoggingEnabled) {
+  transports.push(
+    new winston.transports.Console({
+      format: winston.format.combine(
+        winston.format.colorize(),
+        winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss:ms" }),
+        winston.format.printf((info) => {
+          if (info.stack) {
+            return `${info.level}: ${info.timestamp} ${info.message} 
+ Error Stack: ${info.stack}`;
+          }
+          const winstonStandardKeys = ["level", "message", "timestamp", "stack", "splat", "symbol"];
+          const metaKeys = Object.keys(info).filter((key) => !winstonStandardKeys.includes(key));
+          const rawLevel = info.level.replace(/\u001b\[\d+m/g, "");
+          const isInfoLevel = rawLevel === "info";
+          if (metaKeys.length > 0) {
+            const meta = {};
+            metaKeys.forEach((key) => {
+              meta[key] = info[key];
+            });
+            const metaStr = isInfoLevel ? JSON.stringify(meta) : JSON.stringify(meta, null, 2);
+            return `${info.level}: ${info.timestamp} ${info.message} ${metaStr}`;
+          }
+          if (info.meta && typeof info.meta === "object") {
+            const metaStr = isInfoLevel ? JSON.stringify(info.meta) : JSON.stringify(info.meta, null, 2);
+            return `${info.level}: ${info.timestamp} ${info.message} ${metaStr}`;
+          }
+          return `${info.level}: ${info.timestamp} ${info.message}`;
+        })
+      ),
+      level: logLevel,
+      handleExceptions: true
+    })
+  );
+}
+if (fileLoggingEnabled) {
+  transports.push(
+    new DailyRotateFile({
+      filename: LOG_PATH || `${LOG_DIR}/${LOG_FILE.replace(/\.log$/, "")}-%DATE%.log`,
+      zippedArchive: true,
+      maxFiles: "14d",
+      // Keep for 14 days
+      datePattern: datePatternString,
+      level: logLevel,
+      handleExceptions: true,
+      json: false,
+      dirname: LOG_PATH ? void 0 : LOG_DIR
+    })
+  );
+}
+var _a;
+var logger = (_a = globalThis.__winstonLoggerInstance) != null ? _a : (() => {
+  const instance = winston.createLogger({
+    level: "info",
+    format: winston.format.combine(
+      winston.format.timestamp(),
+      winston.format.errors({ stack: true }),
+      winston.format.splat(),
+      logFormat
+    ),
+    transports,
+    exitOnError: false
+  });
+  globalThis.__winstonLoggerInstance = instance;
+  return instance;
+})();
+function logDebug(message, meta) {
+  logger.debug(message, meta);
+}
+function logInfo(message, meta) {
+  logger.info(message, meta);
+}
+function logError(message, meta) {
+  logger.error(message, meta);
+}
+var MASK_KEYS = ["password", "token", "secret", "accessToken", "refreshToken"];
+var MAX_BODY_LENGTH = 1024;
+function maskSensitiveData(obj) {
+  if (typeof obj !== "object" || obj === null) return obj;
+  const masked = __spreadValues({}, obj);
+  for (const key of MASK_KEYS) {
+    if (key in masked) {
+      masked[key] = "[MASKED]";
+    }
+  }
+  return masked;
+}
+function truncateBody(body) {
+  if (typeof body === "string") {
+    return body.length > MAX_BODY_LENGTH ? body.slice(0, MAX_BODY_LENGTH) + "... [TRUNCATED]" : body;
+  }
+  if (typeof body === "object") {
+    const str = JSON.stringify(body);
+    return str.length > MAX_BODY_LENGTH ? str.slice(0, MAX_BODY_LENGTH) + "... [TRUNCATED]" : body;
+  }
+  return body;
+}
+async function getSafeBody(req) {
+  try {
+    const cloned = req.clone();
+    const contentType = cloned.headers.get("content-type") || "";
+    let body = null;
+    if (contentType.includes("application/json")) {
+      body = await cloned.json();
+    } else if (contentType.includes("text/")) {
+      body = await cloned.text();
+    } else {
+      return "[non-text body]";
+    }
+    if (typeof body === "object" && body !== null) {
+      body = maskSensitiveData(body);
+    }
+    return truncateBody(body);
+  } catch (e) {
+    return "[unreadable body]";
+  }
+}
+function logApiRequest(request, extra) {
+  const baseLog = __spreadValues({
+    method: request.method,
+    url: request.url
+  }, extra);
+  const contentType = request.headers.get("content-type") || "";
+  if (contentType.includes("application/json") || contentType.includes("text/")) {
+    getSafeBody(request).then((body) => {
+      const fullLog = __spreadProps(__spreadValues({}, baseLog), { body });
+      logDebug("[API Req] " + JSON.stringify(fullLog, null, 2));
+    }).catch(() => {
+      logDebug("[API Req] " + JSON.stringify(baseLog, null, 2));
+    });
+  } else {
+    logDebug("[API Req] " + JSON.stringify(baseLog, null, 2));
+  }
+}
+function logApiResponse(request, response, extra) {
+  const baseLog = __spreadValues({
+    method: request.method,
+    url: request.url,
+    status: response.status,
+    headers: Object.fromEntries(response.headers.entries())
+  }, extra);
+  const contentType = response.headers.get("content-type") || "";
+  if (contentType.includes("application/json") || contentType.includes("text/")) {
+    getSafeBody(response).then((body) => {
+      const fullLog = __spreadProps(__spreadValues({}, baseLog), { body });
+      logDebug("[API Res] " + JSON.stringify(fullLog, null, 2));
+    }).catch(() => {
+      logDebug("[API Res] " + JSON.stringify(baseLog, null, 2));
+    });
+  } else {
+    logDebug("[API Res] " + JSON.stringify(baseLog, null, 2));
+  }
+}
+
+export {
+  logger,
+  logDebug,
+  logInfo,
+  logError,
+  logApiRequest,
+  logApiResponse
+};