inup 1.4.0 → 1.4.2

package/dist/ui/state/navigation-manager.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NavigationManager = void 0;
+class NavigationManager {
+    constructor(initialRow = 0, maxVisibleItems = 19) {
+        this.renderableItems = [];
+        this.headerLines = 5; // title (with label) + empty + 1 instruction line + status + empty
+        this.state = {
+            currentRow: initialRow,
+            previousRow: -1,
+            scrollOffset: 0,
+            previousScrollOffset: 0,
+        };
+        this.maxVisibleItems = maxVisibleItems;
+    }
+    getState() {
+        return { ...this.state };
+    }
+    getCurrentRow() {
+        return this.state.currentRow;
+    }
+    getScrollOffset() {
+        return this.state.scrollOffset;
+    }
+    setCurrentRow(row) {
+        this.state.previousRow = this.state.currentRow;
+        this.state.currentRow = row;
+    }
+    setScrollOffset(offset) {
+        this.state.previousScrollOffset = this.state.scrollOffset;
+        this.state.scrollOffset = offset;
+    }
+    setRenderableItems(items) {
+        this.renderableItems = items;
+    }
+    setMaxVisibleItems(maxVisible) {
+        this.maxVisibleItems = maxVisible;
+    }
+    getMaxVisibleItems() {
+        return this.maxVisibleItems;
+    }
+    // Convert package index to visual row index in renderable items
+    packageIndexToVisualIndex(packageIndex) {
+        // If no renderable items (flat mode), visual index equals package index
+        if (this.renderableItems.length === 0) {
+            return packageIndex;
+        }
+        // Otherwise search in renderable items (grouped mode)
+        for (let i = 0; i < this.renderableItems.length; i++) {
+            const item = this.renderableItems[i];
+            if (item.type === 'package' && item.originalIndex === packageIndex) {
+                return i;
+            }
+        }
+        return 0;
+    }
+    // Find the next navigable package index in the given direction
+    findNextPackageIndex(currentPackageIndex, direction, totalPackages) {
+        if (this.renderableItems.length === 0) {
+            // Fallback to simple navigation if no renderable items
+            if (direction === 'up') {
+                return currentPackageIndex <= 0 ? totalPackages - 1 : currentPackageIndex - 1;
+            }
+            else {
+                return currentPackageIndex >= totalPackages - 1 ? 0 : currentPackageIndex + 1;
+            }
+        }
+        // Find current visual index
+        const currentVisualIndex = this.packageIndexToVisualIndex(currentPackageIndex);
+        // Get all package items with their visual indices
+        const packageItems = [];
+        for (let i = 0; i < this.renderableItems.length; i++) {
+            const item = this.renderableItems[i];
+            if (item.type === 'package') {
+                packageItems.push({ visualIndex: i, packageIndex: item.originalIndex });
+            }
+        }
+        if (packageItems.length === 0)
+            return currentPackageIndex;
+        // Find current position in packageItems
+        const currentPos = packageItems.findIndex((p) => p.packageIndex === currentPackageIndex);
+        if (currentPos === -1)
+            return packageItems[0].packageIndex;
+        // Navigate with wrap-around at boundaries
+        if (direction === 'up') {
+            const newPos = currentPos <= 0 ? packageItems.length - 1 : currentPos - 1;
+            return packageItems[newPos].packageIndex;
+        }
+        else {
+            const newPos = currentPos >= packageItems.length - 1 ? 0 : currentPos + 1;
+            return packageItems[newPos].packageIndex;
+        }
+    }
+    navigateUp(totalItems) {
+        if (totalItems === 0)
+            return;
+        this.state.previousRow = this.state.currentRow;
+        this.state.currentRow = this.findNextPackageIndex(this.state.currentRow, 'up', totalItems);
+        this.ensureVisible(this.state.currentRow, totalItems);
+    }
+    navigateDown(totalItems) {
+        if (totalItems === 0)
+            return;
+        this.state.previousRow = this.state.currentRow;
+        this.state.currentRow = this.findNextPackageIndex(this.state.currentRow, 'down', totalItems);
+        this.ensureVisible(this.state.currentRow, totalItems);
+    }
+    ensureVisible(packageIndex, totalPackages) {
+        // Convert package index to visual index for scrolling
+        const visualIndex = this.packageIndexToVisualIndex(packageIndex);
+        const totalVisualItems = this.renderableItems.length || totalPackages;
+        // Try to show section header if the current item is just below a header
+        let targetVisualIndex = visualIndex;
+        if (visualIndex > 0) {
+            const prevItem = this.renderableItems[visualIndex - 1];
+            if (prevItem?.type === 'header') {
+                targetVisualIndex = visualIndex - 1;
+            }
+            else if (visualIndex > 1) {
+                // Also check for spacer + header combo (for first package in non-first section)
+                const prevPrevItem = this.renderableItems[visualIndex - 2];
+                if (prevItem?.type === 'spacer' && prevPrevItem?.type === 'header') {
+                    // Show spacer and header if possible
+                    targetVisualIndex = Math.max(0, visualIndex - 2);
+                }
+            }
+        }
+        // Scrolling up: scroll up by 1 item
+        if (targetVisualIndex < this.state.scrollOffset) {
+            this.state.scrollOffset = targetVisualIndex;
+        }
+        // Scrolling down: scroll down by 1 item (smooth scrolling)
+        else if (visualIndex >= this.state.scrollOffset + this.maxVisibleItems) {
+            this.state.scrollOffset += 1;
+        }
+        // Ensure scrollOffset doesn't go negative or beyond bounds
+        const maxScroll = Math.max(0, totalVisualItems - this.maxVisibleItems);
+        this.state.scrollOffset = Math.max(0, Math.min(this.state.scrollOffset, maxScroll));
+        // Handle wrap-around: if we're at the last item and it's out of view, show it at bottom
+        if (visualIndex === totalVisualItems - 1 &&
+            visualIndex >= this.state.scrollOffset + this.maxVisibleItems) {
+            this.state.scrollOffset = maxScroll;
+        }
+    }
+    resetForResize(totalItems) {
+        this.ensureVisible(this.state.currentRow, totalItems);
+    }
+    markRendered() {
+        this.state.previousRow = this.state.currentRow;
+        this.state.previousScrollOffset = this.state.scrollOffset;
+    }
+}
+exports.NavigationManager = NavigationManager;
+//# sourceMappingURL=navigation-manager.js.map

package/dist/ui/state/state-manager.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateManager = void 0;
+const navigation_manager_1 = require("./navigation-manager");
+const modal_manager_1 = require("./modal-manager");
+const filter_manager_1 = require("./filter-manager");
+const theme_manager_1 = require("./theme-manager");
+class StateManager {
+    constructor(initialRow = 0, terminalHeight = 24) {
+        this.headerLines = 5; // title (with label) + empty + 1 instruction line + status + empty
+        const maxVisibleItems = Math.max(5, terminalHeight - this.headerLines - 2);
+        this.navigationManager = new navigation_manager_1.NavigationManager(initialRow, maxVisibleItems);
+        this.modalManager = new modal_manager_1.ModalManager();
+        this.filterManager = new filter_manager_1.FilterManager();
+        this.themeManager = new theme_manager_1.ThemeManager();
+        this.displayState = {
+            maxVisibleItems,
+            terminalHeight,
+        };
+        this.renderState = {
+            forceFullRender: true,
+            renderedLines: [],
+            renderableItems: [],
+        };
+    }
+    // Aggregate all state for backward compatibility
+    getUIState() {
+        const navState = this.navigationManager.getState();
+        const modalState = this.modalManager.getState();
+        const filterState = this.filterManager.getState();
+        const themeState = this.themeManager.getState();
+        return {
+            currentRow: navState.currentRow,
+            previousRow: navState.previousRow,
+            scrollOffset: navState.scrollOffset,
+            previousScrollOffset: navState.previousScrollOffset,
+            maxVisibleItems: this.displayState.maxVisibleItems,
+            terminalHeight: this.displayState.terminalHeight,
+            forceFullRender: this.renderState.forceFullRender,
+            renderedLines: this.renderState.renderedLines,
+            renderableItems: this.renderState.renderableItems,
+            showInfoModal: modalState.showInfoModal,
+            infoModalRow: modalState.infoModalRow,
+            isLoadingModalInfo: modalState.isLoadingModalInfo,
+            filterMode: filterState.filterMode,
+            filterQuery: filterState.filterQuery,
+            showThemeModal: themeState.showThemeModal,
+            currentTheme: themeState.currentTheme,
+        };
+    }
+    setRenderableItems(items) {
+        this.renderState.renderableItems = items;
+        this.navigationManager.setRenderableItems(items);
+    }
+    // Navigation delegation
+    navigateUp(totalItems) {
+        this.navigationManager.navigateUp(totalItems);
+    }
+    navigateDown(totalItems) {
+        this.navigationManager.navigateDown(totalItems);
+    }
+    packageIndexToVisualIndex(packageIndex) {
+        return this.navigationManager.packageIndexToVisualIndex(packageIndex);
+    }
+    // Selection logic (still in StateManager as it operates on external state)
+    updateSelection(states, direction) {
+        if (states.length === 0)
+            return;
+        const currentRow = this.navigationManager.getCurrentRow();
+        const currentState = states[currentRow];
+        if (!currentState)
+            return;
+        if (direction === 'left') {
+            // Move selection left with wraparound: latest -> range -> none -> latest
+            if (currentState.selectedOption === 'latest') {
+                if (currentState.hasRangeUpdate) {
+                    currentState.selectedOption = 'range';
+                }
+                else {
+                    currentState.selectedOption = 'none';
+                }
+            }
+            else if (currentState.selectedOption === 'range') {
+                currentState.selectedOption = 'none';
+            }
+            else if (currentState.selectedOption === 'none') {
+                // Wrap around to the last available option
+                if (currentState.hasMajorUpdate) {
+                    currentState.selectedOption = 'latest';
+                }
+                else if (currentState.hasRangeUpdate) {
+                    currentState.selectedOption = 'range';
+                }
+            }
+        }
+        else {
+            // Move selection right with wraparound: none -> range -> latest -> none
+            if (currentState.selectedOption === 'none') {
+                if (currentState.hasRangeUpdate) {
+                    currentState.selectedOption = 'range';
+                }
+                else if (currentState.hasMajorUpdate) {
+                    currentState.selectedOption = 'latest';
+                }
+            }
+            else if (currentState.selectedOption === 'range') {
+                if (currentState.hasMajorUpdate) {
+                    currentState.selectedOption = 'latest';
+                }
+                else {
+                    // Wrap around to none
+                    currentState.selectedOption = 'none';
+                }
+            }
+            else if (currentState.selectedOption === 'latest') {
+                // Wrap around to none
+                currentState.selectedOption = 'none';
+            }
+        }
+    }
+    bulkSelectMinor(states) {
+        if (states.length === 0)
+            return;
+        states.forEach((state) => {
+            if (state.hasRangeUpdate) {
+                state.selectedOption = 'range';
+            }
+        });
+    }
+    bulkSelectLatest(states) {
+        if (states.length === 0)
+            return;
+        states.forEach((state) => {
+            if (state.hasMajorUpdate) {
+                state.selectedOption = 'latest';
+            }
+            else if (state.hasRangeUpdate) {
+                state.selectedOption = 'range';
+            }
+        });
+    }
+    bulkUnselectAll(states) {
+        if (states.length === 0)
+            return;
+        states.forEach((state) => {
+            state.selectedOption = 'none';
+        });
+    }
+    // Modal delegation
+    toggleInfoModal() {
+        const currentRow = this.navigationManager.getCurrentRow();
+        this.modalManager.toggleInfoModal(currentRow);
+        this.renderState.forceFullRender = true;
+    }
+    closeInfoModal() {
+        this.modalManager.closeInfoModal();
+        this.renderState.forceFullRender = true;
+    }
+    setModalLoading(isLoading) {
+        this.modalManager.setModalLoading(isLoading);
+        this.renderState.forceFullRender = true;
+    }
+    // Filter delegation
+    enterFilterMode() {
+        this.filterManager.enterFilterMode();
+        this.renderState.forceFullRender = true;
+    }
+    exitFilterMode() {
+        this.filterManager.exitFilterMode();
+        this.navigationManager.setCurrentRow(0);
+        this.navigationManager.setScrollOffset(0);
+        this.renderState.forceFullRender = true;
+    }
+    updateFilterQuery(query) {
+        this.filterManager.updateFilterQuery(query);
+        this.navigationManager.setCurrentRow(0);
+        this.navigationManager.setScrollOffset(0);
+    }
+    appendToFilterQuery(char) {
+        this.filterManager.appendToFilterQuery(char);
+        this.navigationManager.setCurrentRow(0);
+        this.navigationManager.setScrollOffset(0);
+        this.renderState.forceFullRender = true;
+    }
+    deleteFromFilterQuery() {
+        this.filterManager.deleteFromFilterQuery();
+        this.navigationManager.setCurrentRow(0);
+        this.navigationManager.setScrollOffset(0);
+        this.renderState.forceFullRender = true;
+    }
+    getFilteredStates(allStates) {
+        return this.filterManager.getFilteredStates(allStates);
+    }
+    // Display and render state management
+    updateTerminalHeight(newHeight) {
+        const newMaxVisibleItems = Math.max(5, newHeight - this.headerLines - 2);
+        if (newHeight !== this.displayState.terminalHeight ||
+            newMaxVisibleItems !== this.displayState.maxVisibleItems) {
+            this.displayState.terminalHeight = newHeight;
+            this.displayState.maxVisibleItems = newMaxVisibleItems;
+            this.navigationManager.setMaxVisibleItems(newMaxVisibleItems);
+            return true; // Changed
+        }
+        return false; // No change
+    }
+    markRendered(renderedLines) {
+        this.renderState.renderedLines = renderedLines;
+        this.navigationManager.markRendered();
+    }
+    setInitialRender(isInitial) {
+        this.renderState.forceFullRender = isInitial;
+    }
+    resetForResize() {
+        const totalItems = this.renderState.renderableItems.length || this.displayState.maxVisibleItems;
+        this.navigationManager.resetForResize(totalItems);
+        this.renderState.forceFullRender = true;
+    }
+    // Theme delegation
+    toggleThemeModal() {
+        this.themeManager.toggleThemeModal();
+        this.renderState.forceFullRender = true;
+    }
+    closeThemeModal() {
+        this.themeManager.closeThemeModal();
+        this.renderState.forceFullRender = true;
+    }
+    previewTheme(themeName) {
+        this.themeManager.previewTheme(themeName);
+        this.renderState.forceFullRender = true;
+    }
+    confirmTheme() {
+        this.themeManager.confirmTheme();
+        this.renderState.forceFullRender = true;
+    }
+    getThemeManager() {
+        return this.themeManager;
+    }
+}
+exports.StateManager = StateManager;
+//# sourceMappingURL=state-manager.js.map

package/dist/ui/state/theme-manager.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThemeManager = void 0;
+exports.getThemeColors = getThemeColors;
+exports.getCurrentThemeName = getCurrentThemeName;
+const themes_1 = require("../themes");
+const config_1 = require("../../utils/config");
+// Global theme state for renderers to access
+let globalCurrentTheme = themes_1.defaultTheme;
+class ThemeManager {
+    constructor() {
+        // Load saved theme from config, fallback to default
+        const savedTheme = config_1.configManager.getTheme();
+        const initialTheme = savedTheme && themes_1.themeNames.includes(savedTheme) ? savedTheme : themes_1.defaultTheme;
+        this.state = {
+            showThemeModal: false,
+            currentTheme: initialTheme,
+            previewTheme: initialTheme,
+        };
+        globalCurrentTheme = initialTheme;
+    }
+    getState() {
+        return { ...this.state };
+    }
+    isThemeModalOpen() {
+        return this.state.showThemeModal;
+    }
+    getCurrentTheme() {
+        return this.state.currentTheme;
+    }
+    getPreviewTheme() {
+        return this.state.previewTheme;
+    }
+    openThemeModal() {
+        this.state.showThemeModal = true;
+        // Start preview with current theme
+        this.state.previewTheme = this.state.currentTheme;
+    }
+    closeThemeModal() {
+        this.state.showThemeModal = false;
+        // Reset preview to current theme when closing without confirmation
+        this.state.previewTheme = this.state.currentTheme;
+    }
+    previewTheme(themeName) {
+        if (themes_1.themeNames.includes(themeName)) {
+            this.state.previewTheme = themeName;
+            // Update global theme immediately for live preview in UI
+            globalCurrentTheme = themeName;
+        }
+    }
+    confirmTheme() {
+        this.state.currentTheme = this.state.previewTheme;
+        globalCurrentTheme = this.state.currentTheme;
+        // Save theme to config
+        config_1.configManager.setTheme(this.state.currentTheme);
+        this.closeThemeModal();
+    }
+    setTheme(themeName) {
+        if (themes_1.themeNames.includes(themeName)) {
+            this.state.currentTheme = themeName;
+            this.state.previewTheme = themeName;
+            globalCurrentTheme = themeName;
+            // Save theme to config
+            config_1.configManager.setTheme(themeName);
+        }
+    }
+    toggleThemeModal() {
+        if (this.state.showThemeModal) {
+            this.closeThemeModal();
+        }
+        else {
+            this.openThemeModal();
+        }
+    }
+}
+exports.ThemeManager = ThemeManager;
+// Helper function for renderers to get current theme colors
+function getThemeColors() {
+    return themes_1.themes[globalCurrentTheme]?.colors || themes_1.themes[themes_1.defaultTheme].colors;
+}
+// Helper function to get current theme name
+function getCurrentThemeName() {
+    return globalCurrentTheme;
+}
+//# sourceMappingURL=theme-manager.js.map

package/dist/ui/themes-colors.js

@@ -0,0 +1,168 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.themeColors = void 0;
+exports.getThemeColor = getThemeColor;
+exports.getThemeBgColor = getThemeBgColor;
+exports.getTerminalBgColorCode = getTerminalBgColorCode;
+exports.getTerminalResetCode = getTerminalResetCode;
+const chalk_1 = __importDefault(require("chalk"));
+const theme_manager_1 = require("./state/theme-manager");
+// Centralized theme color definitions - single source of truth
+const themeColorDefinitions = {
+    default: {
+        bg: '#1a1a1a',
+        primary: 'cyan',
+        secondary: 'magenta',
+        success: 'green',
+        warning: 'yellow',
+        error: 'red',
+        border: 'gray',
+        text: 'white',
+        textSecondary: 'gray',
+    },
+    dracula: {
+        bg: '#282A36',
+        primary: '#8BE9FD',
+        secondary: '#FF79C6',
+        success: '#50FA7B',
+        warning: '#F1FA8C',
+        error: '#FF5555',
+        border: '#44475A',
+        text: '#F8F8F2',
+        textSecondary: '#6272A4',
+    },
+    vsc: {
+        bg: '#1E1E1E',
+        primary: '#4FC1FF',
+        secondary: '#4EC9B0',
+        success: '#89D185',
+        warning: '#E5C07B',
+        error: '#F48771',
+        border: '#3E3E42',
+        text: '#D4D4D4',
+        textSecondary: '#858585',
+    },
+    monokai: {
+        bg: '#272822',
+        primary: '#66D9EF',
+        secondary: '#AE81FF',
+        success: '#A6E22E',
+        warning: '#E6DB74',
+        error: '#F92672',
+        border: '#49483E',
+        text: '#F8F8F2',
+        textSecondary: '#75715E',
+    },
+    catppuccin: {
+        bg: '#1E1E2E',
+        primary: '#89B4FA',
+        secondary: '#CBA6F7',
+        success: '#A6E3A1',
+        warning: '#F9E2AF',
+        error: '#F38BA8',
+        border: '#45475A',
+        text: '#CDD6F4',
+        textSecondary: '#BAC2DE',
+    },
+    tokyonight: {
+        bg: '#1A1B26',
+        primary: '#7AA2F7',
+        secondary: '#BB9AF7',
+        success: '#9ECE6A',
+        warning: '#E0AF68',
+        error: '#F7768E',
+        border: '#414868',
+        text: '#C0CAF5',
+        textSecondary: '#A9B1D6',
+    },
+};
+// Helper to apply color - handles both hex and named colors
+function applyColor(color, text) {
+    if (color.startsWith('#')) {
+        return chalk_1.default.hex(color)(text);
+    }
+    return chalk_1.default[color](text);
+}
+const themeColorSchemes = Object.entries(themeColorDefinitions).reduce((schemes, [themeName, colors]) => {
+    schemes[themeName] = createThemeScheme(colors);
+    return schemes;
+}, {});
+function createThemeScheme(colors) {
+    return {
+        primary: (text) => applyColor(colors.primary, text),
+        secondary: (text) => applyColor(colors.secondary, text),
+        success: (text) => applyColor(colors.success, text),
+        warning: (text) => applyColor(colors.warning, text),
+        error: (text) => applyColor(colors.error, text),
+        border: (text) => applyColor(colors.border, text),
+        text: (text) => applyColor(colors.text, text),
+        textSecondary: (text) => applyColor(colors.textSecondary, text),
+        // Derived colors (reuse existing colors for semantic purposes)
+        packageName: (text) => applyColor(colors.primary, text),
+        packageAuthor: (text) => applyColor(colors.secondary, text),
+        versionRange: (text) => applyColor(colors.warning, text),
+        versionLatest: (text) => applyColor(colors.error, text),
+        dot: (text) => applyColor(colors.success, text),
+        dotEmpty: (text) => applyColor(colors.border, text),
+        bg: (text) => chalk_1.default.bgHex(colors.bg)(text),
+    };
+}
+function getThemeColor(key) {
+    const themeName = (0, theme_manager_1.getCurrentThemeName)();
+    const scheme = themeColorSchemes[themeName] || themeColorSchemes.dracula;
+    return scheme[key];
+}
+/**
+ * Get the background color hex value for the current theme
+ */
+function getThemeBgColor() {
+    const themeName = (0, theme_manager_1.getCurrentThemeName)();
+    return themeColorDefinitions[themeName]?.bg || themeColorDefinitions.dracula.bg;
+}
+/**
+ * Convert hex color to RGB
+ */
+function hexToRgb(hex) {
+    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+    return result
+        ? {
+            r: parseInt(result[1], 16),
+            g: parseInt(result[2], 16),
+            b: parseInt(result[3], 16),
+        }
+        : { r: 0, g: 0, b: 0 };
+}
+/**
+ * Get ANSI escape code to set terminal background color
+ */
+function getTerminalBgColorCode() {
+    const hex = getThemeBgColor();
+    const rgb = hexToRgb(hex);
+    return `\x1b[48;2;${rgb.r};${rgb.g};${rgb.b}m`;
+}
+/**
+ * Get ANSI escape code to reset terminal colors
+ */
+function getTerminalResetCode() {
+    return '\x1b[0m';
+}
+exports.themeColors = {
+    primary: () => getThemeColor('primary'),
+    secondary: () => getThemeColor('secondary'),
+    success: () => getThemeColor('success'),
+    warning: () => getThemeColor('warning'),
+    error: () => getThemeColor('error'),
+    border: () => getThemeColor('border'),
+    text: () => getThemeColor('text'),
+    textSecondary: () => getThemeColor('textSecondary'),
+    packageName: () => getThemeColor('packageName'),
+    versionRange: () => getThemeColor('versionRange'),
+    versionLatest: () => getThemeColor('versionLatest'),
+    dot: () => getThemeColor('dot'),
+    dotEmpty: () => getThemeColor('dotEmpty'),
+    bg: () => getThemeColor('bg'),
+};
+//# sourceMappingURL=themes-colors.js.map

package/dist/ui/themes.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.themeNames = exports.defaultTheme = exports.themes = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const themesMetadata = {
+    default: 'Default',
+    catppuccin: 'Catppuccin',
+    dracula: 'Dracula',
+    vsc: 'VS Code',
+    monokai: 'Monokai',
+    tokyonight: 'Tokyo Night',
+    onedark: 'One Dark',
+};
+// Theme definitions
+exports.themes = Object.entries(themesMetadata).reduce((acc, [key, name]) => {
+    acc[key] = {
+        name,
+        colors: chalk_1.default,
+    };
+    return acc;
+}, {});
+exports.defaultTheme = 'default';
+exports.themeNames = Object.keys(exports.themes);
+//# sourceMappingURL=themes.js.map