polyv-live-cli 1.1.2 → 1.1.5

package/dist/components/channel-status.panel.js

@@ -0,0 +1,858 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelStatusPanel = void 0;
+const blessed_1 = __importDefault(require("blessed"));
+const blessed_contrib_1 = require("blessed-contrib");
+const base_component_1 = require("./base.component");
+const channel_details_popup_1 = require("./channel-details.popup");
+const batch_operations_dialog_1 = require("./batch-operations.dialog");
+class ChannelStatusPanel extends base_component_1.BaseComponent {
+    constructor(config, eventBus) {
+        super(config, eventBus);
+        this.channels = [];
+        this.filteredChannels = [];
+        this.selectedChannels = new Set();
+        this.currentIndex = 0;
+        this.selectionStartIndex = -1;
+        this.isRangeSelecting = false;
+        this.lastJumpPosition = 0;
+        this.navigationHistory = [];
+        this.sortConfig = {
+            field: config.sortField || 'name',
+            order: config.sortOrder || 'asc'
+        };
+        this.filterConfig = config.filters || {};
+        this.lastUpdateTime = new Date();
+    }
+    createWidget() {
+        this.container = blessed_1.default.box({
+            label: ' Channel Status Monitor ',
+            border: { type: 'line' },
+            style: {
+                fg: 'white',
+                bg: 'black',
+                border: { fg: 'cyan' }
+            },
+            top: this.config.position.y,
+            left: this.config.position.x,
+            width: this.config.position.width,
+            height: this.config.position.height,
+            scrollable: false,
+            mouse: true,
+            keys: true,
+            vi: true,
+            tags: true
+        });
+        this.headerBox = blessed_1.default.box({
+            parent: this.container,
+            top: 0,
+            left: 0,
+            width: '100%',
+            height: 2,
+            content: this.getHeaderContent(),
+            style: { fg: 'yellow' },
+            tags: true
+        });
+        this.footerBox = blessed_1.default.box({
+            parent: this.container,
+            bottom: 0,
+            left: 0,
+            width: '100%',
+            height: 2,
+            content: this.getFooterContent(),
+            style: { fg: 'gray' },
+            tags: true
+        });
+        const tableConfig = {
+            keys: true,
+            interactive: true,
+            columnSpacing: 2,
+            columnWidth: this.getConfig().columnWidths || [20, 12, 10, 10, 15, 15],
+            style: {
+                fg: 'white',
+                bg: 'black',
+                border: { fg: 'gray' },
+                header: { fg: 'cyan', bold: true },
+                cell: { fg: 'white' },
+                selected: { bg: 'blue', fg: 'white' }
+            }
+        };
+        this.table = (0, blessed_contrib_1.table)(tableConfig);
+        this.table.parent = this.container;
+        this.table.top = 2;
+        this.table.left = 0;
+        this.table.width = '100%';
+        this.table.height = 'bottom-2';
+        this.noDataBox = blessed_1.default.box({
+            parent: this.container,
+            top: 'center',
+            left: 'center',
+            width: 'shrink',
+            height: 'shrink',
+            content: this.getNoDataMessage(),
+            style: { fg: 'gray' },
+            tags: true,
+            hidden: true
+        });
+        this.widget = this.container;
+        this.initializeDetailsPopup();
+        this.initializeBatchDialog();
+        this.setupKeyBindings();
+        this.updateTableDisplay();
+    }
+    initializeDetailsPopup() {
+        this.detailsPopup = new channel_details_popup_1.ChannelDetailsPopup({
+            screen: this.widget.screen,
+            eventBus: this.eventBus,
+            showColors: this.getConfig().showColors,
+            refreshInterval: this.getConfig().refreshInterval
+        });
+    }
+    initializeBatchDialog() {
+        this.batchDialog = new batch_operations_dialog_1.BatchOperationsDialog({
+            screen: this.widget.screen,
+            eventBus: this.eventBus,
+            showColors: this.getConfig().showColors
+        });
+    }
+    setupKeyBindings() {
+        this.container.key(['up', 'k'], () => {
+            this.moveSelection(-1);
+        });
+        this.container.key(['down', 'j'], () => {
+            this.moveSelection(1);
+        });
+        this.container.key(['pageup'], () => {
+            this.moveSelection(-10);
+        });
+        this.container.key(['pagedown'], () => {
+            this.moveSelection(10);
+        });
+        this.container.key(['home'], () => {
+            this.moveToTop();
+        });
+        this.container.key(['end'], () => {
+            this.moveToBottom();
+        });
+        this.container.key(['space'], () => {
+            this.toggleSelection();
+        });
+        this.container.key(['enter'], () => {
+            this.showChannelDetails();
+        });
+        this.container.key(['s'], () => {
+            this.cycleSortField();
+        });
+        this.container.key(['S'], () => {
+            this.toggleSortOrder();
+        });
+        this.container.key(['f'], () => {
+            this.showFilterDialog();
+        });
+        this.container.key(['F'], () => {
+            this.showAdvancedFilterDialog();
+        });
+        this.container.key(['c'], () => {
+            this.clearFilters();
+        });
+        this.container.key(['1'], () => {
+            this.quickFilterByStatus('live');
+        });
+        this.container.key(['2'], () => {
+            this.quickFilterByStatus('waiting');
+        });
+        this.container.key(['3'], () => {
+            this.quickFilterByStatus('end');
+        });
+        this.container.key(['4'], () => {
+            this.quickFilterByStatus('banpush');
+        });
+        this.container.key(['r', 'R', 'f5'], () => {
+            this.requestUpdate();
+        });
+        this.container.key(['a'], () => {
+            this.selectAll();
+        });
+        this.container.key(['A'], () => {
+            this.deselectAll();
+        });
+        this.container.key(['d'], () => {
+            this.showBatchOperations();
+        });
+        this.container.key(['g'], () => {
+            this.moveToTop();
+        });
+        this.container.key(['G'], () => {
+            this.moveToBottom();
+        });
+        this.container.key(['ctrl+f'], () => {
+            this.showQuickJumpDialog();
+        });
+        this.container.key(['ctrl+g'], () => {
+            this.showGoToLineDialog();
+        });
+        this.container.key(['shift+up', 'shift+k'], () => {
+            this.extendSelectionUp();
+        });
+        this.container.key(['shift+down', 'shift+j'], () => {
+            this.extendSelectionDown();
+        });
+        this.container.key(['ctrl+c'], () => {
+            this.copySelectionInfo();
+        });
+    }
+    render() {
+        if (this.isDestroyed || !this.widget)
+            return;
+        try {
+            this.updateHeader();
+            this.updateFooter();
+            this.updateTableDisplay();
+            this.widget.screen?.render();
+        }
+        catch (error) {
+            this.handleError(error instanceof Error ? error : new Error('Unknown render error'));
+        }
+    }
+    update(data) {
+        if (this.isDestroyed)
+            return;
+        try {
+            let channelsArray;
+            if (Array.isArray(data)) {
+                channelsArray = data;
+            }
+            else if ('channels' in data && Array.isArray(data.channels)) {
+                channelsArray = data.channels;
+            }
+            else {
+                channelsArray = [data];
+            }
+            this.channels = channelsArray.map(channel => this.convertToStatusInfo(channel));
+            this.applyFiltersAndSort();
+            this.lastUpdateTime = new Date();
+            this.updateState({ lastUpdate: this.lastUpdateTime });
+            if (this.channels.length === 0) {
+                this.noDataBox.show();
+                this.table.hide();
+            }
+            else {
+                this.noDataBox.hide();
+                this.table.show();
+            }
+            this.updateStatusColors();
+        }
+        catch (error) {
+            this.handleError(error instanceof Error ? error : new Error('Failed to update channel status'));
+        }
+    }
+    convertToStatusInfo(channel) {
+        const selectedChannels = this.selectedChannels || new Set();
+        return {
+            channelId: channel.channelId.toString(),
+            name: channel.name,
+            status: channel.watchStatus,
+            statusText: channel.watchStatusText,
+            viewerCount: channel.pageView || 0,
+            maxViewer: channel.maxViewer || 0,
+            publisher: channel.publisher || '',
+            startTime: channel.startTime || 0,
+            endTime: channel.endTime || 0,
+            createdTime: channel.createdTime || 0,
+            selected: selectedChannels.has(channel.channelId.toString())
+        };
+    }
+    compareValues(a, b) {
+        if (a === undefined && b === undefined)
+            return 0;
+        if (a === undefined)
+            return 1;
+        if (b === undefined)
+            return -1;
+        if (typeof a === 'string' && typeof b === 'string') {
+            return a.localeCompare(b);
+        }
+        if (typeof a === 'number' && typeof b === 'number') {
+            return a - b;
+        }
+        return String(a).localeCompare(String(b));
+    }
+    applyFiltersAndSort() {
+        const channels = this.channels || [];
+        this.filteredChannels = channels.filter(channel => {
+            if (this.filterConfig.status && this.filterConfig.status.length > 0) {
+                if (!this.filterConfig.status.includes(channel.status)) {
+                    return false;
+                }
+            }
+            if (this.filterConfig.searchTerm) {
+                const searchTerms = this.filterConfig.searchTerm.toLowerCase().split(' ').filter(term => term.length > 0);
+                const searchableText = `${channel.name} ${channel.channelId} ${channel.publisher} ${channel.statusText}`.toLowerCase();
+                const allTermsMatch = searchTerms.every(term => searchableText.includes(term));
+                if (!allTermsMatch) {
+                    return false;
+                }
+            }
+            if (this.filterConfig.viewerCountMin !== undefined && channel.viewerCount < this.filterConfig.viewerCountMin) {
+                return false;
+            }
+            if (this.filterConfig.viewerCountMax !== undefined && channel.viewerCount > this.filterConfig.viewerCountMax) {
+                return false;
+            }
+            if (this.filterConfig.publisherFilter) {
+                const publisherFilter = this.filterConfig.publisherFilter.toLowerCase();
+                if (!channel.publisher.toLowerCase().includes(publisherFilter)) {
+                    return false;
+                }
+            }
+            if (this.filterConfig.dateRange) {
+                const channelDate = new Date(channel.createdTime);
+                if (this.filterConfig.dateRange.startDate && channelDate < this.filterConfig.dateRange.startDate) {
+                    return false;
+                }
+                if (this.filterConfig.dateRange.endDate && channelDate > this.filterConfig.dateRange.endDate) {
+                    return false;
+                }
+            }
+            return true;
+        });
+        this.filteredChannels.sort((a, b) => {
+            const aVal = a[this.sortConfig.field];
+            const bVal = b[this.sortConfig.field];
+            let comparison = this.compareValues(aVal, bVal);
+            if (comparison === 0 && this.sortConfig.secondaryField) {
+                const aSecVal = a[this.sortConfig.secondaryField];
+                const bSecVal = b[this.sortConfig.secondaryField];
+                comparison = this.compareValues(aSecVal, bSecVal);
+                if (this.sortConfig.secondaryOrder === 'desc') {
+                    comparison = -comparison;
+                }
+            }
+            return this.sortConfig.order === 'asc' ? comparison : -comparison;
+        });
+        const filteredChannels = this.filteredChannels || [];
+        if (this.currentIndex >= filteredChannels.length) {
+            this.currentIndex = Math.max(0, filteredChannels.length - 1);
+        }
+    }
+    updateTableDisplay() {
+        if (!this.table)
+            return;
+        const headers = ['Channel Name', 'Status', 'Viewers', 'Max', 'Publisher', 'Created'];
+        const data = [];
+        const channels = this.filteredChannels || [];
+        const selectedChannels = this.selectedChannels || new Set();
+        for (let i = 0; i < channels.length; i++) {
+            const channel = channels[i];
+            if (!channel)
+                continue;
+            const isSelected = selectedChannels.has(channel.channelId);
+            const isCurrent = i === this.currentIndex;
+            const row = [
+                this.formatCellValue(channel.name, isSelected, isCurrent),
+                this.formatStatusCell(channel.status, channel.statusText, isSelected, isCurrent),
+                this.formatCellValue(channel.viewerCount.toString(), isSelected, isCurrent),
+                this.formatCellValue(channel.maxViewer.toString(), isSelected, isCurrent),
+                this.formatCellValue(channel.publisher, isSelected, isCurrent),
+                this.formatCellValue(this.formatDate(new Date(channel.createdTime)), isSelected, isCurrent)
+            ];
+            data.push(row);
+        }
+        this.table.setData({
+            headers,
+            data
+        });
+    }
+    formatCellValue(value, isSelected, isCurrent) {
+        if (isCurrent) {
+            return `{inverse}${isSelected ? '✓ ' : ''}${value}{/inverse}`;
+        }
+        return isSelected ? `{cyan-fg}✓ ${value}{/cyan-fg}` : value;
+    }
+    formatStatusCell(status, statusText, isSelected, isCurrent) {
+        const colors = this.getStatusColors(status);
+        const safeColor = this.getTerminalSafeColor(colors.fg);
+        const prefix = isCurrent ? '{inverse}' : '';
+        const suffix = isCurrent ? '{/inverse}' : '';
+        const checkmark = isSelected ? '✓ ' : '';
+        const icon = colors.icon || '';
+        const healthLevel = this.getStatusHealthLevel(status);
+        let statusDisplay = statusText;
+        switch (healthLevel) {
+            case 'healthy':
+                statusDisplay = `${icon} ${statusText}`;
+                break;
+            case 'warning':
+                statusDisplay = `${icon} ${statusText}`;
+                break;
+            case 'error':
+                statusDisplay = `${icon} ${statusText}`;
+                break;
+        }
+        return `${prefix}{${safeColor}-fg}${checkmark}${statusDisplay}{/${safeColor}-fg}${suffix}`;
+    }
+    updateStatusColors() {
+        this.throttledRender();
+        this.emit('component:statusChanged', {
+            componentId: this.state.id,
+            healthSummary: this.getChannelHealthSummary(),
+            timestamp: new Date()
+        });
+    }
+    getChannelHealthSummary() {
+        const channels = this.filteredChannels || [];
+        const summary = { healthy: 0, warning: 0, error: 0 };
+        channels.forEach(channel => {
+            const healthLevel = this.getStatusHealthLevel(channel.status);
+            summary[healthLevel]++;
+        });
+        return summary;
+    }
+    getStatusColors(status) {
+        switch (status) {
+            case 'live':
+                return { fg: 'green', icon: '●' };
+            case 'waiting':
+                return { fg: 'yellow', icon: '◯' };
+            case 'end':
+                return { fg: 'gray', icon: '◦' };
+            case 'unStart':
+                return { fg: 'gray', icon: '◦' };
+            case 'banpush':
+                return { fg: 'red', icon: '✖' };
+            case 'playback':
+                return { fg: 'blue', icon: '▶' };
+            default:
+                return { fg: 'white', icon: '?' };
+        }
+    }
+    getTerminalSafeColor(color) {
+        const config = this.getConfig();
+        if (!config.showColors) {
+            return 'white';
+        }
+        const colorMapping = {
+            'green': 'green',
+            'yellow': 'yellow',
+            'red': 'red',
+            'blue': 'blue',
+            'gray': 'gray',
+            'white': 'white'
+        };
+        return colorMapping[color] || 'white';
+    }
+    getStatusHealthLevel(status) {
+        switch (status) {
+            case 'live':
+                return 'healthy';
+            case 'waiting':
+            case 'playback':
+                return 'warning';
+            case 'banpush':
+                return 'error';
+            case 'end':
+            case 'unStart':
+            default:
+                return 'warning';
+        }
+    }
+    formatDate(date) {
+        return date.toLocaleDateString();
+    }
+    updateHeader() {
+        this.headerBox.setContent(this.getHeaderContent());
+    }
+    updateFooter() {
+        this.footerBox.setContent(this.getFooterContent());
+    }
+    getHeaderContent() {
+        const total = this.channels?.length || 0;
+        const filtered = this.filteredChannels?.length || 0;
+        const selected = this.selectedChannels?.size || 0;
+        const lastUpdate = this.lastUpdateTime?.toLocaleTimeString() || 'Never';
+        const health = this.getChannelHealthSummary();
+        const healthDisplay = `{green-fg}●${health.healthy}{/green-fg} {yellow-fg}◯${health.warning}{/yellow-fg} {red-fg}✖${health.error}{/red-fg}`;
+        return `Total: {bold}${total}{/bold} | Displayed: {bold}${filtered}{/bold} | Selected: {cyan-fg}${selected}{/cyan-fg} | Health: ${healthDisplay} | Updated: {gray-fg}${lastUpdate}{/gray-fg}`;
+    }
+    getFooterContent() {
+        const activeFilters = this.filterConfig ? Object.keys(this.filterConfig).length : 0;
+        const filterInfo = activeFilters > 0 ? `{yellow-fg}[${activeFilters} filters]{/yellow-fg}` : '';
+        const sortInfo = this.sortConfig?.secondaryField ? `{cyan-fg}[Multi-sort]{/cyan-fg}` : '';
+        return `{gray-fg}↑↓: Navigate | Space: Select | Enter: Details | S: Sort | Shift+S: Order | F: Filter | Shift+F: Advanced | 1-4: Quick Filter | C: Clear | R: Refresh{/gray-fg} ${filterInfo} ${sortInfo}`;
+    }
+    getNoDataMessage() {
+        return '{center}{gray-fg}No channel data available{/gray-fg}\n{center}{gray-fg}Waiting for channel information...{/gray-fg}{/center}';
+    }
+    moveSelection(delta) {
+        const channels = this.filteredChannels || [];
+        if (channels.length === 0)
+            return;
+        this.currentIndex = Math.max(0, Math.min(channels.length - 1, this.currentIndex + delta));
+        this.throttledRender();
+    }
+    moveToTop() {
+        this.saveNavigationHistory();
+        this.currentIndex = 0;
+        this.isRangeSelecting = false;
+        this.throttledRender();
+        this.emitNavigationEvent('moveToTop');
+    }
+    moveToBottom() {
+        const channels = this.filteredChannels || [];
+        this.saveNavigationHistory();
+        this.currentIndex = Math.max(0, channels.length - 1);
+        this.isRangeSelecting = false;
+        this.throttledRender();
+        this.emitNavigationEvent('moveToBottom');
+    }
+    showQuickJumpDialog() {
+        this.emit('component:quickJumpDialog', {
+            componentId: this.state.id,
+            currentIndex: this.currentIndex,
+            totalItems: this.filteredChannels?.length || 0,
+            timestamp: new Date()
+        });
+    }
+    showGoToLineDialog() {
+        this.emit('component:goToLineDialog', {
+            componentId: this.state.id,
+            currentLine: this.currentIndex + 1,
+            totalLines: this.filteredChannels?.length || 0,
+            timestamp: new Date()
+        });
+    }
+    extendSelectionUp() {
+        const channels = this.filteredChannels || [];
+        if (channels.length === 0)
+            return;
+        if (!this.isRangeSelecting) {
+            this.selectionStartIndex = this.currentIndex;
+            this.isRangeSelecting = true;
+        }
+        const newIndex = Math.max(0, this.currentIndex - 1);
+        this.updateRangeSelection(newIndex);
+    }
+    extendSelectionDown() {
+        const channels = this.filteredChannels || [];
+        if (channels.length === 0)
+            return;
+        if (!this.isRangeSelecting) {
+            this.selectionStartIndex = this.currentIndex;
+            this.isRangeSelecting = true;
+        }
+        const newIndex = Math.min(channels.length - 1, this.currentIndex + 1);
+        this.updateRangeSelection(newIndex);
+    }
+    updateRangeSelection(newIndex) {
+        const channels = this.filteredChannels || [];
+        const selectedChannels = this.selectedChannels || new Set();
+        if (this.selectionStartIndex === -1)
+            return;
+        this.clearRangeSelection();
+        const startIndex = Math.min(this.selectionStartIndex, newIndex);
+        const endIndex = Math.max(this.selectionStartIndex, newIndex);
+        for (let i = startIndex; i <= endIndex; i++) {
+            const channel = channels[i];
+            if (channel) {
+                selectedChannels.add(channel.channelId);
+            }
+        }
+        this.currentIndex = newIndex;
+        this.throttledRender();
+    }
+    clearRangeSelection() {
+    }
+    copySelectionInfo() {
+        const selectedChannels = this.selectedChannels || new Set();
+        const channels = this.filteredChannels || [];
+        if (selectedChannels.size === 0 && this.currentIndex < channels.length) {
+            const currentChannel = channels[this.currentIndex];
+            if (currentChannel) {
+                this.copyChannelInfo(currentChannel);
+            }
+        }
+        else {
+            const selectedChannelData = channels.filter(c => selectedChannels.has(c.channelId));
+            this.copyMultipleChannelsInfo(selectedChannelData);
+        }
+    }
+    copyChannelInfo(channel) {
+        const info = `${channel.name} (${channel.channelId}) - ${channel.statusText} - ${channel.viewerCount} viewers`;
+        this.emit('component:copyToClipboard', {
+            componentId: this.state.id,
+            content: info,
+            type: 'singleChannel',
+            channel,
+            timestamp: new Date()
+        });
+    }
+    copyMultipleChannelsInfo(channels) {
+        const info = channels.map(c => `${c.name} (${c.channelId}) - ${c.statusText} - ${c.viewerCount} viewers`).join('\n');
+        this.emit('component:copyToClipboard', {
+            componentId: this.state.id,
+            content: info,
+            type: 'multipleChannels',
+            channels,
+            count: channels.length,
+            timestamp: new Date()
+        });
+    }
+    saveNavigationHistory() {
+        if (this.currentIndex !== this.lastJumpPosition) {
+            this.navigationHistory.push(this.lastJumpPosition);
+            if (this.navigationHistory.length > 10) {
+                this.navigationHistory.shift();
+            }
+            this.lastJumpPosition = this.currentIndex;
+        }
+    }
+    emitNavigationEvent(action) {
+        this.emit('component:navigation', {
+            componentId: this.state.id,
+            action,
+            currentIndex: this.currentIndex,
+            totalItems: this.filteredChannels?.length || 0,
+            timestamp: new Date()
+        });
+    }
+    jumpToLine(lineNumber) {
+        const channels = this.filteredChannels || [];
+        const targetIndex = lineNumber - 1;
+        if (targetIndex >= 0 && targetIndex < channels.length) {
+            this.saveNavigationHistory();
+            this.currentIndex = targetIndex;
+            this.isRangeSelecting = false;
+            this.throttledRender();
+            this.emitNavigationEvent('jumpToLine');
+            return true;
+        }
+        return false;
+    }
+    jumpToChannel(searchTerm) {
+        const channels = this.filteredChannels || [];
+        const lowerSearchTerm = searchTerm.toLowerCase();
+        const targetIndex = channels.findIndex(channel => channel.channelId.toLowerCase().includes(lowerSearchTerm) ||
+            channel.name.toLowerCase().includes(lowerSearchTerm));
+        if (targetIndex !== -1) {
+            this.saveNavigationHistory();
+            this.currentIndex = targetIndex;
+            this.isRangeSelecting = false;
+            this.throttledRender();
+            this.emitNavigationEvent('jumpToChannel');
+            return true;
+        }
+        return false;
+    }
+    toggleSelection() {
+        const channels = this.filteredChannels || [];
+        const selectedChannels = this.selectedChannels || new Set();
+        if (channels.length === 0)
+            return;
+        const currentChannel = channels[this.currentIndex];
+        if (!currentChannel)
+            return;
+        if (selectedChannels.has(currentChannel.channelId)) {
+            selectedChannels.delete(currentChannel.channelId);
+        }
+        else {
+            selectedChannels.add(currentChannel.channelId);
+        }
+        this.throttledRender();
+    }
+    selectAll() {
+        const channels = this.filteredChannels || [];
+        const selectedChannels = this.selectedChannels || new Set();
+        channels.forEach(channel => {
+            selectedChannels.add(channel.channelId);
+        });
+        this.throttledRender();
+    }
+    deselectAll() {
+        const selectedChannels = this.selectedChannels || new Set();
+        selectedChannels.clear();
+        this.throttledRender();
+    }
+    cycleSortField() {
+        const fields = ['name', 'status', 'viewerCount', 'maxViewer', 'publisher', 'createdTime'];
+        const currentIndex = fields.indexOf(this.sortConfig.field);
+        const nextIndex = (currentIndex + 1) % fields.length;
+        const nextField = fields[nextIndex];
+        if (nextField) {
+            if (this.sortConfig.secondaryField) {
+                this.sortConfig.field = this.sortConfig.secondaryField;
+                this.sortConfig.order = this.sortConfig.secondaryOrder || 'asc';
+                delete this.sortConfig.secondaryField;
+                delete this.sortConfig.secondaryOrder;
+            }
+            else {
+                this.sortConfig.field = nextField;
+            }
+        }
+        this.applyFiltersAndSort();
+        this.throttledRender();
+        this.emit('component:sortChanged', {
+            componentId: this.state.id,
+            sortConfig: this.sortConfig,
+            timestamp: new Date()
+        });
+    }
+    toggleSortOrder() {
+        this.sortConfig.order = this.sortConfig.order === 'asc' ? 'desc' : 'asc';
+        this.applyFiltersAndSort();
+        this.throttledRender();
+        this.emit('component:sortChanged', {
+            componentId: this.state.id,
+            sortConfig: this.sortConfig,
+            timestamp: new Date()
+        });
+    }
+    setMultiFieldSort(primary, primaryOrder, secondary, secondaryOrder) {
+        const newConfig = {
+            field: primary,
+            order: primaryOrder
+        };
+        if (secondary !== undefined) {
+            newConfig.secondaryField = secondary;
+        }
+        if (secondaryOrder !== undefined) {
+            newConfig.secondaryOrder = secondaryOrder;
+        }
+        this.sortConfig = newConfig;
+        this.applyFiltersAndSort();
+        this.throttledRender();
+        this.emit('component:sortChanged', {
+            componentId: this.state.id,
+            sortConfig: this.sortConfig,
+            changeType: 'multiField',
+            timestamp: new Date()
+        });
+    }
+    showFilterDialog() {
+        this.emit('component:filterDialog', {
+            componentId: this.state.id,
+            currentFilter: this.filterConfig,
+            type: 'basic',
+            timestamp: new Date()
+        });
+    }
+    showAdvancedFilterDialog() {
+        this.emit('component:advancedFilterDialog', {
+            componentId: this.state.id,
+            currentFilter: this.filterConfig,
+            availableFields: ['viewerCount', 'publisher', 'createdTime'],
+            timestamp: new Date()
+        });
+    }
+    quickFilterByStatus(status) {
+        if (this.filterConfig.status?.includes(status)) {
+            this.filterConfig.status = this.filterConfig.status.filter(s => s !== status);
+            if (this.filterConfig.status.length === 0) {
+                delete this.filterConfig.status;
+            }
+        }
+        else {
+            if (!this.filterConfig.status) {
+                this.filterConfig.status = [];
+            }
+            this.filterConfig.status.push(status);
+        }
+        this.applyFiltersAndSort();
+        this.throttledRender();
+        this.emit('component:filterChanged', {
+            componentId: this.state.id,
+            filter: this.filterConfig,
+            changeType: 'quickFilter',
+            status,
+            timestamp: new Date()
+        });
+    }
+    clearFilters() {
+        const hadFilters = Object.keys(this.filterConfig).length > 0;
+        this.filterConfig = {};
+        this.applyFiltersAndSort();
+        this.throttledRender();
+        if (hadFilters) {
+            this.emit('component:filtersCleared', {
+                componentId: this.state.id,
+                timestamp: new Date()
+            });
+        }
+    }
+    setAdvancedFilter(filter) {
+        this.filterConfig = { ...this.filterConfig, ...filter };
+        this.applyFiltersAndSort();
+        this.throttledRender();
+        this.emit('component:filterChanged', {
+            componentId: this.state.id,
+            filter: this.filterConfig,
+            changeType: 'advanced',
+            timestamp: new Date()
+        });
+    }
+    showChannelDetails() {
+        const channels = this.filteredChannels || [];
+        if (channels.length === 0)
+            return;
+        const currentChannel = channels[this.currentIndex];
+        if (!currentChannel)
+            return;
+        this.detailsPopup.show(currentChannel);
+        this.emit('component:showDetails', {
+            componentId: this.state.id,
+            channelId: currentChannel.channelId,
+            channel: currentChannel,
+            timestamp: new Date()
+        });
+    }
+    showBatchOperations() {
+        const selectedChannels = this.selectedChannels || new Set();
+        if (selectedChannels.size === 0)
+            return;
+        this.batchDialog.show(Array.from(selectedChannels));
+        this.emit('component:batchOperations', {
+            componentId: this.state.id,
+            selectedChannels: Array.from(selectedChannels),
+            timestamp: new Date()
+        });
+    }
+    getConfig() {
+        return this.config;
+    }
+    getSelectedChannels() {
+        return Array.from(this.selectedChannels || new Set());
+    }
+    getCurrentChannel() {
+        const channels = this.filteredChannels || [];
+        return channels[this.currentIndex] || null;
+    }
+    setFilter(filter) {
+        this.filterConfig = filter;
+        this.applyFiltersAndSort();
+        this.throttledRender();
+    }
+    setSort(sort) {
+        this.sortConfig = sort;
+        this.applyFiltersAndSort();
+        this.throttledRender();
+    }
+    destroy() {
+        this.stopRefresh();
+        this.channels = [];
+        this.filteredChannels = [];
+        if (this.selectedChannels) {
+            this.selectedChannels.clear();
+        }
+        if (this.detailsPopup) {
+            this.detailsPopup.destroy();
+        }
+        if (this.batchDialog) {
+            this.batchDialog.destroy();
+        }
+        super.destroy();
+    }
+}
+exports.ChannelStatusPanel = ChannelStatusPanel;
+//# sourceMappingURL=channel-status.panel.js.map