openvsx-webui-test 0.17.2 → 0.18.0-dev.1

package/src/hooks/scan-admin/use-scan-filters.ts

@@ -0,0 +1,83 @@
+/********************************************************************************
+ * Copyright (c) 2026 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * https://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ ********************************************************************************/
+
+import { useMemo } from 'react';
+import { useScanContext } from '../../context/scan-admin';
+
+/**
+ * Hook for managing scan filter state and actions.
+ * Provides access to global filters (date range, enforcement) and
+ * tab-specific filters (status, quarantine, threat scanner, validation type).
+ */
+export const useScanFilters = () => {
+    const { state, actions } = useScanContext();
+
+    // Global filters
+    const globalFilters = useMemo(() => ({
+        dateRange: state.dateRange,
+        enforcement: state.enforcement,
+        setDateRange: actions.setDateRange,
+        setEnforcement: actions.setEnforcement,
+    }), [state.dateRange, state.enforcement, actions]);
+
+    // Status filters (for Scans tab)
+    const statusFilters = useMemo(() => ({
+        filters: state.statusFilters,
+        toggle: actions.toggleStatusFilter,
+        menuAnchor: state.filterMenuAnchor,
+        openMenu: actions.openFilterMenu,
+        closeMenu: actions.closeFilterMenu,
+    }), [state.statusFilters, state.filterMenuAnchor, actions]);
+
+    // Quarantine filters (for Quarantined tab)
+    const quarantineFilters = useMemo(() => ({
+        filters: state.quarantineFilters,
+        toggle: actions.toggleQuarantineFilter,
+        threatScannerFilters: state.threatScannerFilters,
+        toggleThreatScanner: actions.toggleThreatScannerFilter,
+        availableThreatScanners: state.availableThreatScanners,
+        menuAnchor: state.quarantineFilterMenuAnchor,
+        openMenu: actions.openQuarantineFilterMenu,
+        closeMenu: actions.closeQuarantineFilterMenu,
+    }), [
+        state.quarantineFilters,
+        state.threatScannerFilters,
+        state.availableThreatScanners,
+        state.quarantineFilterMenuAnchor,
+        actions,
+    ]);
+
+    // Validation type filters (for Auto Rejected tab)
+    const validationTypeFilters = useMemo(() => ({
+        filters: state.validationTypeFilters,
+        toggle: actions.toggleValidationTypeFilter,
+        availableValidationTypes: state.availableValidationTypes,
+        menuAnchor: state.autoRejectedFilterMenuAnchor,
+        openMenu: actions.openAutoRejectedFilterMenu,
+        closeMenu: actions.closeAutoRejectedFilterMenu,
+    }), [
+        state.validationTypeFilters,
+        state.availableValidationTypes,
+        state.autoRejectedFilterMenuAnchor,
+        actions,
+    ]);
+
+    return {
+        globalFilters,
+        statusFilters,
+        quarantineFilters,
+        validationTypeFilters,
+    };
+};
+
+export type UseScanFiltersReturn = ReturnType<typeof useScanFilters>;

package/src/hooks/scan-admin/use-scans-tab.ts

@@ -0,0 +1,92 @@
+/********************************************************************************
+ * Copyright (c) 2026 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * https://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ ********************************************************************************/
+
+import { useMemo } from 'react';
+import { useScanContext } from '../../context/scan-admin';
+import { useScanFilters } from './use-scan-filters';
+import { usePagination } from './use-pagination';
+import { useSearch } from './use-search';
+
+/**
+ * Hook for the main Scans tab (tab index 0).
+ * Provides all data and actions needed for displaying scan overview.
+ */
+export const useScansTab = () => {
+    const { state, actions } = useScanContext();
+    const { globalFilters, statusFilters } = useScanFilters();
+    const pagination = usePagination();
+    const search = useSearch();
+
+    // Get scan counts for display
+    const counts = useMemo(() => {
+        if (!state.scanCounts) {
+            return {
+                started: 0,
+                validating: 0,
+                scanning: 0,
+                passed: 0,
+                quarantined: 0,
+                autoRejected: 0,
+                error: 0,
+                allowed: 0,
+                blocked: 0,
+                needsReview: 0,
+                total: 0,
+            };
+        }
+        return {
+            started: state.scanCounts.STARTED,
+            validating: state.scanCounts.VALIDATING,
+            scanning: state.scanCounts.SCANNING,
+            passed: state.scanCounts.PASSED,
+            quarantined: state.scanCounts.QUARANTINED,
+            autoRejected: state.scanCounts.AUTO_REJECTED,
+            error: state.scanCounts.ERROR,
+            allowed: state.scanCounts.ALLOWED,
+            blocked: state.scanCounts.BLOCKED,
+            needsReview: state.scanCounts.NEEDS_REVIEW,
+            // Total = sum of scan statuses only (ALLOWED/BLOCKED/NEEDS_REVIEW are admin decisions, not statuses)
+            total: state.scanCounts.STARTED + state.scanCounts.VALIDATING + state.scanCounts.SCANNING +
+                   state.scanCounts.PASSED + state.scanCounts.QUARANTINED + state.scanCounts.AUTO_REJECTED +
+                   state.scanCounts.ERROR,
+        };
+    }, [state.scanCounts]);
+
+    return useMemo(() => ({
+        tabIndex: 0,
+        tabName: 'Scans',
+        scans: state.scans,
+        isLoading: state.isLoadingScans,
+        lastRefreshed: state.lastRefreshed,
+        autoRefresh: state.autoRefresh,
+        onAutoRefreshChange: actions.setAutoRefresh,
+        counts,
+        search,
+        globalFilters,
+        statusFilters,
+        pagination,
+    }), [
+        state.scans,
+        state.isLoadingScans,
+        state.lastRefreshed,
+        state.autoRefresh,
+        actions.setAutoRefresh,
+        counts,
+        search,
+        globalFilters,
+        statusFilters,
+        pagination,
+    ]);
+};
+
+export type UseScansTabReturn = ReturnType<typeof useScansTab>;

package/src/hooks/scan-admin/use-search.ts

@@ -0,0 +1,54 @@
+/********************************************************************************
+ * Copyright (c) 2026 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * https://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ ********************************************************************************/
+
+import { useMemo, useCallback } from 'react';
+import { useScanContext } from '../../context/scan-admin';
+
+/**
+ * Hook for managing search state and actions.
+ * Provides publisher, namespace, and name search functionality.
+ */
+export const useSearch = () => {
+    const { state, actions, dispatch } = useScanContext();
+
+    const clearSearch = useCallback(() => {
+        dispatch({ type: 'CLEAR_SEARCH' });
+    }, [dispatch]);
+
+    const hasActiveSearch = useMemo(() => {
+        return !!(state.publisherQuery || state.namespaceQuery || state.nameQuery);
+    }, [state.publisherQuery, state.namespaceQuery, state.nameQuery]);
+
+    return useMemo(() => ({
+        publisherQuery: state.publisherQuery,
+        namespaceQuery: state.namespaceQuery,
+        nameQuery: state.nameQuery,
+        setPublisherQuery: actions.setPublisherQuery,
+        setNamespaceQuery: actions.setNamespaceQuery,
+        setNameQuery: actions.setNameQuery,
+        handlePublisherChange: actions.handlePublisherChange,
+        handleNamespaceChange: actions.handleNamespaceChange,
+        handleNameChange: actions.handleNameChange,
+        clearSearch,
+        hasActiveSearch,
+    }), [
+        state.publisherQuery,
+        state.namespaceQuery,
+        state.nameQuery,
+        actions,
+        clearSearch,
+        hasActiveSearch,
+    ]);
+};
+
+export type UseSearchReturn = ReturnType<typeof useSearch>;

package/src/hooks/scan-admin/use-tab-navigation.ts

@@ -0,0 +1,82 @@
+/********************************************************************************
+ * Copyright (c) 2026 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * https://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ ********************************************************************************/
+
+import { useMemo, useCallback } from 'react';
+import { useScanContext } from '../../context/scan-admin';
+
+/**
+ * Tab definitions for the Scans Admin page.
+ */
+export const TAB_DEFINITIONS = [
+    { index: 0, name: 'Scans', path: 'scans' },
+    { index: 1, name: 'Quarantined', path: 'quarantined' },
+    { index: 2, name: 'Auto Rejected', path: 'auto-rejected' },
+    { index: 3, name: 'Allowed Files', path: 'allowed-files' },
+    { index: 4, name: 'Blocked Files', path: 'blocked-files' },
+] as const;
+
+export type TabIndex = 0 | 1 | 2 | 3 | 4;
+export type TabName = typeof TAB_DEFINITIONS[number]['name'];
+
+/**
+ * Hook for managing tab navigation state and actions.
+ */
+export const useTabNavigation = () => {
+    const { state, actions } = useScanContext();
+
+    const setTab = useCallback((tab: number) => {
+        if (tab >= 0 && tab <= 4) {
+            actions.setTab(tab);
+        }
+    }, [actions]);
+
+    const currentTab = useMemo(() => {
+        return TAB_DEFINITIONS[state.selectedTab] || TAB_DEFINITIONS[0];
+    }, [state.selectedTab]);
+
+    const isScansTab = state.selectedTab === 0;
+    const isQuarantinedTab = state.selectedTab === 1;
+    const isAutoRejectedTab = state.selectedTab === 2;
+    const isAllowListTab = state.selectedTab === 3;
+    const isBlockListTab = state.selectedTab === 4;
+
+    const isScanDataTab = state.selectedTab <= 2;
+    const isFileDataTab = state.selectedTab >= 3;
+
+    return useMemo(() => ({
+        selectedTab: state.selectedTab,
+        currentTab,
+        tabs: TAB_DEFINITIONS,
+        setTab,
+        isScansTab,
+        isQuarantinedTab,
+        isAutoRejectedTab,
+        isAllowListTab,
+        isBlockListTab,
+        isScanDataTab,
+        isFileDataTab,
+    }), [
+        state.selectedTab,
+        currentTab,
+        setTab,
+        isScansTab,
+        isQuarantinedTab,
+        isAutoRejectedTab,
+        isAllowListTab,
+        isBlockListTab,
+        isScanDataTab,
+        isFileDataTab,
+    ]);
+};
+
+export type UseTabNavigationReturn = ReturnType<typeof useTabNavigation>;

package/src/hooks/scan-admin/use-url-sync.ts

@@ -0,0 +1,293 @@
+/********************************************************************************
+ * Copyright (c) 2026 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * https://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ ********************************************************************************/
+
+import { useEffect, useRef, useCallback } from 'react';
+import { useScanContext } from '../../context/scan-admin';
+import { DateRangeType, EnforcementType } from '../../context/scan-admin/scan-types';
+
+/**
+ * URL parameter keys
+ */
+const URL_PARAMS = {
+    TAB: 'tab',
+    PAGE: 'page',
+    PUBLISHER: 'publisher',
+    NAMESPACE: 'namespace',
+    NAME: 'name',
+    DATE_RANGE: 'dateRange',
+    FILE_DATE_RANGE: 'fileDateRange',
+    ENFORCEMENT: 'enforcement',
+    // Checkbox filters
+    STATUS_FILTERS: 'status',
+    QUARANTINE_FILTERS: 'quarantine',
+    THREAT_SCANNER_FILTERS: 'threatScanner',
+    VALIDATION_TYPE_FILTERS: 'validationType',
+} as const;
+
+/**
+ * Tab name to index mapping
+ */
+const TAB_NAME_TO_INDEX: Record<string, number> = {
+    'scans': 0,
+    'quarantined': 1,
+    'auto-rejected': 2,
+    'allowed-files': 3,
+    'blocked-files': 4,
+};
+
+const TAB_INDEX_TO_NAME: Record<number, string> = {
+    0: 'scans',
+    1: 'quarantined',
+    2: 'auto-rejected',
+    3: 'allowed-files',
+    4: 'blocked-files',
+};
+
+/**
+ * Valid date range values
+ */
+const VALID_DATE_RANGES: DateRangeType[] = ['today', 'last7days', 'last30days', 'last90days', 'all'];
+
+/**
+ * Valid enforcement values
+ */
+const VALID_ENFORCEMENTS: EnforcementType[] = ['enforced', 'notEnforced', 'all'];
+
+/**
+ * Hook to sync scan admin state with URL parameters.
+ * This enables bookmarkable URLs and browser back/forward navigation.
+ */
+export const useUrlSync = () => {
+    const { state, dispatch } = useScanContext();
+    const isInitialized = useRef(false);
+    const isUpdatingFromUrl = useRef(false);
+
+    /**
+     * Parse URL parameters and apply to state on initial load
+     */
+    const initializeFromUrl = useCallback(() => {
+        const params = new URLSearchParams(window.location.search);
+
+        // Tab
+        const tabParam = params.get(URL_PARAMS.TAB);
+        if (tabParam && TAB_NAME_TO_INDEX[tabParam] !== undefined) {
+            dispatch({ type: 'SET_TAB', payload: TAB_NAME_TO_INDEX[tabParam] });
+        }
+
+        // Page (URL is 1-indexed, state is 0-indexed)
+        const pageParam = params.get(URL_PARAMS.PAGE);
+        if (pageParam) {
+            const page = parseInt(pageParam, 10);
+            if (!isNaN(page) && page >= 1) {
+                dispatch({ type: 'SET_PAGE', payload: page - 1 });
+            }
+        }
+
+        // Search queries
+        const publisherParam = params.get(URL_PARAMS.PUBLISHER);
+        if (publisherParam) {
+            dispatch({ type: 'SET_PUBLISHER_QUERY', payload: publisherParam });
+        }
+
+        const namespaceParam = params.get(URL_PARAMS.NAMESPACE);
+        if (namespaceParam) {
+            dispatch({ type: 'SET_NAMESPACE_QUERY', payload: namespaceParam });
+        }
+
+        const nameParam = params.get(URL_PARAMS.NAME);
+        if (nameParam) {
+            dispatch({ type: 'SET_NAME_QUERY', payload: nameParam });
+        }
+
+        // Date range
+        const dateRangeParam = params.get(URL_PARAMS.DATE_RANGE);
+        if (dateRangeParam && VALID_DATE_RANGES.indexOf(dateRangeParam as DateRangeType) !== -1) {
+            dispatch({ type: 'SET_DATE_RANGE', payload: dateRangeParam as DateRangeType });
+        }
+
+        // File date range
+        const fileDateRangeParam = params.get(URL_PARAMS.FILE_DATE_RANGE);
+        if (fileDateRangeParam && VALID_DATE_RANGES.indexOf(fileDateRangeParam as DateRangeType) !== -1) {
+            dispatch({ type: 'SET_FILE_DATE_RANGE', payload: fileDateRangeParam as DateRangeType });
+        }
+
+        // Enforcement
+        const enforcementParam = params.get(URL_PARAMS.ENFORCEMENT);
+        if (enforcementParam && VALID_ENFORCEMENTS.indexOf(enforcementParam as EnforcementType) !== -1) {
+            dispatch({ type: 'SET_ENFORCEMENT', payload: enforcementParam as EnforcementType });
+        }
+
+        // Status filters (comma-separated)
+        const statusFiltersParam = params.get(URL_PARAMS.STATUS_FILTERS);
+        if (statusFiltersParam) {
+            const filters = new Set(statusFiltersParam.split(',').filter(Boolean));
+            if (filters.size > 0) {
+                dispatch({ type: 'SET_STATUS_FILTERS', payload: filters });
+            }
+        }
+
+        // Quarantine filters (comma-separated)
+        const quarantineFiltersParam = params.get(URL_PARAMS.QUARANTINE_FILTERS);
+        if (quarantineFiltersParam) {
+            const filters = new Set(quarantineFiltersParam.split(',').filter(Boolean));
+            if (filters.size > 0) {
+                dispatch({ type: 'SET_QUARANTINE_FILTERS', payload: filters });
+            }
+        }
+
+        // Threat scanner filters (comma-separated)
+        const threatScannerFiltersParam = params.get(URL_PARAMS.THREAT_SCANNER_FILTERS);
+        if (threatScannerFiltersParam) {
+            const filters = new Set(threatScannerFiltersParam.split(',').filter(Boolean));
+            if (filters.size > 0) {
+                dispatch({ type: 'SET_THREAT_SCANNER_FILTERS', payload: filters });
+            }
+        }
+
+        // Validation type filters (comma-separated)
+        const validationTypeFiltersParam = params.get(URL_PARAMS.VALIDATION_TYPE_FILTERS);
+        if (validationTypeFiltersParam) {
+            const filters = new Set(validationTypeFiltersParam.split(',').filter(Boolean));
+            if (filters.size > 0) {
+                dispatch({ type: 'SET_VALIDATION_TYPE_FILTERS', payload: filters });
+            }
+        }
+    }, [dispatch]);
+
+    /**
+     * Update URL parameters from state
+     */
+    const updateUrlFromState = useCallback(() => {
+        if (isUpdatingFromUrl.current) {
+            return;
+        }
+
+        const params = new URLSearchParams();
+
+        // Tab (only add if not default)
+        if (state.selectedTab !== 0) {
+            params.set(URL_PARAMS.TAB, TAB_INDEX_TO_NAME[state.selectedTab] || 'scans');
+        }
+
+        // Page (only add if not first page, URL is 1-indexed)
+        if (state.currentPage > 0) {
+            params.set(URL_PARAMS.PAGE, String(state.currentPage + 1));
+        }
+
+        // Search queries (only add if not empty)
+        if (state.publisherQuery) {
+            params.set(URL_PARAMS.PUBLISHER, state.publisherQuery);
+        }
+        if (state.namespaceQuery) {
+            params.set(URL_PARAMS.NAMESPACE, state.namespaceQuery);
+        }
+        if (state.nameQuery) {
+            params.set(URL_PARAMS.NAME, state.nameQuery);
+        }
+
+        // Date range (only add if not default)
+        if (state.dateRange !== 'all') {
+            params.set(URL_PARAMS.DATE_RANGE, state.dateRange);
+        }
+
+        // File date range (only add if not default)
+        if (state.fileDateRange !== 'all') {
+            params.set(URL_PARAMS.FILE_DATE_RANGE, state.fileDateRange);
+        }
+
+        // Enforcement (only add if not tab-specific default)
+        // Tabs 1 (Quarantined) and 2 (Auto Rejected) default to 'enforced', others default to 'all'
+        const defaultEnforcement = (state.selectedTab === 1 || state.selectedTab === 2) ? 'enforced' : 'all';
+        if (state.enforcement !== defaultEnforcement) {
+            params.set(URL_PARAMS.ENFORCEMENT, state.enforcement);
+        }
+
+        // Status filters (only add if any are selected)
+        if (state.statusFilters.size > 0) {
+            params.set(URL_PARAMS.STATUS_FILTERS, Array.from(state.statusFilters).join(','));
+        }
+
+        // Quarantine filters (only add if any are selected - default is empty)
+        if (state.quarantineFilters.size > 0) {
+            params.set(URL_PARAMS.QUARANTINE_FILTERS, Array.from(state.quarantineFilters).join(','));
+        }
+
+        // Threat scanner filters (only add if any are selected)
+        if (state.threatScannerFilters.size > 0) {
+            params.set(URL_PARAMS.THREAT_SCANNER_FILTERS, Array.from(state.threatScannerFilters).join(','));
+        }
+
+        // Validation type filters (only add if any are selected)
+        if (state.validationTypeFilters.size > 0) {
+            params.set(URL_PARAMS.VALIDATION_TYPE_FILTERS, Array.from(state.validationTypeFilters).join(','));
+        }
+
+        // Build new URL
+        const newSearch = params.toString();
+        const newUrl = newSearch
+            ? `${window.location.pathname}?${newSearch}`
+            : window.location.pathname;
+
+        // Update URL without triggering a page reload
+        if (window.location.search !== (newSearch ? `?${newSearch}` : '')) {
+            window.history.replaceState(null, '', newUrl);
+        }
+    }, [state.selectedTab, state.currentPage, state.publisherQuery, state.namespaceQuery, state.nameQuery, state.dateRange, state.fileDateRange, state.enforcement, state.statusFilters, state.quarantineFilters, state.threatScannerFilters, state.validationTypeFilters]);
+
+    /**
+     * Handle browser back/forward navigation
+     */
+    const handlePopState = useCallback(() => {
+        isUpdatingFromUrl.current = true;
+        initializeFromUrl();
+        // Reset the flag after a short delay to allow state to settle
+        setTimeout(() => {
+            isUpdatingFromUrl.current = false;
+        }, 100);
+    }, [initializeFromUrl]);
+
+    // Initialize from URL on mount
+    useEffect(() => {
+        if (!isInitialized.current) {
+            isInitialized.current = true;
+            isUpdatingFromUrl.current = true;
+            initializeFromUrl();
+            // Reset the flag after initialization
+            setTimeout(() => {
+                isUpdatingFromUrl.current = false;
+            }, 100);
+        }
+    }, [initializeFromUrl]);
+
+    // Update URL when state changes
+    useEffect(() => {
+        if (isInitialized.current) {
+            updateUrlFromState();
+        }
+    }, [updateUrlFromState]);
+
+    // Listen for browser back/forward
+    useEffect(() => {
+        window.addEventListener('popstate', handlePopState);
+        return () => {
+            window.removeEventListener('popstate', handlePopState);
+        };
+    }, [handlePopState]);
+
+    return {
+        initializeFromUrl,
+        updateUrlFromState,
+    };
+};
+
+export type UseUrlSyncReturn = ReturnType<typeof useUrlSync>;

package/src/page-settings.ts

@@ -16,6 +16,10 @@ import { Cookie } from './utils';
 export interface PageSettings {
     pageTitle: string;
     themeType?: 'light' | 'dark';
+    publisherAgreement?: {
+        name?: string;
+        email?: string;
+    };
     elements: {
         toolbarContent?: ComponentType;
         defaultMenuContent?: ComponentType;