@gomjellie/lazyapi 0.0.1

package/dist/components/list-view/ListView.js

@@ -0,0 +1,304 @@
+/**
+ * API 목록 화면
+ */
+import React, { useMemo } from 'react';
+import { Box, useStdout } from 'ink';
+import { useAppSelector, useAppDispatch } from '../../store/hooks.js';
+import { setMode, listSelect, listSetFilter, listSetTag, listSetFocus, listSelectTag, listSetSearch, listSetTagSearch, } from '../../store/appSlice.js';
+import { useNavigation } from '../../hooks/useNavigation.js';
+import { useKeyPress } from '../../hooks/useKeyPress.js';
+import { OpenAPIParserService } from '../../services/openapi-parser.js';
+import StatusBar from '../common/StatusBar.js';
+import KeybindingFooter from '../common/KeybindingFooter.js';
+import EndpointList from './EndpointList.js';
+import FilterBar from './FilterBar.js';
+import SearchBar from './SearchBar.js';
+import Explorer from './Explorer.js';
+import { setCommandInput } from '../../store/appSlice.js';
+export default function ListView() {
+    const endpoints = useAppSelector((state) => state.app.endpoints);
+    const list = useAppSelector((state) => state.app.list);
+    const mode = useAppSelector((state) => state.app.mode);
+    const document = useAppSelector((state) => state.app.document);
+    const dispatch = useAppDispatch();
+    const { goToDetail } = useNavigation();
+    const parser = useMemo(() => new OpenAPIParserService(), []);
+    const { stdout } = useStdout();
+    // 태그 목록 추출
+    const tags = useMemo(() => {
+        const t = new Set();
+        endpoints.forEach((ep) => ep.tags?.forEach((tag) => t.add(tag)));
+        return Array.from(t).sort();
+    }, [endpoints]);
+    const allTags = ['Overview', ...tags];
+    // Tag Explorer 검색 필터링
+    const filteredTags = list.tagSearchQuery
+        ? allTags.filter((tag) => tag.toLowerCase().includes(list.tagSearchQuery.toLowerCase()))
+        : allTags;
+    // 필터링 및 검색 적용
+    const filteredEndpoints = useMemo(() => {
+        let filtered = endpoints;
+        // 태그 필터
+        if (list.activeTag) {
+            filtered = filtered.filter((ep) => ep.tags?.includes(list.activeTag));
+        }
+        // 메서드 필터
+        if (list.activeFilter !== 'ALL') {
+            filtered = parser.filterEndpoints(filtered, list.activeFilter);
+        }
+        // 검색
+        if (list.searchQuery) {
+            filtered = parser.searchEndpoints(filtered, list.searchQuery);
+        }
+        return filtered;
+    }, [list.activeFilter, list.searchQuery, list.activeTag, endpoints, parser]);
+    // 커맨드 실행 핸들러
+    const handleCommandSubmit = (cmd) => {
+        // 1. 종료 명령어 처리
+        if (cmd === 'q' || cmd === 'quit' || cmd === 'exit') {
+            process.exit(0);
+        }
+        // 2. 접두사 있는 명령어 처리 (t1, m1, e1...)
+        const match = cmd.match(/^([tme])(\d+)$/);
+        if (match) {
+            const type = match[1];
+            const index = parseInt(match[2], 10);
+            const targetIndex = index - 1;
+            if (type === 't') {
+                // Tag Explorer
+                if (targetIndex >= 0 && targetIndex < filteredTags.length) {
+                    dispatch(listSelectTag(targetIndex));
+                    dispatch(listSetFocus('TAGS'));
+                }
+            }
+            else if (type === 'm') {
+                // Filter (Method)
+                const filters = ['ALL', 'GET', 'POST', 'PUT', 'DELETE', 'PATCH'];
+                if (targetIndex >= 0 && targetIndex < filters.length) {
+                    dispatch(listSetFilter(filters[targetIndex]));
+                    dispatch(listSetFocus('LIST'));
+                }
+            }
+            else if (type === 'e') {
+                // Endpoint List (Items)
+                if (targetIndex >= 0 && targetIndex < filteredEndpoints.length) {
+                    dispatch(listSelect(targetIndex));
+                    dispatch(listSetFocus('LIST'));
+                }
+            }
+            dispatch(setMode('NORMAL'));
+            return;
+        }
+        // 3. 숫자만 있는 경우 (기존 동작 호환: 현재 포커스된 영역의 아이템 선택)
+        const index = parseInt(cmd, 10);
+        if (!isNaN(index)) {
+            const targetIndex = index - 1;
+            if (list.focus === 'TAGS') {
+                if (targetIndex >= 0 && targetIndex < filteredTags.length) {
+                    dispatch(listSelectTag(targetIndex));
+                }
+            }
+            else {
+                // LIST focus: Filter selection
+                // 원래 LIST 포커스일 때 숫자 입력은 Filter를 선택하는 로직이었음.
+                const filters = ['ALL', 'GET', 'POST', 'PUT', 'DELETE', 'PATCH'];
+                if (targetIndex >= 0 && targetIndex < filters.length) {
+                    dispatch(listSetFilter(filters[targetIndex]));
+                }
+            }
+            dispatch(setMode('NORMAL'));
+            return;
+        }
+        // 매치되지 않는 경우 그냥 모드 종료
+        dispatch(setMode('NORMAL'));
+    };
+    // 키보드 입력 처리
+    useKeyPress({
+        onTab: () => {
+            const newFocus = list.focus === 'LIST' ? 'TAGS' : 'LIST';
+            dispatch(listSetFocus(newFocus));
+        },
+        j: () => {
+            if (list.focus === 'TAGS') {
+                const nextIndex = Math.min(list.selectedTagIndex + 1, filteredTags.length - 1);
+                dispatch(listSelectTag(nextIndex));
+            }
+            else {
+                // 다음 항목
+                const nextIndex = Math.min(list.selectedIndex + 1, filteredEndpoints.length - 1);
+                dispatch(listSelect(nextIndex));
+            }
+        },
+        k: () => {
+            if (list.focus === 'TAGS') {
+                const prevIndex = Math.max(list.selectedTagIndex - 1, 0);
+                dispatch(listSelectTag(prevIndex));
+            }
+            else {
+                // 이전 항목
+                const prevIndex = Math.max(list.selectedIndex - 1, 0);
+                dispatch(listSelect(prevIndex));
+            }
+        },
+        // Page Up ({)
+        '{': () => {
+            if (list.focus === 'TAGS') {
+                const prevIndex = Math.max(list.selectedTagIndex - pageSize, 0);
+                dispatch(listSelectTag(prevIndex));
+            }
+            else {
+                const prevIndex = Math.max(list.selectedIndex - pageSize, 0);
+                dispatch(listSelect(prevIndex));
+            }
+        },
+        // Page Down (})
+        '}': () => {
+            if (list.focus === 'TAGS') {
+                const nextIndex = Math.min(list.selectedTagIndex + pageSize, filteredTags.length - 1);
+                dispatch(listSelectTag(nextIndex));
+            }
+            else {
+                const nextIndex = Math.min(list.selectedIndex + pageSize, filteredEndpoints.length - 1);
+                dispatch(listSelect(nextIndex));
+            }
+        },
+        g: () => {
+            if (list.focus === 'LIST') {
+                dispatch(listSelect(0));
+            }
+        },
+        G: () => {
+            if (list.focus === 'LIST') {
+                dispatch(listSelect(filteredEndpoints.length - 1));
+            }
+        },
+        '/': () => {
+            // 검색 모드 - focus에 따라 다른 모드
+            if (list.focus === 'TAGS') {
+                dispatch(setMode('TAG_SEARCH'));
+            }
+            else {
+                dispatch(setMode('SEARCH'));
+            }
+        },
+        ':': () => {
+            dispatch(setMode('COMMAND'));
+        },
+        onReturn: () => {
+            if (list.focus === 'TAGS') {
+                const tag = filteredTags[list.selectedTagIndex];
+                const actualTag = tag === 'Overview' ? null : tag;
+                // 다른 태그를 선택한 경우에만 태그 변경 (selectedIndex 리셋됨)
+                if (actualTag !== list.activeTag) {
+                    dispatch(listSetTag(actualTag));
+                }
+                // 포커스 유지 (Enter는 선택만 수행)
+            }
+            else {
+                // 선택한 엔드포인트 상세 보기
+                const selected = filteredEndpoints[list.selectedIndex];
+                if (selected) {
+                    goToDetail(selected);
+                }
+            }
+        },
+        l: () => {
+            if (list.focus === 'TAGS') {
+                const tag = filteredTags[list.selectedTagIndex];
+                const actualTag = tag === 'Overview' ? null : tag;
+                // 다른 태그를 선택한 경우에만 태그 변경 (selectedIndex 리셋됨)
+                if (actualTag !== list.activeTag) {
+                    dispatch(listSetTag(actualTag));
+                }
+                // l 키는 오른쪽 패널로 이동
+                dispatch(listSetFocus('LIST'));
+            }
+            else {
+                const selected = filteredEndpoints[list.selectedIndex];
+                if (selected) {
+                    goToDetail(selected);
+                }
+            }
+        },
+        h: () => {
+            if (list.focus === 'LIST') {
+                dispatch(listSetFocus('TAGS'));
+            }
+        },
+    }, mode === 'NORMAL');
+    // Command 모드 처리
+    useKeyPress({
+        onEscape: () => {
+            dispatch(setMode('NORMAL'));
+            dispatch(setCommandInput(''));
+        },
+    }, mode === 'COMMAND');
+    // 검색 모드 키보드 입력 처리 (엔드포인트 검색)
+    useKeyPress({
+        onReturn: () => {
+            // 검색 쿼리를 유지하고 NORMAL 모드로 전환
+            dispatch(setMode('NORMAL'));
+            // 첫 번째 필터링된 항목으로 인덱스 초기화
+            dispatch(listSelect(0));
+        },
+        onEscape: () => {
+            // 검색 취소
+            dispatch(listSetSearch(''));
+            dispatch(setMode('NORMAL'));
+        },
+    }, mode === 'SEARCH');
+    // Tag Explorer 검색 모드 키보드 입력 처리
+    useKeyPress({
+        onReturn: () => {
+            // 검색 쿼리를 유지하고 NORMAL 모드로 전환
+            dispatch(setMode('NORMAL'));
+            // 첫 번째 필터링된 항목으로 인덱스 초기화
+            dispatch(listSelectTag(0));
+        },
+        onEscape: () => {
+            // 검색 취소
+            dispatch(listSetTagSearch(''));
+            dispatch(setMode('NORMAL'));
+        },
+    }, mode === 'TAG_SEARCH');
+    const keyBindings = [
+        { key: 'Tab', description: 'Switch Focus' },
+        { key: 'j/k', description: 'Next/Prev' },
+        { key: '{/}', description: 'Page Up/Down' },
+        { key: 'h/l', description: 'Nav' },
+        { key: ':', description: 'Command' },
+        { key: 'Enter', description: 'Select' },
+        list.focus === 'TAGS'
+            ? { key: '/', description: 'Search' }
+            : { key: '/', description: 'Search' },
+    ];
+    const searchKeyBindings = [
+        { key: 'Type', description: 'Search Query' },
+        { key: 'Enter', description: 'Apply' },
+        { key: 'Esc', description: 'Cancel' },
+    ];
+    const tagSearchKeyBindings = [
+        { key: 'Type', description: 'Search' },
+        { key: 'Enter', description: 'Apply' },
+        { key: 'Esc', description: 'Cancel' },
+    ];
+    const terminalHeight = stdout?.rows || 24;
+    // ListView와 Tag Explorer의 가용 높이 계산 (동일하게 -9 사용)
+    const pageSize = Math.max(1, terminalHeight - 9);
+    return (React.createElement(Box, { flexDirection: "column", height: terminalHeight },
+        React.createElement(StatusBar, { title: "LAZYAPI", version: "1.0.0", currentPath: document?.info.title || '', mode: mode, status: "ONLINE" }),
+        React.createElement(Box, { flexDirection: "row", flexGrow: 1, overflow: "hidden" },
+            React.createElement(Box, null,
+                React.createElement(Explorer, { tags: tags, selectedTagIndex: list.selectedTagIndex, activeTag: list.activeTag, isFocused: list.focus === 'TAGS', searchQuery: list.tagSearchQuery, isSearchMode: mode === 'TAG_SEARCH', commandMode: mode === 'COMMAND', onSearchChange: (query) => dispatch(listSetTagSearch(query)) })),
+            React.createElement(Box, { flexDirection: "column", flexGrow: 1, marginLeft: 1, borderStyle: "single", borderColor: list.focus === 'LIST' ? 'green' : 'gray', paddingX: 1, paddingBottom: 1, paddingTop: 0 },
+                React.createElement(Box, { flexDirection: "row", alignItems: "center", gap: 2 },
+                    React.createElement(FilterBar, { activeFilter: list.activeFilter, commandMode: mode === 'COMMAND', onFilterChange: (filter) => dispatch(listSetFilter(filter)) })),
+                React.createElement(SearchBar, { query: list.searchQuery, onQueryChange: (query) => dispatch(listSetSearch(query)), isSearchMode: mode === 'SEARCH' }),
+                React.createElement(Box, { flexGrow: 1, marginTop: 0, overflow: "hidden" },
+                    React.createElement(EndpointList, { endpoints: filteredEndpoints, selectedIndex: list.selectedIndex, commandMode: mode === 'COMMAND' })))),
+        React.createElement(KeybindingFooter, { bindings: mode === 'SEARCH'
+                ? searchKeyBindings
+                : mode === 'TAG_SEARCH'
+                    ? tagSearchKeyBindings
+                    : keyBindings, mode: mode, additionalInfo: `${list.selectedIndex + 1}/${filteredEndpoints.length}`, commandInput: useAppSelector((state) => state.app.commandInput), onCommandChange: (value) => dispatch(setCommandInput(value)), onCommandSubmit: handleCommandSubmit })));
+}

package/dist/components/list-view/SearchBar.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 검색 바 컴포넌트
+ */
+import React from 'react';
+interface SearchBarProps {
+    query: string;
+    onQueryChange: (query: string) => void;
+    isSearchMode: boolean;
+}
+export default function SearchBar({ query, onQueryChange, isSearchMode }: SearchBarProps): React.JSX.Element;
+export {};

package/dist/components/list-view/SearchBar.js

@@ -0,0 +1,14 @@
+/**
+ * 검색 바 컴포넌트
+ */
+import React from 'react';
+import { Box, Text } from 'ink';
+import TextInput from 'ink-text-input';
+export default function SearchBar({ query, onQueryChange, isSearchMode }) {
+    return (React.createElement(Box, { paddingX: 0, marginBottom: 0, flexDirection: "row", width: "100%" },
+        React.createElement(Text, { color: isSearchMode ? 'green' : 'gray', bold: true },
+            "\u279C",
+            ' '),
+        React.createElement(Box, { flexGrow: 1 },
+            React.createElement(Text, { underline: true, color: isSearchMode ? 'white' : 'gray' }, isSearchMode ? (React.createElement(TextInput, { value: query, onChange: onQueryChange, placeholder: "", focus: true, showCursor: true })) : query ? (query) : ('Search...')))));
+}

package/dist/hooks/useApiClient.d.ts

@@ -0,0 +1,11 @@
+/**
+ * API 클라이언트 Hook
+ */
+import { Endpoint } from '../types/openapi.js';
+import { ApiResponse } from '../types/app-state.js';
+export declare function useApiClient(baseURL?: string): {
+    executeRequest: (endpoint: Endpoint, parameterValues: Record<string, string>, headers: Record<string, string>, requestBody?: string, customBaseURL?: string) => Promise<ApiResponse | null>;
+    setBaseURL: (url: string) => void;
+    loading: boolean;
+    error: string | null;
+};

package/dist/hooks/useApiClient.js

@@ -0,0 +1,34 @@
+/**
+ * API 클라이언트 Hook
+ */
+import { useState, useCallback } from 'react';
+import { HttpClientService } from '../services/http-client.js';
+export function useApiClient(baseURL) {
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const [httpClient] = useState(() => new HttpClientService(baseURL));
+    const executeRequest = useCallback(async (endpoint, parameterValues, headers, requestBody, customBaseURL) => {
+        setLoading(true);
+        setError(null);
+        try {
+            const response = await httpClient.executeRequest(endpoint, parameterValues, headers, requestBody, customBaseURL || baseURL);
+            setLoading(false);
+            return response;
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : '요청 실행 중 오류가 발생했습니다';
+            setError(errorMessage);
+            setLoading(false);
+            return null;
+        }
+    }, [httpClient, baseURL]);
+    const setBaseURL = useCallback((url) => {
+        httpClient.setBaseURL(url);
+    }, [httpClient]);
+    return {
+        executeRequest,
+        setBaseURL,
+        loading,
+        error,
+    };
+}

package/dist/hooks/useKeyPress.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 키보드 입력 처리 Hook
+ */
+export interface KeyHandler {
+    (key: string, meta: {
+        ctrl: boolean;
+        shift: boolean;
+        meta: boolean;
+    }): void;
+}
+export interface KeyBindings {
+    [key: string]: KeyHandler | undefined;
+    onTab?: KeyHandler;
+    onShiftTab?: KeyHandler;
+    onEscape?: KeyHandler;
+    onReturn?: KeyHandler;
+    onBackspace?: KeyHandler;
+    onUpArrow?: KeyHandler;
+    onDownArrow?: KeyHandler;
+    onLeftArrow?: KeyHandler;
+    onRightArrow?: KeyHandler;
+}
+/**
+ * 키보드 입력을 처리하는 Hook
+ */
+export declare function useKeyPress(bindings: KeyBindings, isEnabled?: boolean): void;

package/dist/hooks/useKeyPress.js

@@ -0,0 +1,57 @@
+/**
+ * 키보드 입력 처리 Hook
+ */
+import { useInput } from 'ink';
+import { useCallback } from 'react';
+/**
+ * 키보드 입력을 처리하는 Hook
+ */
+export function useKeyPress(bindings, isEnabled = true) {
+    const handleInput = useCallback((input, key) => {
+        if (!isEnabled)
+            return;
+        // 특수 키 처리
+        if (key.tab) {
+            if (key.shift && bindings.onShiftTab) {
+                bindings.onShiftTab(input, key);
+            }
+            else if (bindings.onTab) {
+                bindings.onTab(input, key);
+            }
+            return;
+        }
+        if (key.escape && bindings.onEscape) {
+            bindings.onEscape(input, key);
+            return;
+        }
+        if (key.return && bindings.onReturn) {
+            bindings.onReturn(input, key);
+            return;
+        }
+        if (key.backspace && bindings.onBackspace) {
+            bindings.onBackspace(input, key);
+            return;
+        }
+        if (key.upArrow && bindings.onUpArrow) {
+            bindings.onUpArrow(input, key);
+            return;
+        }
+        if (key.downArrow && bindings.onDownArrow) {
+            bindings.onDownArrow(input, key);
+            return;
+        }
+        if (key.leftArrow && bindings.onLeftArrow) {
+            bindings.onLeftArrow(input, key);
+            return;
+        }
+        if (key.rightArrow && bindings.onRightArrow) {
+            bindings.onRightArrow(input, key);
+            return;
+        }
+        // 일반 키 입력 처리
+        if (input && bindings[input]) {
+            bindings[input](input, key);
+        }
+    }, [bindings, isEnabled]);
+    useInput(handleInput, { isActive: isEnabled });
+}

package/dist/hooks/useNavigation.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 화면 네비게이션 Hook
+ */
+import { Endpoint } from '../types/openapi.js';
+export declare function useNavigation(): {
+    currentScreen: import("../types/app-state.js").Screen;
+    goToList: () => void;
+    goToDetail: (endpoint: Endpoint) => void;
+    goBack: () => void;
+};

package/dist/hooks/useNavigation.js

@@ -0,0 +1,33 @@
+/**
+ * 화면 네비게이션 Hook
+ */
+import { useCallback } from 'react';
+import { useAppSelector, useAppDispatch } from '../store/hooks.js';
+import { setScreen, setMode, detailSet } from '../store/appSlice.js';
+export function useNavigation() {
+    const screen = useAppSelector((state) => state.app.screen);
+    const dispatch = useAppDispatch();
+    const goToList = useCallback(() => {
+        dispatch(setScreen('LIST'));
+        dispatch(setMode('NORMAL'));
+    }, [dispatch]);
+    const goToDetail = useCallback((endpoint) => {
+        dispatch(detailSet(endpoint));
+        dispatch(setMode('NORMAL'));
+    }, [dispatch]);
+    const goBack = useCallback(() => {
+        switch (screen) {
+            case 'DETAIL':
+                goToList();
+                break;
+            default:
+                break;
+        }
+    }, [screen, goToList]);
+    return {
+        currentScreen: screen,
+        goToList,
+        goToDetail,
+        goBack,
+    };
+}

package/dist/services/http-client.d.ts

@@ -0,0 +1,21 @@
+/**
+ * HTTP 클라이언트 서비스
+ */
+import { Endpoint } from '../types/openapi.js';
+import { ApiResponse } from '../types/app-state.js';
+export declare class HttpClientService {
+    private client;
+    constructor(baseURL?: string);
+    /**
+     * API 요청 실행
+     */
+    executeRequest(endpoint: Endpoint, parameterValues: Record<string, string>, headers: Record<string, string>, requestBody?: string, baseURL?: string): Promise<ApiResponse>;
+    /**
+     * 기본 URL 설정
+     */
+    setBaseURL(baseURL: string): void;
+    /**
+     * 기본 헤더 설정
+     */
+    setDefaultHeaders(headers: Record<string, string>): void;
+}