@gomjellie/lazyapi 0.0.1

package/dist/store/appSlice.js

@@ -0,0 +1,144 @@
+/**
+ * 애플리케이션 Redux Slice
+ */
+import { createSlice } from '@reduxjs/toolkit';
+// 초기 상태
+const initialState = {
+    document: null,
+    endpoints: [],
+    screen: 'LIST',
+    mode: 'NORMAL',
+    list: {
+        selectedIndex: 0,
+        filteredEndpoints: [],
+        activeFilter: 'ALL',
+        activeTag: null,
+        focus: 'LIST',
+        selectedTagIndex: 0,
+        searchQuery: '',
+        tagSearchQuery: '',
+        scrollOffset: 0,
+    },
+    detail: null,
+    error: null,
+    loading: false,
+    commandInput: '',
+};
+const appSlice = createSlice({
+    name: 'app',
+    initialState,
+    reducers: {
+        setDocument: (state, action) => {
+            state.document = action.payload;
+        },
+        setEndpoints: (state, action) => {
+            state.endpoints = action.payload;
+            state.list.filteredEndpoints = action.payload;
+        },
+        setScreen: (state, action) => {
+            state.screen = action.payload;
+        },
+        setMode: (state, action) => {
+            state.mode = action.payload;
+            if (action.payload === 'COMMAND') {
+                state.commandInput = '';
+            }
+        },
+        setCommandInput: (state, action) => {
+            state.commandInput = action.payload;
+        },
+        setError: (state, action) => {
+            state.error = action.payload;
+            state.loading = false;
+        },
+        setLoading: (state, action) => {
+            state.loading = action.payload;
+        },
+        listSelect: (state, action) => {
+            state.list.selectedIndex = Math.max(0, Math.min(action.payload, state.list.filteredEndpoints.length - 1));
+        },
+        listSetFilter: (state, action) => {
+            state.list.activeFilter = action.payload;
+            state.list.selectedIndex = 0;
+        },
+        listSetTag: (state, action) => {
+            state.list.activeTag = action.payload;
+            state.list.selectedIndex = 0;
+        },
+        listSetFocus: (state, action) => {
+            state.list.focus = action.payload;
+        },
+        listSelectTag: (state, action) => {
+            state.list.selectedTagIndex = action.payload;
+        },
+        listSetSearch: (state, action) => {
+            state.list.searchQuery = action.payload;
+            state.list.selectedIndex = 0;
+        },
+        listSetTagSearch: (state, action) => {
+            state.list.tagSearchQuery = action.payload;
+            state.list.selectedTagIndex = 0;
+        },
+        listScroll: (state, action) => {
+            state.list.scrollOffset = action.payload;
+        },
+        detailSet: (state, action) => {
+            const endpoint = action.payload;
+            state.screen = 'DETAIL';
+            state.detail = {
+                endpoint,
+                focusedFieldIndex: 0,
+                parameterValues: {},
+                requestBody: '',
+                headers: {},
+                activePanel: 'left',
+                activeRequestTab: 'headers',
+                activeResponseTab: 'body',
+                response: null,
+            };
+        },
+        detailSetFocus: (state, action) => {
+            if (state.detail) {
+                state.detail.focusedFieldIndex = action.payload;
+            }
+        },
+        detailSetParam: (state, action) => {
+            if (state.detail) {
+                state.detail.parameterValues[action.payload.key] = action.payload.value;
+            }
+        },
+        detailSetBody: (state, action) => {
+            if (state.detail) {
+                state.detail.requestBody = action.payload;
+            }
+        },
+        detailSetHeader: (state, action) => {
+            if (state.detail) {
+                state.detail.headers[action.payload.key] = action.payload.value;
+            }
+        },
+        detailSetPanel: (state, action) => {
+            if (state.detail) {
+                state.detail.activePanel = action.payload;
+            }
+        },
+        detailSetRequestTab: (state, action) => {
+            if (state.detail) {
+                state.detail.activeRequestTab = action.payload;
+            }
+        },
+        detailSetResponseTab: (state, action) => {
+            if (state.detail) {
+                state.detail.activeResponseTab = action.payload;
+            }
+        },
+        detailSetResponse: (state, action) => {
+            if (state.detail) {
+                state.detail.response = action.payload;
+            }
+        },
+        reset: () => initialState,
+    },
+});
+export const { setDocument, setEndpoints, setScreen, setMode, setCommandInput, setError, setLoading, listSelect, listSetFilter, listSetTag, listSetFocus, listSelectTag, listSetSearch, listSetTagSearch, listScroll, detailSet, detailSetFocus, detailSetParam, detailSetBody, detailSetHeader, detailSetPanel, detailSetRequestTab, detailSetResponseTab, detailSetResponse, reset, } = appSlice.actions;
+export default appSlice.reducer;

package/dist/store/hooks.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 타입이 지정된 Redux hooks
+ */
+export declare const useAppDispatch: import("react-redux").UseDispatch<import("@reduxjs/toolkit").ThunkDispatch<{
+    app: import("../types/app-state.js").AppState;
+}, undefined, import("@reduxjs/toolkit").UnknownAction> & import("@reduxjs/toolkit").Dispatch<import("@reduxjs/toolkit").UnknownAction>>;
+export declare const useAppSelector: import("react-redux").UseSelector<{
+    app: import("../types/app-state.js").AppState;
+}>;

package/dist/store/hooks.js

@@ -0,0 +1,7 @@
+/**
+ * 타입이 지정된 Redux hooks
+ */
+import { useDispatch, useSelector } from 'react-redux';
+// 타입이 지정된 useDispatch와 useSelector
+export const useAppDispatch = useDispatch.withTypes();
+export const useAppSelector = useSelector.withTypes();

package/dist/store/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Redux Store 설정
+ */
+export declare const store: import("@reduxjs/toolkit").EnhancedStore<{
+    app: import("../types/app-state.js").AppState;
+}, import("@reduxjs/toolkit").UnknownAction, import("@reduxjs/toolkit").Tuple<[import("@reduxjs/toolkit").StoreEnhancer<{
+    dispatch: import("@reduxjs/toolkit").ThunkDispatch<{
+        app: import("../types/app-state.js").AppState;
+    }, undefined, import("@reduxjs/toolkit").UnknownAction>;
+}>, import("@reduxjs/toolkit").StoreEnhancer]>>;
+export type RootState = ReturnType<typeof store.getState>;
+export type AppDispatch = typeof store.dispatch;

package/dist/store/index.js

@@ -0,0 +1,12 @@
+/**
+ * Redux Store 설정
+ */
+import { configureStore } from '@reduxjs/toolkit';
+import appReducer from './appSlice.js';
+export const store = configureStore({
+    reducer: {
+        app: appReducer,
+    },
+    // DevTools는 개발 환경에서만 활성화 (기본값)
+    devTools: process.env.NODE_ENV !== 'production',
+});

package/dist/types/app-state.d.ts

@@ -0,0 +1,126 @@
+/**
+ * 애플리케이션 상태 타입 정의
+ */
+import { Endpoint, HttpMethod, OpenAPIDocument } from './openapi.js';
+export type AppMode = 'NORMAL' | 'INSERT' | 'SEARCH' | 'TAG_SEARCH' | 'COMMAND';
+export type Screen = 'LIST' | 'DETAIL';
+export interface AppState {
+    document: OpenAPIDocument | null;
+    endpoints: Endpoint[];
+    screen: Screen;
+    mode: AppMode;
+    commandInput: string;
+    list: ListViewState;
+    detail: DetailViewState | null;
+    error: string | null;
+    loading: boolean;
+}
+export interface ListViewState {
+    selectedIndex: number;
+    filteredEndpoints: Endpoint[];
+    activeFilter: HttpMethod | 'ALL';
+    activeTag: string | null;
+    focus: 'TAGS' | 'LIST';
+    selectedTagIndex: number;
+    searchQuery: string;
+    tagSearchQuery: string;
+    scrollOffset: number;
+}
+export interface DetailViewState {
+    endpoint: Endpoint;
+    focusedFieldIndex: number;
+    parameterValues: Record<string, string>;
+    requestBody: string;
+    headers: Record<string, string>;
+    activePanel: 'left' | 'request' | 'response';
+    activeRequestTab: 'headers' | 'body' | 'query';
+    activeResponseTab: 'body' | 'headers' | 'cookies' | 'curl';
+    response: ApiResponse | null;
+}
+export interface ApiResponse {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: unknown;
+    size: number;
+    duration: number;
+    cookies?: Record<string, string>;
+}
+export type AppAction = {
+    type: 'SET_DOCUMENT';
+    payload: OpenAPIDocument;
+} | {
+    type: 'SET_ENDPOINTS';
+    payload: Endpoint[];
+} | {
+    type: 'SET_SCREEN';
+    payload: Screen;
+} | {
+    type: 'SET_MODE';
+    payload: AppMode;
+} | {
+    type: 'SET_ERROR';
+    payload: string | null;
+} | {
+    type: 'SET_LOADING';
+    payload: boolean;
+} | {
+    type: 'LIST_SELECT';
+    payload: number;
+} | {
+    type: 'LIST_SET_FILTER';
+    payload: HttpMethod | 'ALL';
+} | {
+    type: 'LIST_SET_TAG';
+    payload: string | null;
+} | {
+    type: 'LIST_SET_FOCUS';
+    payload: 'TAGS' | 'LIST';
+} | {
+    type: 'LIST_SELECT_TAG';
+    payload: number;
+} | {
+    type: 'LIST_SET_SEARCH';
+    payload: string;
+} | {
+    type: 'LIST_SET_TAG_SEARCH';
+    payload: string;
+} | {
+    type: 'LIST_SCROLL';
+    payload: number;
+} | {
+    type: 'DETAIL_SET';
+    payload: Endpoint;
+} | {
+    type: 'DETAIL_SET_FOCUS';
+    payload: number;
+} | {
+    type: 'DETAIL_SET_PARAM';
+    payload: {
+        key: string;
+        value: string;
+    };
+} | {
+    type: 'DETAIL_SET_BODY';
+    payload: string;
+} | {
+    type: 'DETAIL_SET_HEADER';
+    payload: {
+        key: string;
+        value: string;
+    };
+} | {
+    type: 'DETAIL_SET_PANEL';
+    payload: 'left' | 'request' | 'response';
+} | {
+    type: 'DETAIL_SET_REQUEST_TAB';
+    payload: 'headers' | 'body' | 'query';
+} | {
+    type: 'DETAIL_SET_RESPONSE_TAB';
+    payload: 'body' | 'headers' | 'cookies' | 'curl';
+} | {
+    type: 'DETAIL_SET_RESPONSE';
+    payload: ApiResponse | null;
+} | {
+    type: 'RESET';
+};

package/dist/types/app-state.js

@@ -0,0 +1,4 @@
+/**
+ * 애플리케이션 상태 타입 정의
+ */
+export {};

package/dist/types/openapi.d.ts

@@ -0,0 +1,86 @@
+/**
+ * OpenAPI 타입 정의
+ * openapi-types 패키지를 재수출하고 애플리케이션별 타입을 정의합니다.
+ */
+import type { OpenAPI, OpenAPIV2, OpenAPIV3, OpenAPIV3_1 } from 'openapi-types';
+export type { OpenAPI, OpenAPIV2, OpenAPIV3, OpenAPIV3_1 };
+export type OpenAPIDocument = OpenAPI.Document;
+export type PathItemObject = OpenAPIV3_1.PathItemObject | OpenAPIV3.PathItemObject | OpenAPIV2.PathItemObject;
+export type OperationObject = OpenAPIV3_1.OperationObject | OpenAPIV3.OperationObject | OpenAPIV2.OperationObject;
+export type ParameterObject = OpenAPIV3_1.ParameterObject | OpenAPIV3.ParameterObject | OpenAPIV2.Parameter;
+export type RequestBodyObject = OpenAPIV3_1.RequestBodyObject | OpenAPIV3.RequestBodyObject;
+export type ResponseObject = OpenAPIV3_1.ResponseObject | OpenAPIV3.ResponseObject | OpenAPIV2.ResponseObject;
+export type SchemaObject = OpenAPIV3_1.SchemaObject | OpenAPIV3.SchemaObject | OpenAPIV2.SchemaObject;
+export type ReferenceObject = OpenAPIV3_1.ReferenceObject | OpenAPIV3.ReferenceObject | OpenAPIV2.ReferenceObject;
+export type ResponsesObject = OpenAPIV3_1.ResponsesObject | OpenAPIV3.ResponsesObject | OpenAPIV2.ResponsesObject;
+export type MediaTypeObject = OpenAPIV3_1.MediaTypeObject | OpenAPIV3.MediaTypeObject;
+export type SecurityRequirementObject = OpenAPIV3_1.SecurityRequirementObject | OpenAPIV3.SecurityRequirementObject | OpenAPIV2.SecurityRequirementObject;
+export type PathItem = PathItemObject;
+export type Operation = OperationObject;
+export type Parameter = ParameterObject;
+export type RequestBody = RequestBodyObject;
+export type Response = ResponseObject;
+export type Schema = SchemaObject;
+export declare function isOpenAPIV2Document(doc: OpenAPIDocument): doc is OpenAPIV2.Document;
+export declare function isOpenAPIV3Document(doc: OpenAPIDocument): doc is OpenAPIV3.Document;
+export declare function isOpenAPIV3_1Document(doc: OpenAPIDocument): doc is OpenAPIV3_1.Document;
+export declare function isReferenceObject(obj: any): obj is ReferenceObject;
+export declare function isSchemaObject(obj: any): obj is SchemaObject;
+export declare function isParameterObject(obj: any): obj is ParameterObject;
+export declare function isRequestBodyObject(obj: any): obj is RequestBodyObject;
+export declare function isResponseObject(obj: any): obj is ResponseObject;
+export interface NormalizedParameter {
+    name: string;
+    in: 'query' | 'header' | 'path' | 'cookie' | 'body' | 'formData';
+    description?: string;
+    required?: boolean;
+    deprecated?: boolean;
+    schema?: SchemaObject;
+    type?: string;
+    format?: string;
+    enum?: any[];
+    default?: any;
+    example?: any;
+}
+export interface NormalizedRequestBody {
+    description?: string;
+    required?: boolean;
+    schema?: SchemaObject;
+}
+export interface Endpoint {
+    id: string;
+    method: HttpMethod;
+    path: string;
+    summary?: string;
+    description?: string;
+    tags: string[];
+    parameters: NormalizedParameter[];
+    requestBody?: NormalizedRequestBody;
+    responses: ResponsesObject;
+    operationId?: string;
+    deprecated?: boolean;
+    security?: SecurityRequirementObject[];
+}
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'HEAD' | 'TRACE';
+export declare const HTTP_METHODS: HttpMethod[];
+export declare const METHOD_COLORS: Record<HttpMethod, string>;
+/**
+ * OpenAPI 문서에서 서버 URL 가져오기 (버전별 처리)
+ */
+export declare function getServerUrl(document: OpenAPIDocument): string | undefined;
+/**
+ * OpenAPI 문서에서 모든 서버 URL 가져오기
+ */
+export declare function getServerUrls(document: OpenAPIDocument): string[];
+/**
+ * OpenAPI에서 $ref로 참조 가능한 모든 타입
+ */
+export type ResolvableObject = SchemaObject | RequestBodyObject | ResponseObject | ParameterObject | MediaTypeObject;
+/**
+ * $ref를 resolve하여 실제 객체 반환
+ * @param ref - $ref 경로 (예: "#/definitions/Pet", "#/components/schemas/Pet", "#/components/requestBodies/UpdateUserRequest")
+ * @param document - OpenAPI 문서
+ * @returns 해결된 객체 또는 undefined
+ * @template T - resolve할 타입 (기본값: SchemaObject)
+ */
+export declare function resolveRef<T extends ResolvableObject = SchemaObject>(ref: string, document: OpenAPIDocument): T | undefined;

package/dist/types/openapi.js

@@ -0,0 +1,115 @@
+/**
+ * OpenAPI 타입 정의
+ * openapi-types 패키지를 재수출하고 애플리케이션별 타입을 정의합니다.
+ */
+// Type guards - 버전별 구분
+export function isOpenAPIV2Document(doc) {
+    return 'swagger' in doc && doc.swagger === '2.0';
+}
+export function isOpenAPIV3Document(doc) {
+    return 'openapi' in doc && typeof doc.openapi === 'string' && doc.openapi.startsWith('3.0');
+}
+export function isOpenAPIV3_1Document(doc) {
+    return 'openapi' in doc && typeof doc.openapi === 'string' && doc.openapi.startsWith('3.1');
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function isReferenceObject(obj) {
+    return obj && typeof obj === 'object' && '$ref' in obj;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function isSchemaObject(obj) {
+    return obj && typeof obj === 'object' && !('$ref' in obj);
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function isParameterObject(obj) {
+    return obj && typeof obj === 'object' && 'name' in obj && 'in' in obj && !('$ref' in obj);
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function isRequestBodyObject(obj) {
+    return obj && typeof obj === 'object' && 'content' in obj && !('$ref' in obj);
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function isResponseObject(obj) {
+    return obj && typeof obj === 'object' && 'description' in obj && !('$ref' in obj);
+}
+export const HTTP_METHODS = [
+    'GET',
+    'POST',
+    'PUT',
+    'DELETE',
+    'PATCH',
+    'OPTIONS',
+    'HEAD',
+    'TRACE',
+];
+// HTTP 메서드별 색상 매핑
+export const METHOD_COLORS = {
+    GET: '#61afef',
+    POST: '#13ec13',
+    PUT: '#e5c07b',
+    DELETE: '#e06c75',
+    PATCH: '#c678dd',
+    OPTIONS: '#56b6c2',
+    HEAD: '#abb2bf',
+    TRACE: '#98c379',
+};
+/**
+ * OpenAPI 문서에서 서버 URL 가져오기 (버전별 처리)
+ */
+export function getServerUrl(document) {
+    if (isOpenAPIV2Document(document)) {
+        // Swagger 2.0: scheme + host + basePath
+        const scheme = document.schemes?.[0] || 'http';
+        const host = document.host || 'localhost';
+        const basePath = document.basePath || '';
+        return `${scheme}://${host}${basePath}`;
+    }
+    else if (isOpenAPIV3Document(document) || isOpenAPIV3_1Document(document)) {
+        // OpenAPI 3.x: servers[0].url
+        return document.servers?.[0]?.url;
+    }
+    return undefined;
+}
+/**
+ * OpenAPI 문서에서 모든 서버 URL 가져오기
+ */
+export function getServerUrls(document) {
+    if (isOpenAPIV2Document(document)) {
+        const urls = [];
+        const schemes = document.schemes || ['http'];
+        const host = document.host || 'localhost';
+        const basePath = document.basePath || '';
+        for (const scheme of schemes) {
+            urls.push(`${scheme}://${host}${basePath}`);
+        }
+        return urls;
+    }
+    else if (isOpenAPIV3Document(document) || isOpenAPIV3_1Document(document)) {
+        const servers = document.servers || [];
+        return servers.map((s) => s.url);
+    }
+    return [];
+}
+/**
+ * $ref를 resolve하여 실제 객체 반환
+ * @param ref - $ref 경로 (예: "#/definitions/Pet", "#/components/schemas/Pet", "#/components/requestBodies/UpdateUserRequest")
+ * @param document - OpenAPI 문서
+ * @returns 해결된 객체 또는 undefined
+ * @template T - resolve할 타입 (기본값: SchemaObject)
+ */
+export function resolveRef(ref, document) {
+    if (!ref.startsWith('#/')) {
+        // 외부 파일 참조는 지원하지 않음
+        return undefined;
+    }
+    const path = ref.slice(2).split('/'); // "#/" 제거하고 경로 분할
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let current = document;
+    for (const segment of path) {
+        if (!current || typeof current !== 'object') {
+            return undefined;
+        }
+        current = current[segment];
+    }
+    return current;
+}

package/dist/utils/clipboard.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 클립보드 유틸리티
+ */
+/**
+ * 텍스트를 클립보드에 복사
+ */
+export declare function copyToClipboard(text: string): Promise<void>;
+/**
+ * 클립보드에서 텍스트 가져오기
+ */
+export declare function readFromClipboard(): Promise<string>;

package/dist/utils/clipboard.js

@@ -0,0 +1,26 @@
+/**
+ * 클립보드 유틸리티
+ */
+import clipboardy from 'clipboardy';
+/**
+ * 텍스트를 클립보드에 복사
+ */
+export async function copyToClipboard(text) {
+    try {
+        await clipboardy.write(text);
+    }
+    catch {
+        throw new Error('클립보드 복사 실패');
+    }
+}
+/**
+ * 클립보드에서 텍스트 가져오기
+ */
+export async function readFromClipboard() {
+    try {
+        return await clipboardy.read();
+    }
+    catch {
+        throw new Error('클립보드 읽기 실패');
+    }
+}

package/dist/utils/formatters.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 포맷팅 유틸리티
+ */
+/**
+ * JSON을 예쁘게 포맷팅
+ */
+export declare function formatJSON(data: unknown, indent?: number): string;
+/**
+ * 바이트 크기를 읽기 쉬운 형식으로 변환
+ */
+export declare function formatBytes(bytes: number): string;
+/**
+ * 밀리초를 읽기 쉬운 형식으로 변환
+ */
+export declare function formatDuration(ms: number): string;
+/**
+ * HTTP 상태 코드를 텍스트로 변환
+ */
+export declare function formatStatusCode(status: number, statusText?: string): string;
+/**
+ * 날짜를 포맷팅
+ */
+export declare function formatTimestamp(date: Date): string;
+/**
+ * URL 경로에서 파라미터 추출
+ */
+export declare function extractPathParams(path: string): string[];
+/**
+ * 긴 텍스트를 잘라내기
+ */
+export declare function truncate(text: string, maxLength: number): string;
+/**
+ * 라인 넘버 포맷팅
+ */
+export declare function formatLineNumber(lineNumber: number, maxDigits: number): string;

package/dist/utils/formatters.js

@@ -0,0 +1,93 @@
+/**
+ * 포맷팅 유틸리티
+ */
+/**
+ * JSON을 예쁘게 포맷팅
+ */
+export function formatJSON(data, indent = 2) {
+    try {
+        return JSON.stringify(data, null, indent);
+    }
+    catch {
+        return String(data);
+    }
+}
+/**
+ * 바이트 크기를 읽기 쉬운 형식으로 변환
+ */
+export function formatBytes(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(1024));
+    const value = bytes / Math.pow(1024, i);
+    return `${value.toFixed(2)} ${sizes[i]}`;
+}
+/**
+ * 밀리초를 읽기 쉬운 형식으로 변환
+ */
+export function formatDuration(ms) {
+    if (ms < 1000) {
+        return `${ms}ms`;
+    }
+    const seconds = ms / 1000;
+    if (seconds < 60) {
+        return `${seconds.toFixed(2)}s`;
+    }
+    const minutes = seconds / 60;
+    return `${minutes.toFixed(2)}m`;
+}
+/**
+ * HTTP 상태 코드를 텍스트로 변환
+ */
+export function formatStatusCode(status, statusText) {
+    if (statusText) {
+        return `${status} ${statusText}`;
+    }
+    const statusTexts = {
+        200: 'OK',
+        201: 'Created',
+        202: 'Accepted',
+        204: 'No Content',
+        400: 'Bad Request',
+        401: 'Unauthorized',
+        403: 'Forbidden',
+        404: 'Not Found',
+        500: 'Internal Server Error',
+        502: 'Bad Gateway',
+        503: 'Service Unavailable',
+    };
+    return `${status} ${statusTexts[status] || 'Unknown'}`;
+}
+/**
+ * 날짜를 포맷팅
+ */
+export function formatTimestamp(date) {
+    const hours = String(date.getHours()).padStart(2, '0');
+    const minutes = String(date.getMinutes()).padStart(2, '0');
+    const seconds = String(date.getSeconds()).padStart(2, '0');
+    return `${hours}:${minutes}:${seconds}`;
+}
+/**
+ * URL 경로에서 파라미터 추출
+ */
+export function extractPathParams(path) {
+    const matches = path.match(/\{([^}]+)\}/g);
+    if (!matches)
+        return [];
+    return matches.map((match) => match.slice(1, -1));
+}
+/**
+ * 긴 텍스트를 잘라내기
+ */
+export function truncate(text, maxLength) {
+    if (text.length <= maxLength)
+        return text;
+    return text.slice(0, maxLength - 3) + '...';
+}
+/**
+ * 라인 넘버 포맷팅
+ */
+export function formatLineNumber(lineNumber, maxDigits) {
+    return String(lineNumber).padStart(maxDigits, ' ');
+}