@withwiz/toolkit 0.1.0

package/dist/geolocation/index.js

@@ -0,0 +1,36 @@
+import {
+  GeoIPProviderFactory
+} from "../chunk-S73334QY.js";
+import {
+  IPApiProvider
+} from "../chunk-DEEJBDJE.js";
+import {
+  IPApiCoProvider
+} from "../chunk-VSGKVZB4.js";
+import {
+  IPGeolocationProvider
+} from "../chunk-DH2ZHGW2.js";
+import {
+  MaxMindProvider
+} from "../chunk-4NWJ3WCZ.js";
+import {
+  BaseGeoIPProvider,
+  truncateString
+} from "../chunk-AHDPGRXS.js";
+import {
+  BatchProcessor,
+  createBatchProcessor
+} from "../chunk-TZAP5T4N.js";
+import "../chunk-EZR55KV2.js";
+import "../chunk-ORMEWXMH.js";
+export {
+  BaseGeoIPProvider,
+  BatchProcessor,
+  GeoIPProviderFactory,
+  IPApiCoProvider,
+  IPApiProvider,
+  IPGeolocationProvider,
+  MaxMindProvider,
+  createBatchProcessor,
+  truncateString
+};

package/dist/geolocation/providers/base-provider.d.ts

@@ -0,0 +1,33 @@
+/**
+ * GeoIP Provider Base
+ *
+ * 프로젝트 독립적인 GeoIP 제공자 기본 클래스
+ * - 외부 의존성 없음 (Prisma, CacheKeys 등)
+ * - 순수 HTTP 클라이언트
+ */
+import type { IGeoIPProvider, IGeoIPApiResponse } from '@withwiz/types/geoip';
+import type { IGeoLocationData } from '@withwiz/types/database';
+/**
+ * 문자열 길이를 제한하는 유틸리티 함수
+ */
+export declare function truncateString(str: string | null | undefined, maxLength: number): string | null;
+/**
+ * GeoIP Provider 기본 클래스
+ * 모든 제공자가 상속받아 구현
+ */
+export declare abstract class BaseGeoIPProvider implements IGeoIPProvider {
+    abstract name: string;
+    protected abstract rateLimit: number;
+    protected abstract timeout: number;
+    abstract url(ip: string): string;
+    abstract parseResponse(data: IGeoIPApiResponse): IGeoLocationData | null;
+    isAvailable(): boolean;
+    getRateLimit(): number;
+    getTimeout(): number;
+    /**
+     * IP 주소로 GeoIP 데이터 조회
+     * @param ip - IP 주소
+     * @returns GeoIP 데이터 또는 null
+     */
+    fetchGeoData(ip: string): Promise<IGeoLocationData | null>;
+}

package/dist/geolocation/providers/base-provider.js

@@ -0,0 +1,9 @@
+import {
+  BaseGeoIPProvider,
+  truncateString
+} from "../../chunk-AHDPGRXS.js";
+import "../../chunk-ORMEWXMH.js";
+export {
+  BaseGeoIPProvider,
+  truncateString
+};

package/dist/geolocation/providers/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * GeoIP Providers
+ *
+ * 프로젝트 독립적인 GeoIP 제공자 모듈
+ * - 순수 HTTP 클라이언트
+ * - 외부 의존성 없음
+ */
+import type { IGeoIPProvider } from '@withwiz/types/geoip';
+export { BaseGeoIPProvider, truncateString } from './base-provider';
+export { IPApiProvider } from './ip-api-provider';
+export { IPApiCoProvider } from './ipapi-co-provider';
+export { IPGeolocationProvider } from './ipgeolocation-provider';
+export { MaxMindProvider } from './maxmind-provider';
+/**
+ * GeoIP 제공자 팩토리
+ * 제공자들을 관리하고 적절한 제공자를 선택
+ * - 프로젝트 독립적
+ */
+export declare class GeoIPProviderFactory {
+    private static providers;
+    /**
+     * 사용 가능한 제공자 목록 반환
+     */
+    static getAvailableProviders(): IGeoIPProvider[];
+    /**
+     * 이름으로 제공자 찾기
+     */
+    static getProvider(name: string): IGeoIPProvider | null;
+    /**
+     * 모든 제공자 목록 반환
+     */
+    static getAllProviders(): IGeoIPProvider[];
+    /**
+     * 제공자별 성능 통계
+     */
+    static getProviderStats(): Array<{
+        name: string;
+        available: boolean;
+        rateLimit: number;
+        timeout: number;
+    }>;
+    /**
+     * 최적의 제공자 선택 (성능 기준)
+     */
+    static getOptimalProvider(): IGeoIPProvider | null;
+    /**
+     * 제공자 등록
+     */
+    static registerProvider(provider: IGeoIPProvider): void;
+    /**
+     * 제공자 제거
+     */
+    static unregisterProvider(name: string): boolean;
+}

package/dist/geolocation/providers/index.js

@@ -0,0 +1,29 @@
+import {
+  GeoIPProviderFactory
+} from "../../chunk-S73334QY.js";
+import {
+  IPApiProvider
+} from "../../chunk-DEEJBDJE.js";
+import {
+  IPApiCoProvider
+} from "../../chunk-VSGKVZB4.js";
+import {
+  IPGeolocationProvider
+} from "../../chunk-DH2ZHGW2.js";
+import {
+  MaxMindProvider
+} from "../../chunk-4NWJ3WCZ.js";
+import {
+  BaseGeoIPProvider,
+  truncateString
+} from "../../chunk-AHDPGRXS.js";
+import "../../chunk-ORMEWXMH.js";
+export {
+  BaseGeoIPProvider,
+  GeoIPProviderFactory,
+  IPApiCoProvider,
+  IPApiProvider,
+  IPGeolocationProvider,
+  MaxMindProvider,
+  truncateString
+};

package/dist/geolocation/providers/ip-api-provider.d.ts

@@ -0,0 +1,17 @@
+/**
+ * IP-API.com Provider
+ *
+ * 무료 GeoIP 제공자 (분당 45회 요청 제한)
+ * - 프로젝트 독립적
+ * - HTTP 전용 (무료 플랜)
+ */
+import type { IGeoIPApiResponse } from '@withwiz/types/geoip';
+import type { IGeoLocationData } from '@withwiz/types/database';
+import { BaseGeoIPProvider } from './base-provider';
+export declare class IPApiProvider extends BaseGeoIPProvider {
+    name: string;
+    protected rateLimit: number;
+    protected timeout: number;
+    url(ip: string): string;
+    parseResponse(data: IGeoIPApiResponse): IGeoLocationData | null;
+}

package/dist/geolocation/providers/ip-api-provider.js

@@ -0,0 +1,8 @@
+import {
+  IPApiProvider
+} from "../../chunk-DEEJBDJE.js";
+import "../../chunk-AHDPGRXS.js";
+import "../../chunk-ORMEWXMH.js";
+export {
+  IPApiProvider
+};

package/dist/geolocation/providers/ipapi-co-provider.d.ts

@@ -0,0 +1,17 @@
+/**
+ * IPAPI.co Provider
+ *
+ * 무료 GeoIP 제공자 (분당 1000회 요청 제한)
+ * - 프로젝트 독립적
+ * - HTTPS 지원
+ */
+import type { IGeoIPApiResponse } from '@withwiz/types/geoip';
+import type { IGeoLocationData } from '@withwiz/types/database';
+import { BaseGeoIPProvider } from './base-provider';
+export declare class IPApiCoProvider extends BaseGeoIPProvider {
+    name: string;
+    protected rateLimit: number;
+    protected timeout: number;
+    url(ip: string): string;
+    parseResponse(data: IGeoIPApiResponse): IGeoLocationData | null;
+}

package/dist/geolocation/providers/ipapi-co-provider.js

@@ -0,0 +1,8 @@
+import {
+  IPApiCoProvider
+} from "../../chunk-VSGKVZB4.js";
+import "../../chunk-AHDPGRXS.js";
+import "../../chunk-ORMEWXMH.js";
+export {
+  IPApiCoProvider
+};

package/dist/geolocation/providers/ipgeolocation-provider.d.ts

@@ -0,0 +1,18 @@
+/**
+ * IPGeolocation.io Provider
+ *
+ * 유료 GeoIP 제공자 (고성능)
+ * - 프로젝트 독립적
+ * - API 키 필요
+ */
+import type { IGeoIPApiResponse } from '@withwiz/types/geoip';
+import type { IGeoLocationData } from '@withwiz/types/database';
+import { BaseGeoIPProvider } from './base-provider';
+export declare class IPGeolocationProvider extends BaseGeoIPProvider {
+    name: string;
+    protected rateLimit: number;
+    protected timeout: number;
+    url(ip: string): string;
+    parseResponse(data: IGeoIPApiResponse): IGeoLocationData | null;
+    isAvailable(): boolean;
+}

package/dist/geolocation/providers/ipgeolocation-provider.js

@@ -0,0 +1,8 @@
+import {
+  IPGeolocationProvider
+} from "../../chunk-DH2ZHGW2.js";
+import "../../chunk-AHDPGRXS.js";
+import "../../chunk-ORMEWXMH.js";
+export {
+  IPGeolocationProvider
+};

package/dist/geolocation/providers/maxmind-provider.d.ts

@@ -0,0 +1,18 @@
+/**
+ * MaxMind GeoIP2 Provider
+ *
+ * 유료 GeoIP 제공자 (최고 성능, 로컬 DB)
+ * - 프로젝트 독립적
+ * - 로컬 데이터베이스 사용 (현재 미구현)
+ */
+import type { IGeoIPApiResponse } from '@withwiz/types/geoip';
+import type { IGeoLocationData } from '@withwiz/types/database';
+import { BaseGeoIPProvider } from './base-provider';
+export declare class MaxMindProvider extends BaseGeoIPProvider {
+    name: string;
+    protected rateLimit: number;
+    protected timeout: number;
+    url(ip: string): string;
+    parseResponse(data: IGeoIPApiResponse): IGeoLocationData | null;
+    isAvailable(): boolean;
+}

package/dist/geolocation/providers/maxmind-provider.js

@@ -0,0 +1,8 @@
+import {
+  MaxMindProvider
+} from "../../chunk-4NWJ3WCZ.js";
+import "../../chunk-AHDPGRXS.js";
+import "../../chunk-ORMEWXMH.js";
+export {
+  MaxMindProvider
+};

package/dist/hooks/useDataTable.d.ts

@@ -0,0 +1,51 @@
+export interface DataTableFilters {
+    search?: string;
+    [key: string]: any;
+}
+export interface DataTableSort {
+    sort: string;
+    order: 'asc' | 'desc';
+}
+export interface DataTablePagination {
+    page: number;
+    pageSize: number;
+    total: number;
+}
+export interface UseDataTableOptions<T> {
+    initialFilters?: DataTableFilters;
+    initialSort?: DataTableSort;
+    initialPagination?: Partial<DataTablePagination>;
+    debounceMs?: number;
+    onDataChange?: (params: {
+        filters: DataTableFilters;
+        sort: DataTableSort;
+        pagination: DataTablePagination;
+    }) => Promise<void>;
+}
+export interface UseDataTableReturn<T> {
+    data: T[];
+    loading: boolean;
+    error: string | null;
+    total: number;
+    filters: DataTableFilters;
+    sort: DataTableSort;
+    pagination: DataTablePagination;
+    selectedIds: string[];
+    setData: (data: T[]) => void;
+    setLoading: (loading: boolean) => void;
+    setError: (error: string | null) => void;
+    setTotal: (total: number) => void;
+    setFilters: (filters: DataTableFilters) => void;
+    updateFilter: (key: string, value: any) => void;
+    clearFilters: () => void;
+    setSort: (sort: string, order?: 'asc' | 'desc') => void;
+    setPage: (page: number) => void;
+    setPageSize: (pageSize: number) => void;
+    setSelectedIds: (ids: string[]) => void;
+    toggleSelection: (id: string) => void;
+    selectAll: () => void;
+    clearSelection: () => void;
+    refresh: () => Promise<void>;
+    bulkAction: (action: (ids: string[]) => Promise<void>) => Promise<void>;
+}
+export declare function useDataTable<T>({ initialFilters, initialSort, initialPagination, debounceMs, onDataChange, }: UseDataTableOptions<T>): UseDataTableReturn<T>;

package/dist/hooks/useDataTable.js

@@ -0,0 +1,149 @@
+"use client";
+import {
+  useDebounce
+} from "../chunk-ZTN4X5FN.js";
+import {
+  __spreadProps,
+  __spreadValues
+} from "../chunk-ORMEWXMH.js";
+
+// src/hooks/useDataTable.ts
+import { useState, useCallback, useMemo } from "react";
+function useDataTable({
+  initialFilters = {},
+  initialSort = { sort: "createdAt", order: "desc" },
+  initialPagination = { page: 1, pageSize: 10, total: 0 },
+  debounceMs = 500,
+  onDataChange
+}) {
+  const [data, setData] = useState([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [total, setTotal] = useState(initialPagination.total || 0);
+  const [filters, setFilters] = useState(initialFilters);
+  const [sort, setSortState] = useState(initialSort);
+  const [pagination, setPaginationState] = useState({
+    page: initialPagination.page || 1,
+    pageSize: initialPagination.pageSize || 10,
+    total: initialPagination.total || 0
+  });
+  const [selectedIds, setSelectedIds] = useState([]);
+  const debouncedSearch = useDebounce(filters.search || "", debounceMs);
+  const refresh = useCallback(async () => {
+    if (!onDataChange) return;
+    setLoading(true);
+    setError(null);
+    try {
+      await onDataChange({
+        filters: __spreadProps(__spreadValues({}, filters), { search: debouncedSearch }),
+        sort,
+        pagination
+      });
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "An error occurred");
+    } finally {
+      setLoading(false);
+    }
+  }, [filters, debouncedSearch, sort, pagination, onDataChange]);
+  const updateFilter = useCallback((key, value) => {
+    setFilters((prev) => __spreadProps(__spreadValues({}, prev), {
+      [key]: value
+    }));
+    if (key !== "search") {
+      setPaginationState((prev) => __spreadProps(__spreadValues({}, prev), { page: 1 }));
+    }
+  }, []);
+  const clearFilters = useCallback(() => {
+    setFilters(initialFilters);
+    setPaginationState((prev) => __spreadProps(__spreadValues({}, prev), { page: 1 }));
+  }, [initialFilters]);
+  const setSort = useCallback((newSort, newOrder) => {
+    setSortState((prev) => {
+      if (prev.sort === newSort) {
+        return {
+          sort: newSort,
+          order: newOrder || (prev.order === "asc" ? "desc" : "asc")
+        };
+      }
+      return {
+        sort: newSort,
+        order: newOrder || "asc"
+      };
+    });
+    setPaginationState((prev) => __spreadProps(__spreadValues({}, prev), { page: 1 }));
+  }, []);
+  const setPage = useCallback((page) => {
+    setPaginationState((prev) => __spreadProps(__spreadValues({}, prev), { page }));
+  }, []);
+  const setPageSize = useCallback((pageSize) => {
+    setPaginationState((prev) => __spreadProps(__spreadValues({}, prev), { pageSize, page: 1 }));
+  }, []);
+  const toggleSelection = useCallback((id) => {
+    setSelectedIds(
+      (prev) => prev.includes(id) ? prev.filter((selectedId) => selectedId !== id) : [...prev, id]
+    );
+  }, []);
+  const selectAll = useCallback(() => {
+    setSelectedIds(data.map((item) => item.id));
+  }, [data]);
+  const clearSelection = useCallback(() => {
+    setSelectedIds([]);
+  }, []);
+  const bulkAction = useCallback(async (action) => {
+    if (selectedIds.length === 0) return;
+    setLoading(true);
+    try {
+      await action(selectedIds);
+      setSelectedIds([]);
+      await refresh();
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Bulk action failed");
+    } finally {
+      setLoading(false);
+    }
+  }, [selectedIds, refresh]);
+  useMemo(() => {
+    if (debouncedSearch !== filters.search) {
+      setPaginationState((prev) => __spreadProps(__spreadValues({}, prev), { page: 1 }));
+    }
+  }, [debouncedSearch, filters.search]);
+  useMemo(() => {
+    refresh();
+  }, [debouncedSearch, sort.sort, sort.order, pagination.page, pagination.pageSize]);
+  return {
+    // 상태
+    data,
+    loading,
+    error,
+    total,
+    filters,
+    sort,
+    pagination,
+    selectedIds,
+    // 데이터 관리
+    setData,
+    setLoading,
+    setError,
+    setTotal,
+    // 필터 관리
+    setFilters,
+    updateFilter,
+    clearFilters,
+    // 정렬 관리
+    setSort,
+    // 페이지네이션 관리
+    setPage,
+    setPageSize,
+    // 선택 관리
+    setSelectedIds,
+    toggleSelection,
+    selectAll,
+    clearSelection,
+    // 액션
+    refresh,
+    bulkAction
+  };
+}
+export {
+  useDataTable
+};

package/dist/hooks/useDebounce.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 디바운싱을 위한 커스텀 훅
+ * @param value 디바운싱할 값
+ * @param delay 지연 시간 (밀리초)
+ * @returns 디바운싱된 값
+ */
+export declare function useDebounce<T>(value: T, delay: number): T;

package/dist/hooks/useDebounce.js

@@ -0,0 +1,7 @@
+import {
+  useDebounce
+} from "../chunk-ZTN4X5FN.js";
+import "../chunk-ORMEWXMH.js";
+export {
+  useDebounce
+};

package/dist/hooks/useExitIntent.d.ts

@@ -0,0 +1,35 @@
+export interface UseExitIntentOptions {
+    /** 팝업 표시 쿨다운 시간 (밀리초) - 기본 24시간 */
+    cooldown?: number;
+    /** 페이지 진입 후 대기 시간 (밀리초) - 기본 5초 */
+    delay?: number;
+    /** localStorage에 저장할 키 */
+    storageKey?: string;
+    /** 비활성화 여부 */
+    disabled?: boolean;
+}
+export interface UseExitIntentReturn {
+    /** 팝업 표시 여부 */
+    showPopup: boolean;
+    /** 팝업 닫기 */
+    closePopup: () => void;
+    /** 다시 보지 않기 처리 */
+    dismissForever: () => void;
+}
+/**
+ * Exit Intent 감지 훅
+ *
+ * @example
+ * ```tsx
+ * const { showPopup, closePopup, dismissForever } = useExitIntent({
+ *   cooldown: 86400000, // 24시간
+ *   delay: 5000,        // 5초 후 활성화
+ *   storageKey: 'my-popup',
+ * });
+ *
+ * if (showPopup) {
+ *   return <Modal onClose={closePopup} onDismiss={dismissForever} />;
+ * }
+ * ```
+ */
+export declare function useExitIntent(options?: UseExitIntentOptions): UseExitIntentReturn;

package/dist/hooks/useExitIntent.js

@@ -0,0 +1,72 @@
+"use client";
+import "../chunk-ORMEWXMH.js";
+
+// src/hooks/useExitIntent.ts
+import { useState, useEffect, useCallback, useRef } from "react";
+var DEFAULT_COOLDOWN = 24 * 60 * 60 * 1e3;
+var DEFAULT_DELAY = 5e3;
+var DEFAULT_STORAGE_KEY = "exit-intent-popup";
+function useExitIntent(options = {}) {
+  const {
+    cooldown = DEFAULT_COOLDOWN,
+    delay = DEFAULT_DELAY,
+    storageKey = DEFAULT_STORAGE_KEY,
+    disabled = false
+  } = options;
+  const [showPopup, setShowPopup] = useState(false);
+  const hasTriggered = useRef(false);
+  const isReady = useRef(false);
+  const canShowPopup = useCallback(() => {
+    if (typeof window === "undefined") return false;
+    const lastShown = localStorage.getItem(`${storageKey}-last-shown`);
+    const isDismissed = localStorage.getItem(`${storageKey}-dismissed`) === "true";
+    if (isDismissed) return false;
+    if (!lastShown) return true;
+    const timeSinceLastShown = Date.now() - parseInt(lastShown, 10);
+    return timeSinceLastShown >= cooldown;
+  }, [storageKey, cooldown]);
+  const triggerPopup = useCallback(() => {
+    if (hasTriggered.current || !isReady.current || disabled) return;
+    if (!canShowPopup()) return;
+    hasTriggered.current = true;
+    setShowPopup(true);
+    localStorage.setItem(`${storageKey}-last-shown`, Date.now().toString());
+  }, [canShowPopup, storageKey, disabled]);
+  const closePopup = useCallback(() => {
+    setShowPopup(false);
+  }, []);
+  const dismissForever = useCallback(() => {
+    localStorage.setItem(`${storageKey}-dismissed`, "true");
+    setShowPopup(false);
+  }, [storageKey]);
+  useEffect(() => {
+    if (disabled) return;
+    const delayTimer = setTimeout(() => {
+      isReady.current = true;
+    }, delay);
+    const handleMouseLeave = (e) => {
+      if (e.clientY < 10 && isReady.current) {
+        triggerPopup();
+      }
+    };
+    const handleVisibilityChange = () => {
+      if (document.visibilityState === "hidden" && isReady.current) {
+      }
+    };
+    document.addEventListener("mouseleave", handleMouseLeave);
+    document.addEventListener("visibilitychange", handleVisibilityChange);
+    return () => {
+      clearTimeout(delayTimer);
+      document.removeEventListener("mouseleave", handleMouseLeave);
+      document.removeEventListener("visibilitychange", handleVisibilityChange);
+    };
+  }, [delay, disabled, triggerPopup]);
+  return {
+    showPopup,
+    closePopup,
+    dismissForever
+  };
+}
+export {
+  useExitIntent
+};

package/dist/hooks/useTimezone.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 사용자 타임존 정보를 관리하는 Hook
+ */
+export declare function useTimezone(): {
+    isLoading: boolean;
+    refreshTimezone: () => void;
+    timezone: string;
+    offset: number;
+    offsetFormatted: string;
+};
+/**
+ * 타임존 정보를 간단하게 표시하는 Hook
+ */
+export declare function useSimpleTimezone(): {
+    timezone: string;
+    offsetFormatted: string;
+    isLoading: boolean;
+    display: string;
+};

package/dist/hooks/useTimezone.js

@@ -0,0 +1,11 @@
+"use client";
+import {
+  useSimpleTimezone,
+  useTimezone
+} from "../chunk-EZC6ETFW.js";
+import "../chunk-TRBKJ7JT.js";
+import "../chunk-ORMEWXMH.js";
+export {
+  useSimpleTimezone,
+  useTimezone
+};

package/dist/logger/logger.d.ts

@@ -0,0 +1,11 @@
+import winston from 'winston';
+declare global {
+    var __maxListenersSet: boolean | undefined;
+    var __winstonLoggerInstance: winston.Logger | undefined;
+}
+export declare const logger: winston.Logger;
+export declare function logDebug(message: string, meta?: any): void;
+export declare function logInfo(message: string, meta?: any): void;
+export declare function logError(message: string, meta?: any): void;
+export declare function logApiRequest(request: Request, extra?: Record<string, any>): void;
+export declare function logApiResponse(request: Request, response: Response, extra?: Record<string, any>): void;

package/dist/logger/logger.js

@@ -0,0 +1,17 @@
+import {
+  logApiRequest,
+  logApiResponse,
+  logDebug,
+  logError,
+  logInfo,
+  logger
+} from "../chunk-EZR55KV2.js";
+import "../chunk-ORMEWXMH.js";
+export {
+  logApiRequest,
+  logApiResponse,
+  logDebug,
+  logError,
+  logInfo,
+  logger
+};