@wheeparam/library 0.0.1

package/dist/api/index.cjs

@@ -0,0 +1,89 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/api/index.ts
+var api_exports = {};
+__export(api_exports, {
+  defineRoutes: () => defineRoutes,
+  matchRoute: () => matchRoute,
+  routeResponse: () => routeResponse
+});
+module.exports = __toCommonJS(api_exports);
+
+// src/api/types.ts
+function defineRoutes(routes) {
+  return routes;
+}
+
+// src/api/route.ts
+function parseParamToken(segment) {
+  if (/^\[[^.[\]]+\]$/.test(segment)) return { kind: "single", key: segment.slice(1, -1) };
+  if (/^\[\.\.\.[^\]]+\]$/.test(segment)) return { kind: "catchAll", key: segment.slice(4, -1) };
+  if (/^\[\[\.\.\.[^\]]+\]\]$/.test(segment)) return { kind: "optionalCatchAll", key: segment.slice(5, -2) };
+  return null;
+}
+function matchRoute(path, slug) {
+  const parts = path.split("/").filter(Boolean);
+  const params = {};
+  let i = 0;
+  let j = 0;
+  while (i < parts.length) {
+    const seg = parts[i];
+    const token = parseParamToken(seg);
+    if (!token) {
+      if (j >= slug.length) return null;
+      if (seg !== slug[j]) return null;
+      i++;
+      j++;
+      continue;
+    }
+    if (token.kind === "single") {
+      if (j >= slug.length) return null;
+      params[token.key] = slug[j];
+      i++;
+      j++;
+      continue;
+    }
+    if (token.kind === "catchAll") {
+      if (j >= slug.length) return null;
+      params[token.key] = slug.slice(j);
+      return { params };
+    }
+    if (j >= slug.length) return { params };
+    params[token.key] = slug.slice(j);
+    return { params };
+  }
+  if (j !== slug.length) return null;
+  return { params };
+}
+async function routeResponse(slug, routes, request) {
+  for (const route of routes) {
+    const matched = matchRoute(route.path, slug);
+    if (!matched) continue;
+    const res = await route.handler(request, matched.params);
+    return res;
+  }
+  return Response.json({ error: "Not Found" }, { status: 404 });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defineRoutes,
+  matchRoute,
+  routeResponse
+});

package/dist/api/index.d.cts

@@ -0,0 +1,124 @@
+import { NextResponse, NextRequest } from 'next/server';
+
+/**
+ * @packageDocumentation
+ * Next.js Route Handler 유틸에서 사용하는 타입/헬퍼 모음
+ *
+ * - path 문자열("users/[id]")로부터 params 타입을 추론하여 DX를 높인다.
+ * - defineRoutes()로 routes 배열의 path literal을 유지한다.
+ */
+
+type Merge<A, B> = A & B;
+/**
+ * 단일 path segment에서 params 타입을 추출한다.
+ *
+ * 지원 패턴:
+ * - [id]           -> { id: string }
+ * - [...rest]      -> { rest: string[] }
+ * - [[...rest]]    -> { rest?: string[] }
+ */
+type ExtractSegmentParam<S extends string> = S extends `[[...${infer K}]]` ? {
+    [P in K]?: string[];
+} : S extends `[...${infer K}]` ? {
+    [P in K]: string[];
+} : S extends `[${infer K}]` ? {
+    [P in K]: string;
+} : {};
+/**
+ * path 문자열로부터 params 타입을 재귀적으로 추론한다.
+ *
+ * @example
+ * type P1 = ParamsFromPath<"users/[id]">              // { id: string }
+ * type P2 = ParamsFromPath<"files/[...path]">         // { path: string[] }
+ * type P3 = ParamsFromPath<"docs/[[...slug]]">        // { slug?: string[] }
+ * type P4 = ParamsFromPath<"a/[id]/b/[postId]">       // { id: string; postId: string }
+ */
+type ParamsFromPath<Path extends string> = Path extends `${infer Head}/${infer Tail}` ? Merge<ExtractSegmentParam<Head>, ParamsFromPath<Tail>> : ExtractSegmentParam<Path>;
+/**
+ * Next.js Route Handler 타입
+ *
+ * - Request(표준) / NextRequest 모두 지원한다.
+ * - params는 path로부터 자동 추론된다.
+ *
+ * @example
+ * const r: Route<"users/[id]"> = {
+ *   path: "users/[id]",
+ *   handler: async (_req, params) => Response.json({ id: params.id })
+ * }
+ */
+type RouteHandler<Path extends string> = ((request: Request, params: ParamsFromPath<Path>) => Promise<Response | NextResponse>) | ((request: NextRequest, params: ParamsFromPath<Path>) => Promise<Response | NextResponse>);
+/**
+ * 라우팅 정의 객체
+ *
+ * @example
+ * const route: Route<"users/[id]"> = {
+ *   path: "users/[id]",
+ *   handler: async (_req, params) => Response.json({ id: params.id })
+ * }
+ */
+type Route<Path extends string = string> = {
+    path: Path;
+    handler: RouteHandler<Path>;
+};
+/**
+ * routes 배열의 path literal을 유지하기 위한 identity helper
+ *
+ * TS가 배열 리터럴을 `string`으로 넓혀버리는 것을 방지하여,
+ * handler의 params 타입 추론이 끝까지 유지된다.
+ *
+ * @example
+ * const routes = defineRoutes([
+ *   { path: "users/[id]", handler: async (_req, p) => Response.json({ id: p.id }) }
+ * ] as const)
+ */
+declare function defineRoutes<const R extends readonly Route<string>[]>(routes: R): R;
+
+/**
+ * @packageDocumentation
+ * slug 배열과 route 패턴을 매칭하여 handler를 호출하는 라우팅 유틸
+ *
+ * 지원 패턴:
+ * - 정적 경로: "health"
+ * - 단일 파라미터: "users/[id]"
+ * - catch-all: "files/[...path]"
+ * - optional catch-all: "docs/[[...slug]]"
+ */
+
+type MatchResult = {
+    params: Record<string, string | string[]>;
+};
+/**
+ * 특정 route path 패턴이 slug와 매칭되는지 검사하고 params를 반환한다.
+ *
+ * @param path route 패턴 (예: "users/[id]", "docs/[[...slug]]")
+ * @param slug URL 경로 배열 (예: ["users","10"])
+ * @returns 매칭되면 params, 아니면 null
+ *
+ * @example
+ * matchRoute("users/[id]", ["users","10"]) // { params: { id: "10" } }
+ * matchRoute("docs/[[...slug]]", ["docs"]) // { params: {} }
+ * matchRoute("files/[...path]", ["files","a","b"]) // { params: { path: ["a","b"] } }
+ */
+declare function matchRoute(path: string, slug: string[]): MatchResult | null;
+/**
+ * 슬러그 기반 라우팅을 처리한다.
+ *
+ * 정의된 routes 목록에서 slug와 일치하는 handler를 찾아 실행한다.
+ * 매칭되는 route가 없으면 404 JSON 응답을 반환한다.
+ *
+ * @param slug URL 경로 배열
+ * @param routes 라우팅 정의 목록
+ * @param request Request 객체
+ * @returns handler가 반환한 Response (또는 404 Response)
+ *
+ * @example
+ * const routes = defineRoutes([
+ *   { path: "health", handler: async () => Response.json({ ok: true }) },
+ *   { path: "users/[id]", handler: async (_req, p) => Response.json({ id: p.id }) },
+ * ] as const)
+ *
+ * return routeResponse(slug, routes, request)
+ */
+declare function routeResponse(slug: string[], routes: readonly Route<string>[], request: Request): Promise<Response>;
+
+export { type ParamsFromPath, type Route, type RouteHandler, defineRoutes, matchRoute, routeResponse };

package/dist/api/index.d.ts

@@ -0,0 +1,124 @@
+import { NextResponse, NextRequest } from 'next/server';
+
+/**
+ * @packageDocumentation
+ * Next.js Route Handler 유틸에서 사용하는 타입/헬퍼 모음
+ *
+ * - path 문자열("users/[id]")로부터 params 타입을 추론하여 DX를 높인다.
+ * - defineRoutes()로 routes 배열의 path literal을 유지한다.
+ */
+
+type Merge<A, B> = A & B;
+/**
+ * 단일 path segment에서 params 타입을 추출한다.
+ *
+ * 지원 패턴:
+ * - [id]           -> { id: string }
+ * - [...rest]      -> { rest: string[] }
+ * - [[...rest]]    -> { rest?: string[] }
+ */
+type ExtractSegmentParam<S extends string> = S extends `[[...${infer K}]]` ? {
+    [P in K]?: string[];
+} : S extends `[...${infer K}]` ? {
+    [P in K]: string[];
+} : S extends `[${infer K}]` ? {
+    [P in K]: string;
+} : {};
+/**
+ * path 문자열로부터 params 타입을 재귀적으로 추론한다.
+ *
+ * @example
+ * type P1 = ParamsFromPath<"users/[id]">              // { id: string }
+ * type P2 = ParamsFromPath<"files/[...path]">         // { path: string[] }
+ * type P3 = ParamsFromPath<"docs/[[...slug]]">        // { slug?: string[] }
+ * type P4 = ParamsFromPath<"a/[id]/b/[postId]">       // { id: string; postId: string }
+ */
+type ParamsFromPath<Path extends string> = Path extends `${infer Head}/${infer Tail}` ? Merge<ExtractSegmentParam<Head>, ParamsFromPath<Tail>> : ExtractSegmentParam<Path>;
+/**
+ * Next.js Route Handler 타입
+ *
+ * - Request(표준) / NextRequest 모두 지원한다.
+ * - params는 path로부터 자동 추론된다.
+ *
+ * @example
+ * const r: Route<"users/[id]"> = {
+ *   path: "users/[id]",
+ *   handler: async (_req, params) => Response.json({ id: params.id })
+ * }
+ */
+type RouteHandler<Path extends string> = ((request: Request, params: ParamsFromPath<Path>) => Promise<Response | NextResponse>) | ((request: NextRequest, params: ParamsFromPath<Path>) => Promise<Response | NextResponse>);
+/**
+ * 라우팅 정의 객체
+ *
+ * @example
+ * const route: Route<"users/[id]"> = {
+ *   path: "users/[id]",
+ *   handler: async (_req, params) => Response.json({ id: params.id })
+ * }
+ */
+type Route<Path extends string = string> = {
+    path: Path;
+    handler: RouteHandler<Path>;
+};
+/**
+ * routes 배열의 path literal을 유지하기 위한 identity helper
+ *
+ * TS가 배열 리터럴을 `string`으로 넓혀버리는 것을 방지하여,
+ * handler의 params 타입 추론이 끝까지 유지된다.
+ *
+ * @example
+ * const routes = defineRoutes([
+ *   { path: "users/[id]", handler: async (_req, p) => Response.json({ id: p.id }) }
+ * ] as const)
+ */
+declare function defineRoutes<const R extends readonly Route<string>[]>(routes: R): R;
+
+/**
+ * @packageDocumentation
+ * slug 배열과 route 패턴을 매칭하여 handler를 호출하는 라우팅 유틸
+ *
+ * 지원 패턴:
+ * - 정적 경로: "health"
+ * - 단일 파라미터: "users/[id]"
+ * - catch-all: "files/[...path]"
+ * - optional catch-all: "docs/[[...slug]]"
+ */
+
+type MatchResult = {
+    params: Record<string, string | string[]>;
+};
+/**
+ * 특정 route path 패턴이 slug와 매칭되는지 검사하고 params를 반환한다.
+ *
+ * @param path route 패턴 (예: "users/[id]", "docs/[[...slug]]")
+ * @param slug URL 경로 배열 (예: ["users","10"])
+ * @returns 매칭되면 params, 아니면 null
+ *
+ * @example
+ * matchRoute("users/[id]", ["users","10"]) // { params: { id: "10" } }
+ * matchRoute("docs/[[...slug]]", ["docs"]) // { params: {} }
+ * matchRoute("files/[...path]", ["files","a","b"]) // { params: { path: ["a","b"] } }
+ */
+declare function matchRoute(path: string, slug: string[]): MatchResult | null;
+/**
+ * 슬러그 기반 라우팅을 처리한다.
+ *
+ * 정의된 routes 목록에서 slug와 일치하는 handler를 찾아 실행한다.
+ * 매칭되는 route가 없으면 404 JSON 응답을 반환한다.
+ *
+ * @param slug URL 경로 배열
+ * @param routes 라우팅 정의 목록
+ * @param request Request 객체
+ * @returns handler가 반환한 Response (또는 404 Response)
+ *
+ * @example
+ * const routes = defineRoutes([
+ *   { path: "health", handler: async () => Response.json({ ok: true }) },
+ *   { path: "users/[id]", handler: async (_req, p) => Response.json({ id: p.id }) },
+ * ] as const)
+ *
+ * return routeResponse(slug, routes, request)
+ */
+declare function routeResponse(slug: string[], routes: readonly Route<string>[], request: Request): Promise<Response>;
+
+export { type ParamsFromPath, type Route, type RouteHandler, defineRoutes, matchRoute, routeResponse };

package/dist/api/index.js

@@ -0,0 +1,60 @@
+// src/api/types.ts
+function defineRoutes(routes) {
+  return routes;
+}
+
+// src/api/route.ts
+function parseParamToken(segment) {
+  if (/^\[[^.[\]]+\]$/.test(segment)) return { kind: "single", key: segment.slice(1, -1) };
+  if (/^\[\.\.\.[^\]]+\]$/.test(segment)) return { kind: "catchAll", key: segment.slice(4, -1) };
+  if (/^\[\[\.\.\.[^\]]+\]\]$/.test(segment)) return { kind: "optionalCatchAll", key: segment.slice(5, -2) };
+  return null;
+}
+function matchRoute(path, slug) {
+  const parts = path.split("/").filter(Boolean);
+  const params = {};
+  let i = 0;
+  let j = 0;
+  while (i < parts.length) {
+    const seg = parts[i];
+    const token = parseParamToken(seg);
+    if (!token) {
+      if (j >= slug.length) return null;
+      if (seg !== slug[j]) return null;
+      i++;
+      j++;
+      continue;
+    }
+    if (token.kind === "single") {
+      if (j >= slug.length) return null;
+      params[token.key] = slug[j];
+      i++;
+      j++;
+      continue;
+    }
+    if (token.kind === "catchAll") {
+      if (j >= slug.length) return null;
+      params[token.key] = slug.slice(j);
+      return { params };
+    }
+    if (j >= slug.length) return { params };
+    params[token.key] = slug.slice(j);
+    return { params };
+  }
+  if (j !== slug.length) return null;
+  return { params };
+}
+async function routeResponse(slug, routes, request) {
+  for (const route of routes) {
+    const matched = matchRoute(route.path, slug);
+    if (!matched) continue;
+    const res = await route.handler(request, matched.params);
+    return res;
+  }
+  return Response.json({ error: "Not Found" }, { status: 404 });
+}
+export {
+  defineRoutes,
+  matchRoute,
+  routeResponse
+};

package/dist/client/index.cjs

@@ -0,0 +1,205 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/client/index.ts
+var client_exports = {};
+__export(client_exports, {
+  createAxiosClient: () => createAxiosClient
+});
+module.exports = __toCommonJS(client_exports);
+
+// src/client/axios.ts
+var import_axios = __toESM(require("axios"), 1);
+function createLocalStorageTokenAccess(keys) {
+  const accessTokenKey = keys?.accessTokenKey ?? "accessToken";
+  const refreshTokenKey = keys?.refreshTokenKey ?? "refreshToken";
+  return {
+    get() {
+      return {
+        accessToken: window.localStorage.getItem(accessTokenKey),
+        refreshToken: window.localStorage.getItem(refreshTokenKey)
+      };
+    },
+    set(data) {
+      if (data.accessToken !== void 0) {
+        window.localStorage.setItem(accessTokenKey, data.accessToken ?? "");
+      }
+      if (data.refreshToken !== void 0) {
+        window.localStorage.setItem(refreshTokenKey, data.refreshToken ?? "");
+      }
+    },
+    clear() {
+      window.localStorage.removeItem(accessTokenKey);
+      window.localStorage.removeItem(refreshTokenKey);
+    }
+  };
+}
+function createCookieModeTokenAccess(keys) {
+  const refreshTokenKey = keys?.refreshTokenKey ?? "refreshToken";
+  return {
+    get() {
+      return {
+        accessToken: null,
+        // 쿠키 기반이면 JS에서 accessToken을 직접 읽지 않는 전제를 둔다.
+        refreshToken: window.localStorage.getItem(refreshTokenKey)
+      };
+    },
+    set(data) {
+      if (data.refreshToken !== void 0) {
+        window.localStorage.setItem(refreshTokenKey, data.refreshToken ?? "");
+      }
+    },
+    clear() {
+      window.localStorage.removeItem(refreshTokenKey);
+    }
+  };
+}
+function createAxiosClient(options) {
+  const {
+    baseURL,
+    timeout = 1e4,
+    withCredentials = true,
+    refreshUrl,
+    storage = "localStorage",
+    storageKeys,
+    onAuthStateChange,
+    onError,
+    getErrorMessage
+  } = options;
+  const instance = import_axios.default.create({ baseURL, timeout, withCredentials });
+  const tokenAccess = storage === "localStorage" ? createLocalStorageTokenAccess(storageKeys) : createCookieModeTokenAccess({ refreshTokenKey: storageKeys?.refreshTokenKey });
+  let isRefreshing = false;
+  let subscribers = [];
+  const notifySubscribers = (token) => {
+    subscribers.forEach((cb) => cb(token));
+    subscribers = [];
+  };
+  const clearAuth = () => {
+    tokenAccess.clear();
+    onAuthStateChange?.("unauthenticated");
+  };
+  const requestRefresh = async (refreshToken) => {
+    const res = await fetch(refreshUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ refreshToken }),
+      credentials: withCredentials ? "include" : "same-origin"
+    });
+    if (!res.ok) {
+      throw new Error("Token refresh failed");
+    }
+    return await res.json();
+  };
+  instance.interceptors.request.use(
+    (config) => {
+      const { accessToken } = tokenAccess.get();
+      if (accessToken) {
+        config.headers = config.headers ?? {};
+        config.headers.Authorization = `Bearer ${accessToken}`;
+      }
+      return config;
+    },
+    (e) => Promise.reject(e)
+  );
+  instance.interceptors.response.use(
+    (res) => res,
+    async (error) => {
+      const response = error.response;
+      const status = response?.status;
+      const originalRequest = error.config ?? {};
+      if (status !== 401) {
+        let message = getErrorMessage?.(error) ?? response?.data?.error ?? "";
+        if (!message && typeof status === "number") {
+          switch (status) {
+            case 0:
+              message = "REST API \uC11C\uBC84\uC5D0 \uC811\uADFC\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4\n\uC11C\uBC84 \uAD00\uB9AC\uC790\uC5D0\uAC8C \uBB38\uC758\uD558\uC138\uC694";
+              break;
+            case 400:
+              message = "\uC798\uBABB\uB41C \uC694\uCCAD\uC785\uB2C8\uB2E4.";
+              break;
+            case 404:
+              message = "[404] REST API \uC694\uCCAD\uC5D0 \uC2E4\uD328\uD558\uC600\uC2B5\uB2C8\uB2E4";
+              break;
+            case 500:
+              message = "\uC11C\uBC84\uC5D0\uC11C \uCC98\uB9AC \uC911 \uC624\uB958\uAC00 \uBC1C\uC0DD\uD558\uC600\uC2B5\uB2C8\uB2E4.";
+              break;
+          }
+        }
+        if (message) onError?.(message, error);
+        return Promise.reject(error);
+      }
+      if (originalRequest._retry) {
+        clearAuth();
+        return Promise.reject(error);
+      }
+      originalRequest._retry = true;
+      const { refreshToken } = tokenAccess.get();
+      if (!refreshToken) {
+        clearAuth();
+        return Promise.reject(error);
+      }
+      if (isRefreshing) {
+        return new Promise((resolve, reject) => {
+          subscribers.push((newToken) => {
+            if (!newToken) return reject(error);
+            originalRequest.headers = originalRequest.headers ?? {};
+            originalRequest.headers.Authorization = `Bearer ${newToken}`;
+            resolve(instance(originalRequest));
+          });
+        });
+      }
+      isRefreshing = true;
+      try {
+        const newTokens = await requestRefresh(refreshToken);
+        tokenAccess.set(newTokens);
+        onAuthStateChange?.("authenticated");
+        isRefreshing = false;
+        notifySubscribers(newTokens.accessToken);
+        originalRequest.headers = originalRequest.headers ?? {};
+        originalRequest.headers.Authorization = `Bearer ${newTokens.accessToken}`;
+        return instance(originalRequest);
+      } catch (e) {
+        isRefreshing = false;
+        notifySubscribers(null);
+        clearAuth();
+        return Promise.reject(error);
+      }
+    }
+  );
+  return {
+    axios: instance,
+    setToken: (data) => tokenAccess.set(data),
+    getToken: () => tokenAccess.get(),
+    clearToken: () => clearAuth()
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAxiosClient
+});