Skip to content

armgit / Pulse

Public Imported from GitHub
0

Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.

22.5 KB
Raw Blame
import { createEffect, createMemo, createSignal, onMount, type Accessor } from 'solid-js';
import { useLocation, useNavigate } from '@solidjs/router';

import { recordWorkloadHistoryActivity } from '@/api/workloadHistoryActivity';
import { useBreakpoint } from '@/hooks/useBreakpoint';
import { useColumnVisibility } from '@/hooks/useColumnVisibility';
import { usePersistentSignal } from '@/hooks/usePersistentSignal';
import { blurFocusedTypeToSearch } from '@/hooks/useTypeToSearch';
import { STORAGE_KEYS } from '@/utils/localStorage';
import type { ViewMode, WorkloadType } from '@/types/workloads';

import {
  GUEST_COLUMNS,
  VIEW_MODE_COLUMNS,
  getWorkloadTableLayoutModeForContainer,
  getWorkloadTableLayoutMode,
  getWorkloadVisibleColumnsForLayout,
  resolveWorkloadColumnViewMode,
} from './guestRowModel';
import {
  DEFAULT_WORKLOADS_SORT_DIRECTION,
  DEFAULT_WORKLOADS_SORT_KEY,
  DEFAULT_WORKLOADS_METRIC_DISPLAY_MODE,
  DEFAULT_WORKLOADS_METRIC_HOVER_MODE,
  DEFAULT_WORKLOADS_STATUS_MODE,
  type WorkloadsGroupingMode,
  type WorkloadsMetricDisplayMode,
  type WorkloadsMetricHoverMode,
  type WorkloadsSortKey,
  type WorkloadsStatusMode,
} from './workloadsFilterModel';
import {
  isWorkloadTableMetricHistoryRange,
  WORKLOAD_TABLE_HISTORY_DEFAULT_RANGE,
  type WorkloadTableMetricHistoryRange,
} from './workloadMetricHistoryModel';
import {
  buildWorkloadColumnLayoutEntries,
  parseWorkloadColumnLayoutParam,
  resolveWorkloadColumnLayoutEntries,
  serializeWorkloadColumnLayout,
  toggleWorkloadColumnLayoutEntry,
  workloadColumnLayoutIds,
  workloadColumnLayoutWidths,
  WORKLOAD_COLUMNS_URL_PARAM,
  type WorkloadColumnLayoutEntry,
} from './workloadColumnLayoutUrl';
import {
  hasWorkloadColumnWidths,
  isWorkloadManualSizingSupported,
  normalizeWorkloadColumnWidths,
  pruneWorkloadColumnWidths,
  seedWorkloadColumnWidthsFromDefaults,
  snapshotWorkloadColumnWidths,
  sumWorkloadColumnWidths,
  WORKLOAD_COLUMN_FALLBACK_WIDTH,
  withWorkloadColumnWidth,
  withoutWorkloadColumnWidth,
  workloadColumnWidthsStorageKey,
  type WorkloadColumnWidths,
} from './workloadColumnWidths';

interface WorkloadsControlsStateOptions {
  layoutWidth?: Accessor<number | null | undefined>;
  forcedGroupingMode?: WorkloadsGroupingMode;
  statusModeStorageScope?: string;
  // When a platform page owns the metric display mode (e.g. Proxmox
  // overview shares it across a top hosts table and the embedded workloads
  // surface), pass the accessor + change handler so the controls track the
  // page-level state instead of forking a local persistent signal.
  metricDisplayMode?: Accessor<WorkloadsMetricDisplayMode>;
  onMetricDisplayModeChange?: (value: WorkloadsMetricDisplayMode) => void;
  metricHoverMode?: Accessor<WorkloadsMetricHoverMode>;
  onMetricHoverModeChange?: (value: WorkloadsMetricHoverMode) => void;
  metricHistoryRange?: Accessor<WorkloadTableMetricHistoryRange>;
  onMetricHistoryRangeChange?: (value: WorkloadTableMetricHistoryRange) => void;
  columnVisibilityStorageScope?: string;
  additionalDefaultHiddenColumnIds?: string[];
  // False when no workload in the current set has an availability check
  // linked, which suppresses the Availability column instead of rendering an
  // empty cell on every row. Omitted means "assume data exists".
  hasAvailabilityData?: Accessor<boolean>;
  columnLabelOverrides?: Partial<Record<string, string>>;
  excludedWorkloadTypes?: readonly WorkloadType[];
  setShowFilters: (value: boolean | ((current: boolean) => boolean)) => void;
  showFilters: Accessor<boolean>;
  viewMode: Accessor<ViewMode>;
  routeStateEnabled?: Accessor<boolean>;
}

const parseWorkloadsStatusMode = (raw: string | null | undefined): WorkloadsStatusMode =>
  raw === 'all' || raw === 'running' || raw === 'degraded' || raw === 'stopped'
    ? (raw as WorkloadsStatusMode)
    : DEFAULT_WORKLOADS_STATUS_MODE;

const workloadsStatusModeStorageKey = (scope: string | undefined): string => {
  const trimmedScope = (scope || '').trim();
  return trimmedScope ? `workloadsStatusMode:${trimmedScope}` : 'workloadsStatusMode';
};

const saveWorkloadsStatusMode = (scope: string | undefined, value: WorkloadsStatusMode): void => {
  if (typeof window === 'undefined') return;
  try {
    window.localStorage.setItem(workloadsStatusModeStorageKey(scope), value);
  } catch {
    // Ignore storage failures; the URL remains the canonical live state.
  }
};

const readSavedWorkloadsStatusMode = (scope: string | undefined): WorkloadsStatusMode => {
  if (typeof window === 'undefined') return DEFAULT_WORKLOADS_STATUS_MODE;
  try {
    const raw = window.localStorage.getItem(workloadsStatusModeStorageKey(scope));
    return parseWorkloadsStatusMode(raw);
  } catch {
    return DEFAULT_WORKLOADS_STATUS_MODE;
  }
};

export function useWorkloadsControlsState(options: WorkloadsControlsStateOptions) {
  const location = useLocation();
  const navigate = useNavigate();
  const routeStateEnabled = options.routeStateEnabled ?? (() => true);
  const [activeRouteSearch, setActiveRouteSearch] = createSignal(location.search);
  createEffect(() => {
    if (!routeStateEnabled()) return;
    setActiveRouteSearch(location.search);
  });
  const breakpoint = useBreakpoint();
  const workloadTableLayoutMode = createMemo(() => {
    const measuredWidth = options.layoutWidth?.();
    return typeof measuredWidth === 'number' && measuredWidth > 0
      ? getWorkloadTableLayoutModeForContainer(measuredWidth)
      : getWorkloadTableLayoutMode(breakpoint.width());
  });
  const isMobile = createMemo(() =>
    ['narrow', 'phone', 'mobile'].includes(workloadTableLayoutMode()),
  );
  const [isSearchLocked, setIsSearchLocked] = createSignal(false);

  const updateSearchParam = (mutate: (params: URLSearchParams) => void): void => {
    if (!routeStateEnabled()) return;
    const params = new URLSearchParams(activeRouteSearch());
    mutate(params);
    const query = params.toString();
    // Router propagation is asynchronous. Keep the local URL-backed controls
    // responsive in the same event turn, then let the location effect confirm
    // the canonical value after navigation completes.
    setActiveRouteSearch(query ? `?${query}` : '');
    navigate(`${location.pathname}${query ? `?${query}` : ''}`, { replace: true });
  };

  const search: Accessor<string> = () => new URLSearchParams(activeRouteSearch()).get('q') ?? '';
  const setSearch = (value: string): void => {
    updateSearchParam((params) => {
      if (value === '') {
        params.delete('q');
      } else {
        params.set('q', value);
      }
    });
  };

  const statusMode: Accessor<WorkloadsStatusMode> = () =>
    parseWorkloadsStatusMode(new URLSearchParams(activeRouteSearch()).get('status'));
  const setStatusMode = (value: WorkloadsStatusMode): void => {
    saveWorkloadsStatusMode(options.statusModeStorageScope, value);
    updateSearchParam((params) => {
      if (value === DEFAULT_WORKLOADS_STATUS_MODE) {
        params.delete('status');
      } else {
        params.set('status', value);
      }
    });
  };

  onMount(() => {
    if (typeof window === 'undefined') return;
    if (!routeStateEnabled()) return;
    const params = new URLSearchParams(activeRouteSearch());
    if (params.has('status')) return;
    const saved = readSavedWorkloadsStatusMode(options.statusModeStorageScope);
    if (saved !== DEFAULT_WORKLOADS_STATUS_MODE) {
      params.set('status', saved);
      navigate(`${location.pathname}?${params.toString()}`, { replace: true });
    }
  });

  const [groupingMode, setGroupingMode] = usePersistentSignal<WorkloadsGroupingMode>(
    'workloadsGroupingMode',
    'grouped',
    {
      deserialize: (raw) => (raw === 'grouped' || raw === 'flat' ? raw : 'grouped'),
    },
  );
  const effectiveGroupingMode = createMemo<WorkloadsGroupingMode>(
    () => options.forcedGroupingMode ?? groupingMode(),
  );

  const [internalMetricDisplayMode, setInternalMetricDisplayMode] =
    usePersistentSignal<WorkloadsMetricDisplayMode>(
      STORAGE_KEYS.WORKLOADS_METRIC_DISPLAY_MODE,
      DEFAULT_WORKLOADS_METRIC_DISPLAY_MODE,
      {
        deserialize: (raw) =>
          raw === 'bars' || raw === 'sparklines' ? raw : DEFAULT_WORKLOADS_METRIC_DISPLAY_MODE,
      },
    );
  const workloadMetricDisplayMode: Accessor<WorkloadsMetricDisplayMode> =
    options.metricDisplayMode ?? internalMetricDisplayMode;
  const setWorkloadMetricDisplayMode = (value: WorkloadsMetricDisplayMode): void => {
    if (options.onMetricDisplayModeChange) {
      options.onMetricDisplayModeChange(value);
      return;
    }
    setInternalMetricDisplayMode(value);
  };

  const [internalMetricHoverMode, setInternalMetricHoverMode] =
    usePersistentSignal<WorkloadsMetricHoverMode>(
      STORAGE_KEYS.WORKLOADS_METRIC_HOVER_MODE,
      DEFAULT_WORKLOADS_METRIC_HOVER_MODE,
      {
        deserialize: (raw) =>
          raw === 'details' || raw === 'history' ? raw : DEFAULT_WORKLOADS_METRIC_HOVER_MODE,
      },
    );
  const workloadMetricHoverMode: Accessor<WorkloadsMetricHoverMode> =
    options.metricHoverMode ?? internalMetricHoverMode;
  const setWorkloadMetricHoverMode = (value: WorkloadsMetricHoverMode): void => {
    if (value === 'details' && value !== workloadMetricHoverMode()) {
      recordWorkloadHistoryActivity('details_selected');
    }
    if (options.onMetricHoverModeChange) {
      options.onMetricHoverModeChange(value);
      return;
    }
    setInternalMetricHoverMode(value);
  };

  const [internalMetricHistoryRange, setInternalMetricHistoryRange] =
    usePersistentSignal<WorkloadTableMetricHistoryRange>(
      STORAGE_KEYS.WORKLOADS_METRIC_HISTORY_RANGE,
      WORKLOAD_TABLE_HISTORY_DEFAULT_RANGE,
      {
        deserialize: (raw) =>
          isWorkloadTableMetricHistoryRange(raw) ? raw : WORKLOAD_TABLE_HISTORY_DEFAULT_RANGE,
      },
    );
  const workloadMetricHistoryRange: Accessor<WorkloadTableMetricHistoryRange> =
    options.metricHistoryRange ?? internalMetricHistoryRange;
  const setWorkloadMetricHistoryRange = (value: WorkloadTableMetricHistoryRange): void => {
    if (value !== workloadMetricHistoryRange()) {
      recordWorkloadHistoryActivity('range_change');
    }
    if (options.onMetricHistoryRangeChange) {
      options.onMetricHistoryRangeChange(value);
      return;
    }
    setInternalMetricHistoryRange(value);
  };

  const [sortKey, setSortKey] = createSignal<WorkloadsSortKey | null>(DEFAULT_WORKLOADS_SORT_KEY);
  const [sortDirection, setSortDirection] = createSignal<'asc' | 'desc'>(
    DEFAULT_WORKLOADS_SORT_DIRECTION,
  );

  // The Availability cell renders nothing at all until an availability check
  // is linked to that workload, so a table where no row has one shows an empty
  // column under an "Avail" header and tells the reader nothing. Gate it on the
  // live data rather than on a persisted preference: dropping it from the
  // relevant set leaves the user's own show/hide choice untouched, and the
  // column comes back on its own the first time a check is linked.
  const hasAvailabilityData = createMemo(() =>
    options.hasAvailabilityData ? options.hasAvailabilityData() : true,
  );

  const relevantColumns = createMemo(() => {
    const columnViewMode = resolveWorkloadColumnViewMode(
      options.viewMode(),
      options.excludedWorkloadTypes,
    );
    const base = VIEW_MODE_COLUMNS[columnViewMode];
    const dropNode = effectiveGroupingMode() === 'grouped';
    const dropAvailability = !hasAvailabilityData();
    if (!base) {
      if (!dropAvailability) return null;
      const all = new Set(GUEST_COLUMNS.map((column) => column.id));
      all.delete('availability');
      return all;
    }
    if ((dropNode && base.has('node')) || (dropAvailability && base.has('availability'))) {
      const filtered = new Set(base);
      if (dropNode) filtered.delete('node');
      if (dropAvailability) filtered.delete('availability');
      return filtered;
    }
    return base;
  });

  const workloadColumns = GUEST_COLUMNS.map((column) => {
    const label = options.columnLabelOverrides?.[column.id]?.trim();
    return label ? { ...column, label } : column;
  });
  const columnStorageKey = options.columnVisibilityStorageScope?.trim()
    ? `${STORAGE_KEYS.WORKLOADS_HIDDEN_COLUMNS}:${options.columnVisibilityStorageScope.trim()}`
    : STORAGE_KEYS.WORKLOADS_HIDDEN_COLUMNS;
  const defaultHiddenColumnIds = Array.from(
    new Set(['os', 'ip', ...(options.additionalDefaultHiddenColumnIds ?? [])]),
  );
  const columnVisibility = useColumnVisibility(
    columnStorageKey,
    workloadColumns,
    defaultHiddenColumnIds,
    relevantColumns,
    {},
    // One-time hides for users who already have a saved column preference for
    // this scope. `backup` reads exclusively from `resource.proxmox.lastBackup`,
    // so on the scopes that opt into hiding it the column says the same thing
    // on every row forever. The migration only fires where the id is already in
    // that scope's default-hidden set, so Proxmox keeps the column visible.
    // `tags` was on this list while vSphere shipped adapter provenance strings
    // in place of real tags; the adapter now reads vCenter's tagging API, so no
    // scope default-hides it and retiring the preference would be wrong.
    ['backup'],
  );

  const visibleColumns = columnVisibility.visibleColumns;
  const [columnWidths, setColumnWidths] = usePersistentSignal<WorkloadColumnWidths>(
    workloadColumnWidthsStorageKey(
      STORAGE_KEYS.WORKLOADS_COLUMN_WIDTHS,
      options.columnVisibilityStorageScope,
    ),
    {},
    {
      serialize: (widths) => JSON.stringify(widths),
      deserialize: (raw) => {
        try {
          return normalizeWorkloadColumnWidths(JSON.parse(raw));
        } catch {
          return {};
        }
      },
    },
  );
  const [pendingColumnWidths, setPendingColumnWidths] = createSignal<WorkloadColumnWidths | null>(
    null,
  );
  const manualColumnSizingSupported = createMemo(() =>
    isWorkloadManualSizingSupported(workloadTableLayoutMode()),
  );
  const renderableColumnIds = createMemo(() => {
    const relevant = relevantColumns();
    return new Set(
      workloadColumns
        .filter((column) => !relevant || relevant.has(column.id))
        .map((column) => column.id),
    );
  });
  const urlColumnLayout = createMemo<WorkloadColumnLayoutEntry[]>(() => {
    if (!routeStateEnabled()) return [];
    return resolveWorkloadColumnLayoutEntries(
      parseWorkloadColumnLayoutParam(
        new URLSearchParams(activeRouteSearch()).get(WORKLOAD_COLUMNS_URL_PARAM),
      ),
      renderableColumnIds(),
    );
  });
  const hasUrlColumnLayout = createMemo(
    () => manualColumnSizingSupported() && urlColumnLayout().length > 0,
  );
  const manualColumnSizingActive = createMemo(
    () =>
      manualColumnSizingSupported() &&
      (pendingColumnWidths() !== null ||
        hasUrlColumnLayout() ||
        hasWorkloadColumnWidths(columnWidths())),
  );
  const activeColumnWidths = createMemo<WorkloadColumnWidths>(() => {
    if (!manualColumnSizingActive()) return {};
    const pending = pendingColumnWidths();
    if (pending) return pending;
    if (hasUrlColumnLayout()) return workloadColumnLayoutWidths(urlColumnLayout());
    return columnWidths();
  });
  const workloadTableVisibleColumns = createMemo(() => {
    if (hasUrlColumnLayout()) {
      const byId = new Map(workloadColumns.map((column) => [column.id, column] as const));
      return workloadColumnLayoutIds(urlColumnLayout())
        .map((columnId) => byId.get(columnId))
        .filter((column): column is (typeof workloadColumns)[number] => !!column);
    }
    return getWorkloadVisibleColumnsForLayout(visibleColumns(), workloadTableLayoutMode(), {
      manualSizing: manualColumnSizingActive(),
    });
  });
  const workloadTableVisibleColumnIds = createMemo(() =>
    workloadTableVisibleColumns().map((column) => column.id),
  );
  const totalColumns = createMemo(() => workloadTableVisibleColumns().length);
  const workloadTableManualWidth = createMemo<number | null>(() =>
    sumWorkloadColumnWidths(activeColumnWidths(), workloadTableVisibleColumnIds()),
  );

  const beginWorkloadColumnResize = (measuredWidths: Readonly<Record<string, number>>): void => {
    if (!manualColumnSizingSupported()) return;
    const measured = snapshotWorkloadColumnWidths(columnWidths(), measuredWidths);
    setPendingColumnWidths(seedWorkloadColumnWidthsFromDefaults(measured, visibleColumns()));
  };
  const previewWorkloadColumnWidth = (columnId: string, width: number): void => {
    setPendingColumnWidths((current) =>
      current ? withWorkloadColumnWidth(current, columnId, width) : current,
    );
  };
  const writeColumnLayoutParam = (entries: readonly WorkloadColumnLayoutEntry[] | null): void => {
    updateSearchParam((params) => {
      if (!entries || entries.length === 0) params.delete(WORKLOAD_COLUMNS_URL_PARAM);
      else params.set(WORKLOAD_COLUMNS_URL_PARAM, serializeWorkloadColumnLayout(entries));
    });
  };
  const publishColumnLayout = (
    widths: WorkloadColumnWidths,
    orderedIds: readonly string[],
  ): void => {
    writeColumnLayoutParam(buildWorkloadColumnLayoutEntries(orderedIds, widths));
  };
  const commitWorkloadColumnResize = (): void => {
    const pending = pendingColumnWidths();
    if (!pending) return;
    const renderedColumnIds = workloadTableVisibleColumnIds();
    const committed = pruneWorkloadColumnWidths(pending, renderedColumnIds);
    if (!hasUrlColumnLayout()) setColumnWidths(committed);
    setPendingColumnWidths(null);
    publishColumnLayout(committed, renderedColumnIds);
  };
  const cancelWorkloadColumnResize = (): void => {
    setPendingColumnWidths(null);
  };
  const clearWorkloadColumnWidth = (columnId: string): void => {
    const renderedColumnIds = workloadTableVisibleColumnIds();
    const current = activeColumnWidths();
    setPendingColumnWidths(null);
    const linkOwnsLayout = hasUrlColumnLayout();
    const without = withoutWorkloadColumnWidth(current, columnId);
    if (!hasWorkloadColumnWidths(without)) {
      if (!linkOwnsLayout) setColumnWidths({});
      writeColumnLayoutParam(null);
      return;
    }
    const column = workloadColumns.find((candidate) => candidate.id === columnId);
    const restored = column ? seedWorkloadColumnWidthsFromDefaults(without, [column]) : without;
    if (!linkOwnsLayout) setColumnWidths(restored);
    publishColumnLayout(restored, renderedColumnIds);
  };
  const resetWorkloadColumnWidths = (): void => {
    setPendingColumnWidths(null);
    setColumnWidths({});
    writeColumnLayoutParam(null);
  };
  const toggleWorkloadColumn = (columnId: string): void => {
    if (!hasUrlColumnLayout()) {
      columnVisibility.toggle(columnId);
      return;
    }
    const column = workloadColumns.find((candidate) => candidate.id === columnId);
    const defaultWidth =
      column?.width && /^\d+(?:\.\d+)?px$/.test(column.width)
        ? Number.parseFloat(column.width)
        : WORKLOAD_COLUMN_FALLBACK_WIDTH;
    writeColumnLayoutParam(
      toggleWorkloadColumnLayoutEntry(urlColumnLayout(), columnId, defaultWidth),
    );
  };

  const handleSort = (key: WorkloadsSortKey) => {
    if (sortKey() === key) {
      setSortDirection(sortDirection() === 'asc' ? 'desc' : 'asc');
      return;
    }

    setSortKey(key);
    if (
      key === 'cpu' ||
      key === 'memory' ||
      key === 'disk' ||
      key === 'diskIo' ||
      key === 'netIo' ||
      key === 'uptime'
    ) {
      setSortDirection('desc');
    } else {
      setSortDirection(DEFAULT_WORKLOADS_SORT_DIRECTION);
    }
  };

  const resetWorkloadsControls = () => {
    setSearch('');
    setIsSearchLocked(false);
    setSortKey(DEFAULT_WORKLOADS_SORT_KEY);
    setSortDirection(DEFAULT_WORKLOADS_SORT_DIRECTION);
    setStatusMode(DEFAULT_WORKLOADS_STATUS_MODE);
    blurFocusedTypeToSearch();
  };

  const handleBeforeAutoFocus = () => {
    if (!options.showFilters()) options.setShowFilters(true);
    return false;
  };

  const handleTagClick = (tag: string) => {
    const currentSearch = search().trim();
    const tagFilter = `tags:${tag}`;

    if (currentSearch.includes(tagFilter)) {
      let newSearch = currentSearch;

      if (currentSearch === tagFilter) {
        newSearch = '';
      } else if (currentSearch.startsWith(tagFilter + ',')) {
        newSearch = currentSearch.replace(tagFilter + ',', '').trim();
      } else if (currentSearch.endsWith(', ' + tagFilter)) {
        newSearch = currentSearch.replace(', ' + tagFilter, '').trim();
      } else if (currentSearch.includes(', ' + tagFilter + ',')) {
        newSearch = currentSearch.replace(', ' + tagFilter + ',', ',').trim();
      } else if (currentSearch.includes(tagFilter + ', ')) {
        newSearch = currentSearch.replace(tagFilter + ', ', '').trim();
      }

      setSearch(newSearch);
      if (!newSearch) {
        setIsSearchLocked(false);
      }
      return;
    }

    if (!currentSearch || isSearchLocked()) {
      setSearch(tagFilter);
      setIsSearchLocked(false);
    } else {
      setSearch(`${currentSearch}, ${tagFilter}`);
    }

    if (!options.showFilters()) {
      options.setShowFilters(true);
    }
  };

  const workloadsFilterColumnVisibility = createMemo(() => ({
    availableColumns: getWorkloadVisibleColumnsForLayout(
      columnVisibility.availableToggles(),
      workloadTableLayoutMode(),
      { manualSizing: manualColumnSizingActive() },
    ),
    isColumnHidden: (columnId: string) =>
      hasUrlColumnLayout()
        ? !workloadTableVisibleColumnIds().includes(columnId)
        : columnVisibility.isHiddenByUser(columnId),
    onColumnToggle: toggleWorkloadColumn,
    onColumnReset: columnVisibility.resetToDefaults,
    hasColumnWidthOverrides: manualColumnSizingActive(),
    onColumnWidthsReset: resetWorkloadColumnWidths,
  }));

  return {
    columnVisibility,
    workloadsFilterColumnVisibility,
    groupingMode: effectiveGroupingMode,
    handleBeforeAutoFocus,
    handleSort,
    handleTagClick,
    isMobile,
    isSearchLocked,
    resetWorkloadsControls,
    search,
    setGroupingMode,
    setSearch,
    setSortDirection,
    setSortKey,
    setStatusMode,
    sortDirection,
    sortKey,
    statusMode,
    totalColumns,
    visibleColumns,
    workloadMetricHistoryRange,
    workloadMetricDisplayMode,
    workloadMetricHoverMode,
    workloadTableVisibleColumnIds,
    workloadTableVisibleColumns,
    workloadTableLayoutMode,
    workloadColumnWidths: activeColumnWidths,
    workloadManualColumnSizing: manualColumnSizingActive,
    workloadManualColumnSizingSupported: manualColumnSizingSupported,
    workloadTableManualWidth,
    beginWorkloadColumnResize,
    previewWorkloadColumnWidth,
    commitWorkloadColumnResize,
    cancelWorkloadColumnResize,
    clearWorkloadColumnWidth,
    resetWorkloadColumnWidths,
    setWorkloadMetricHistoryRange,
    setWorkloadMetricDisplayMode,
    setWorkloadMetricHoverMode,
  } as const;
}