drizzle-cube 0.2.25 → 0.2.27

package/dist/client/hooks/useAnalysisAI.d.ts

@@ -0,0 +1,44 @@
+import { AnalysisBuilderState, AIState } from '../components/AnalysisBuilder/types';
+import { ChartType, ChartAxisConfig, ChartDisplayConfig } from '../types';
+interface UseAnalysisAIOptions {
+    /** Current state for snapshotting */
+    state: AnalysisBuilderState;
+    /** Set state function for applying AI-generated queries */
+    setState: (updater: (prev: AnalysisBuilderState) => AnalysisBuilderState) => void;
+    /** Current chart type */
+    chartType: ChartType;
+    /** Set chart type */
+    setChartType: (type: ChartType) => void;
+    /** Current chart config */
+    chartConfig: ChartAxisConfig;
+    /** Set chart config */
+    setChartConfig: (config: ChartAxisConfig) => void;
+    /** Current display config */
+    displayConfig: ChartDisplayConfig;
+    /** Set display config */
+    setDisplayConfig: (config: ChartDisplayConfig) => void;
+    /** Set whether user manually selected chart */
+    setUserManuallySelectedChart: (value: boolean) => void;
+    /** Set active view */
+    setActiveView: (view: 'table' | 'chart') => void;
+    /** AI endpoint URL */
+    aiEndpoint?: string;
+}
+interface UseAnalysisAIResult {
+    /** Current AI state */
+    aiState: AIState;
+    /** Open the AI panel */
+    handleOpenAI: () => void;
+    /** Close the AI panel */
+    handleCloseAI: () => void;
+    /** Update the AI prompt */
+    handleAIPromptChange: (prompt: string) => void;
+    /** Generate query from AI */
+    handleGenerateAI: () => Promise<void>;
+    /** Accept the AI-generated query */
+    handleAcceptAI: () => void;
+    /** Cancel and restore previous state */
+    handleCancelAI: () => void;
+}
+export declare function useAnalysisAI({ state, setState, chartType, setChartType, chartConfig, setChartConfig, displayConfig, setDisplayConfig, setUserManuallySelectedChart, setActiveView, aiEndpoint }: UseAnalysisAIOptions): UseAnalysisAIResult;
+export {};

package/dist/client/hooks/useAnalysisBuilderHook.d.ts

@@ -0,0 +1,113 @@
+import { ColorPalette } from '../utils/colorPalettes';
+import { CubeQuery, MultiQueryConfig, ChartType, ChartAxisConfig, ChartDisplayConfig, Filter } from '../types';
+import { AnalysisBuilderState, MetricItem, BreakdownItem, ExecutionStatus, QueryPanelTab } from '../components/AnalysisBuilder/types';
+import { ChartAvailabilityMap } from '../shared/chartDefaults';
+import { DebugDataEntry } from './queries';
+import { MultiQueryValidationResult } from '../utils/multiQueryValidation';
+import { MetaField } from '../shared/types';
+export interface UseAnalysisBuilderOptions {
+    /** External color palette (overrides local) */
+    externalColorPalette?: string[] | ColorPalette;
+    /** Initial data (skip first fetch) */
+    initialData?: unknown[];
+    /** Callback when query changes */
+    onQueryChange?: (query: CubeQuery) => void;
+    /** Callback when chart config changes */
+    onChartConfigChange?: (config: {
+        chartType: ChartType;
+        chartConfig: ChartAxisConfig;
+        displayConfig: ChartDisplayConfig;
+    }) => void;
+}
+export interface UseAnalysisBuilderResult {
+    queryState: AnalysisBuilderState;
+    queryStates: AnalysisBuilderState[];
+    activeQueryIndex: number;
+    mergeStrategy: 'concat' | 'merge';
+    isMultiQueryMode: boolean;
+    mergeKeys: string[] | undefined;
+    currentQuery: CubeQuery;
+    allQueries: CubeQuery[];
+    multiQueryConfig: MultiQueryConfig | null;
+    multiQueryValidation: MultiQueryValidationResult | null;
+    executionStatus: ExecutionStatus;
+    executionResults: unknown[] | null;
+    perQueryResults: (unknown[] | null)[] | null;
+    isLoading: boolean;
+    isFetching: boolean;
+    error: Error | null;
+    isValidQuery: boolean;
+    debugDataPerQuery: DebugDataEntry[];
+    chartType: ChartType;
+    chartConfig: ChartAxisConfig;
+    displayConfig: ChartDisplayConfig;
+    colorPalette: ColorPalette;
+    localPaletteName: string;
+    chartAvailability: ChartAvailabilityMap;
+    combinedMetrics: MetricItem[];
+    combinedBreakdowns: BreakdownItem[];
+    effectiveBreakdowns: BreakdownItem[];
+    activeTab: QueryPanelTab;
+    activeView: 'table' | 'chart';
+    displayLimit: number;
+    showFieldModal: boolean;
+    fieldModalMode: 'metrics' | 'breakdown';
+    activeTableIndex: number;
+    userManuallySelectedChart: boolean;
+    aiState: {
+        isOpen: boolean;
+        userPrompt: string;
+        isGenerating: boolean;
+        error: string | null;
+        hasGeneratedQuery: boolean;
+    };
+    shareButtonState: 'idle' | 'copied' | 'copied-no-chart';
+    canShare: boolean;
+    actions: {
+        setActiveQueryIndex: (index: number) => void;
+        setMergeStrategy: (strategy: 'concat' | 'merge') => void;
+        openMetricsModal: () => void;
+        addMetric: (field: string, label?: string) => void;
+        removeMetric: (id: string) => void;
+        toggleMetric: (fieldName: string) => void;
+        reorderMetrics: (fromIndex: number, toIndex: number) => void;
+        openBreakdownsModal: () => void;
+        addBreakdown: (field: string, isTimeDimension: boolean, granularity?: string) => void;
+        removeBreakdown: (id: string) => void;
+        toggleBreakdown: (fieldName: string, isTimeDimension: boolean, granularity?: string) => void;
+        setBreakdownGranularity: (id: string, granularity: string) => void;
+        toggleBreakdownComparison: (id: string) => void;
+        reorderBreakdowns: (fromIndex: number, toIndex: number) => void;
+        setFilters: (filters: Filter[]) => void;
+        dropFieldToFilter: (field: string) => void;
+        setOrder: (fieldName: string, direction: 'asc' | 'desc' | null) => void;
+        addQuery: () => void;
+        removeQuery: (index: number) => void;
+        setChartType: (type: ChartType) => void;
+        setChartConfig: (config: ChartAxisConfig) => void;
+        setDisplayConfig: (config: ChartDisplayConfig) => void;
+        setLocalPaletteName: (name: string) => void;
+        setActiveTab: (tab: QueryPanelTab) => void;
+        setActiveView: (view: 'table' | 'chart') => void;
+        setDisplayLimit: (limit: number) => void;
+        closeFieldModal: () => void;
+        setActiveTableIndex: (index: number) => void;
+        openAI: () => void;
+        closeAI: () => void;
+        setAIPrompt: (prompt: string) => void;
+        generateAI: () => Promise<void>;
+        acceptAI: () => void;
+        cancelAI: () => void;
+        share: () => Promise<void>;
+        clearQuery: () => void;
+        refetch: () => void;
+        handleFieldSelected: (field: MetaField, fieldType: 'measure' | 'dimension' | 'timeDimension', cubeName: string, keepOpen?: boolean) => void;
+    };
+    getQueryConfig: () => CubeQuery | MultiQueryConfig;
+    getChartConfig: () => {
+        chartType: ChartType;
+        chartConfig: ChartAxisConfig;
+        displayConfig: ChartDisplayConfig;
+    };
+}
+export declare function useAnalysisBuilder(options?: UseAnalysisBuilderOptions): UseAnalysisBuilderResult;

package/dist/client/hooks/useAnalysisChartDefaults.d.ts

@@ -0,0 +1,35 @@
+import { ColorPalette } from '../utils/colorPalettes';
+import { ChartType, ChartAxisConfig, ChartDisplayConfig } from '../types';
+import { MetricItem, BreakdownItem } from '../components/AnalysisBuilder/types';
+import { ChartAvailabilityMap } from '../shared/chartDefaults';
+export interface UseAnalysisChartDefaultsOptions {
+    /** External color palette (overrides local) */
+    externalColorPalette?: string[] | ColorPalette;
+    /** Combined metrics from all queries */
+    combinedMetrics: MetricItem[];
+    /** Combined breakdowns from all queries */
+    combinedBreakdowns: BreakdownItem[];
+    /** Whether query has been debounced (triggers smart defaults) */
+    hasDebounced: boolean;
+}
+export interface UseAnalysisChartDefaultsResult {
+    /** Current chart type */
+    chartType: ChartType;
+    /** Chart axis configuration */
+    chartConfig: ChartAxisConfig;
+    /** Chart display configuration */
+    displayConfig: ChartDisplayConfig;
+    /** Effective color palette */
+    colorPalette: ColorPalette;
+    /** Local palette name (when not using external) */
+    localPaletteName: string;
+    /** Chart availability map */
+    chartAvailability: ChartAvailabilityMap;
+    /** User manually selected chart */
+    userManuallySelectedChart: boolean;
+    setChartType: (type: ChartType) => void;
+    setChartConfig: (config: ChartAxisConfig) => void;
+    setDisplayConfig: (config: ChartDisplayConfig) => void;
+    setLocalPaletteName: (name: string) => void;
+}
+export declare function useAnalysisChartDefaults(options: UseAnalysisChartDefaultsOptions): UseAnalysisChartDefaultsResult;

package/dist/client/hooks/useAnalysisCombinedFields.d.ts

@@ -0,0 +1,18 @@
+import { AnalysisBuilderState, MetricItem, BreakdownItem } from '../components/AnalysisBuilder/types';
+import { QueryMergeStrategy } from '../types';
+export interface UseAnalysisCombinedFieldsOptions {
+    queryState: AnalysisBuilderState;
+    queryStates: AnalysisBuilderState[];
+    isMultiQueryMode: boolean;
+    mergeStrategy: QueryMergeStrategy;
+    activeQueryIndex: number;
+}
+export interface UseAnalysisCombinedFieldsResult {
+    /** Combined metrics from all queries (for chart config) */
+    combinedMetrics: MetricItem[];
+    /** Combined breakdowns from all queries (for chart config) */
+    combinedBreakdowns: BreakdownItem[];
+    /** Effective breakdowns for display (Q1's in merge mode, otherwise current query's) */
+    effectiveBreakdowns: BreakdownItem[];
+}
+export declare function useAnalysisCombinedFields(options: UseAnalysisCombinedFieldsOptions): UseAnalysisCombinedFieldsResult;

package/dist/client/hooks/useAnalysisInitialization.d.ts

@@ -0,0 +1,25 @@
+import { CubeQuery, ChartType, ChartAxisConfig, ChartDisplayConfig } from '../types';
+export interface UseAnalysisInitializationOptions {
+    /** Current query */
+    currentQuery: CubeQuery;
+    /** Whether query is valid */
+    isValidQuery: boolean;
+    /** Chart type */
+    chartType: ChartType;
+    /** Chart config */
+    chartConfig: ChartAxisConfig;
+    /** Display config */
+    displayConfig: ChartDisplayConfig;
+    /** Callback when query changes */
+    onQueryChange?: (query: CubeQuery) => void;
+    /** Callback when chart config changes */
+    onChartConfigChange?: (config: {
+        chartType: ChartType;
+        chartConfig: ChartAxisConfig;
+        displayConfig: ChartDisplayConfig;
+    }) => void;
+}
+/**
+ * Handles initialization effects - no return value (side-effect only hook)
+ */
+export declare function useAnalysisInitialization(options: UseAnalysisInitializationOptions): void;

package/dist/client/hooks/useAnalysisQueryBuilder.d.ts

@@ -0,0 +1,32 @@
+import { MultiQueryValidationResult } from '../utils/multiQueryValidation';
+import { CubeQuery, MultiQueryConfig, QueryMergeStrategy } from '../types';
+import { AnalysisBuilderState } from '../components/AnalysisBuilder/types';
+export interface UseAnalysisQueryBuilderResult {
+    /** Current query state (active query) */
+    queryState: AnalysisBuilderState;
+    /** All query states (for multi-query mode) */
+    queryStates: AnalysisBuilderState[];
+    /** Active query index */
+    activeQueryIndex: number;
+    /** Merge strategy for multi-query */
+    mergeStrategy: QueryMergeStrategy;
+    /** Whether in multi-query mode */
+    isMultiQueryMode: boolean;
+    /** Merge keys (computed from Q1 breakdowns) */
+    mergeKeys: string[] | undefined;
+    /** Current query as CubeQuery */
+    currentQuery: CubeQuery;
+    /** All queries as CubeQuery[] */
+    allQueries: CubeQuery[];
+    /** MultiQueryConfig (if in multi-query mode) */
+    multiQueryConfig: MultiQueryConfig | null;
+    /** Multi-query validation result */
+    multiQueryValidation: MultiQueryValidationResult | null;
+    /** Whether current query is valid */
+    isValidQuery: boolean | undefined;
+    setActiveQueryIndex: (index: number) => void;
+    setMergeStrategy: (strategy: QueryMergeStrategy) => void;
+    addQuery: () => void;
+    removeQuery: (index: number) => void;
+}
+export declare function useAnalysisQueryBuilder(): UseAnalysisQueryBuilderResult;

package/dist/client/hooks/useAnalysisQueryExecution.d.ts

@@ -0,0 +1,38 @@
+import { DebugDataEntry } from './queries';
+import { CubeQuery, MultiQueryConfig } from '../types';
+import { ExecutionStatus } from '../components/AnalysisBuilder/types';
+export interface UseAnalysisQueryExecutionOptions {
+    /** Current query (for single-query mode) */
+    currentQuery: CubeQuery;
+    /** All queries (for dry-run and multi-query) */
+    allQueries: CubeQuery[];
+    /** Multi-query config (null if single-query mode) */
+    multiQueryConfig: MultiQueryConfig | null;
+    /** Whether in multi-query mode */
+    isMultiQueryMode: boolean;
+    /** Whether current query is valid */
+    isValidQuery: boolean;
+    /** Initial data (skip first fetch) */
+    initialData?: unknown[];
+}
+export interface UseAnalysisQueryExecutionResult {
+    /** Query execution status */
+    executionStatus: ExecutionStatus;
+    /** Query results (merged for multi-query) */
+    executionResults: unknown[] | null;
+    /** Per-query results (for table view in multi-query mode) */
+    perQueryResults: (unknown[] | null)[] | null;
+    /** Whether query is loading */
+    isLoading: boolean;
+    /** Whether query is fetching (includes refetch) */
+    isFetching: boolean;
+    /** Query error */
+    error: Error | null;
+    /** Debug data per query */
+    debugDataPerQuery: DebugDataEntry[];
+    /** Whether query has been debounced (for smart defaults trigger) */
+    hasDebounced: boolean;
+    /** Refetch function */
+    refetch: () => void;
+}
+export declare function useAnalysisQueryExecution(options: UseAnalysisQueryExecutionOptions): UseAnalysisQueryExecutionResult;

package/dist/client/hooks/useAnalysisShare.d.ts

@@ -0,0 +1,23 @@
+import { CubeQuery, ChartType, ChartAxisConfig, ChartDisplayConfig, MultiQueryConfig } from '../types';
+interface UseAnalysisShareOptions {
+    /** Whether the current query is valid */
+    isValidQuery: boolean;
+    /** Getter for the query config (matches AnalysisBuilder save format) */
+    getQueryConfig: () => CubeQuery | MultiQueryConfig;
+    /** Current chart type */
+    chartType: ChartType;
+    /** Current chart config */
+    chartConfig: ChartAxisConfig;
+    /** Current display config */
+    displayConfig: ChartDisplayConfig;
+    /** Current active view */
+    activeView: 'table' | 'chart';
+}
+interface UseAnalysisShareResult {
+    /** Current share button state */
+    shareButtonState: 'idle' | 'copied' | 'copied-no-chart';
+    /** Handle share button click */
+    handleShare: () => Promise<void>;
+}
+export declare function useAnalysisShare({ isValidQuery, getQueryConfig, chartType, chartConfig, displayConfig, activeView }: UseAnalysisShareOptions): UseAnalysisShareResult;
+export {};

package/dist/client/hooks/useAnalysisUIState.d.ts

@@ -0,0 +1,24 @@
+import { FieldModalMode } from '../stores/analysisBuilderStore';
+import { QueryPanelTab } from '../components/AnalysisBuilder/types';
+export interface UseAnalysisUIStateResult {
+    /** Active tab in query panel */
+    activeTab: QueryPanelTab;
+    /** Active view (table or chart) */
+    activeView: 'table' | 'chart';
+    /** Display limit for table */
+    displayLimit: number;
+    /** Whether field modal is open */
+    showFieldModal: boolean;
+    /** Field modal mode */
+    fieldModalMode: FieldModalMode;
+    /** Active table index for multi-query */
+    activeTableIndex: number;
+    /** User manually selected chart */
+    userManuallySelectedChart: boolean;
+    setActiveTab: (tab: QueryPanelTab) => void;
+    setActiveView: (view: 'table' | 'chart') => void;
+    setDisplayLimit: (limit: number) => void;
+    closeFieldModal: () => void;
+    setActiveTableIndex: (index: number) => void;
+}
+export declare function useAnalysisUIState(): UseAnalysisUIStateResult;

package/dist/client/hooks/useDashboardHook.d.ts

@@ -0,0 +1,108 @@
+import { default as React } from 'react';
+import { PortletDebugDataEntry } from '../stores/dashboardStore';
+import { LayoutItem } from 'react-grid-layout';
+import { DashboardConfig, PortletConfig, RowLayout, DashboardFilter, DashboardGridSettings, DashboardLayoutMode } from '../types';
+export interface UseDashboardOptions {
+    /** Dashboard configuration */
+    config: DashboardConfig;
+    /** Whether dashboard is editable */
+    editable?: boolean;
+    /** Dashboard filters */
+    dashboardFilters?: DashboardFilter[];
+    /** Grid settings */
+    gridSettings: DashboardGridSettings;
+    /** Allowed layout modes */
+    allowedModes?: DashboardLayoutMode[];
+    /** Whether responsive mode allows editing (desktop only) */
+    isResponsiveEditable?: boolean;
+    /** Config change handler */
+    onConfigChange?: (config: DashboardConfig) => void;
+    /** Save handler */
+    onSave?: (config: DashboardConfig) => Promise<void> | void;
+    /** Grid width for row calculations */
+    gridWidth?: number;
+    /** Portlet component refs for refresh functionality */
+    portletComponentRefs?: React.MutableRefObject<Record<string, {
+        refresh: () => void;
+    } | null>>;
+    /** Portlet refresh handler (external) */
+    onPortletRefresh?: (portletId: string) => void;
+}
+export interface UseDashboardResult {
+    /** Whether dashboard is in edit mode */
+    isEditMode: boolean;
+    /** Selected filter ID for filter assignment mode */
+    selectedFilterId: string | null;
+    /** Whether portlet modal is open */
+    isPortletModalOpen: boolean;
+    /** Portlet being edited */
+    editingPortlet: PortletConfig | null;
+    /** Whether filter config modal is open */
+    isFilterConfigModalOpen: boolean;
+    /** Portlet for filter configuration */
+    filterConfigPortlet: PortletConfig | null;
+    /** Portlet ID pending delete confirmation */
+    deleteConfirmPortletId: string | null;
+    /** Draft rows during drag operations */
+    draftRows: RowLayout[] | null;
+    /** Whether a portlet is being dragged */
+    isDraggingPortlet: boolean;
+    /** Last known layout for change detection */
+    lastKnownLayout: LayoutItem[];
+    /** Whether component is initialized */
+    isInitialized: boolean;
+    /** Debug data per portlet */
+    debugData: Record<string, PortletDebugDataEntry>;
+    /** Whether editing is allowed (editable && isEditMode && desktop && !filterMode) */
+    canEdit: boolean;
+    /** Whether layout mode can be changed */
+    canChangeLayoutMode: boolean;
+    /** Currently selected filter object */
+    selectedFilter: DashboardFilter | null;
+    /** Resolved rows for row-based layout */
+    resolvedRows: RowLayout[];
+    /** Current layout mode */
+    layoutMode: DashboardLayoutMode;
+    /** Allowed layout modes */
+    allowedModes: DashboardLayoutMode[];
+    actions: UseDashboardActions;
+}
+export interface UseDashboardActions {
+    enterEditMode: () => void;
+    exitEditMode: () => void;
+    toggleEditMode: () => void;
+    selectFilter: (filterId: string | null) => void;
+    exitFilterSelectionMode: () => void;
+    openAddPortlet: () => void;
+    openEditPortlet: (portlet: PortletConfig) => void;
+    closePortletModal: () => void;
+    openFilterConfig: (portlet: PortletConfig) => void;
+    closeFilterConfig: () => void;
+    setDraftRows: (rows: RowLayout[] | null) => void;
+    setIsDraggingPortlet: (isDragging: boolean) => void;
+    setLastKnownLayout: (layout: LayoutItem[]) => void;
+    setIsInitialized: (initialized: boolean) => void;
+    setDragState: (state: {
+        rowIndex: number;
+        colIndex: number;
+        portletId: string;
+    } | null) => void;
+    clearDragState: () => void;
+    hasLayoutActuallyChanged: (newLayout: LayoutItem[]) => boolean;
+    updateRowLayout: (rows: RowLayout[], save?: boolean, portletsOverride?: PortletConfig[]) => Promise<void>;
+    handleLayoutModeChange: (mode: DashboardLayoutMode) => Promise<void>;
+    savePortlet: (portletData: PortletConfig | Omit<PortletConfig, 'id' | 'x' | 'y'>) => Promise<string | null>;
+    deletePortlet: (portletId: string) => Promise<void>;
+    duplicatePortlet: (portletId: string) => Promise<string | undefined>;
+    refreshPortlet: (portletId: string) => void;
+    toggleFilterForPortlet: (portletId: string, filterId: string) => Promise<void>;
+    selectAllForFilter: (filterId: string) => Promise<void>;
+    saveFilterConfig: (mapping: string[]) => Promise<void>;
+    handlePaletteChange: (paletteName: string) => Promise<void>;
+    openDeleteConfirm: (portletId: string) => void;
+    closeDeleteConfirm: () => void;
+    confirmDelete: () => Promise<void>;
+    setDebugData: (portletId: string, data: PortletDebugDataEntry) => void;
+    clearDebugData: (portletId?: string) => void;
+}
+export declare function useDashboard(options: UseDashboardOptions): UseDashboardResult;

package/dist/client/hooks/useDebounceQuery.d.ts

@@ -0,0 +1,48 @@
+/**
+ * useDebounceQuery - Shared debounce logic for query hooks
+ *
+ * This hook encapsulates the common debouncing pattern used by
+ * useCubeLoadQuery and useMultiCubeLoadQuery to prevent excessive API calls
+ * when users are actively editing queries.
+ *
+ * Features:
+ * - Debounces value changes with configurable delay
+ * - Handles skip-to-unskip transitions (e.g., portlet becoming visible)
+ * - Clears debounced value when invalid or skipped
+ * - Provides isDebouncing state for UI feedback
+ */
+export interface UseDebounceQueryOptions {
+    /**
+     * Whether the value is valid (has required fields)
+     */
+    isValid: boolean;
+    /**
+     * Whether to skip the debounced value
+     * @default false
+     */
+    skip?: boolean;
+    /**
+     * Debounce delay in milliseconds
+     * @default 300
+     */
+    debounceMs?: number;
+}
+export interface UseDebounceQueryResult<T> {
+    /** The debounced value (null if skipped or invalid) */
+    debouncedValue: T | null;
+    /** Whether the hook is currently debouncing (waiting for timer) */
+    isDebouncing: boolean;
+}
+/**
+ * Hook for debouncing query values with skip and validity support
+ *
+ * Usage:
+ * ```tsx
+ * const { debouncedValue, isDebouncing } = useDebounceQuery(query, {
+ *   isValid: isValidCubeQuery(query),
+ *   skip: !isReady,
+ *   debounceMs: 300
+ * })
+ * ```
+ */
+export declare function useDebounceQuery<T>(value: T | null, options: UseDebounceQueryOptions): UseDebounceQueryResult<T>;

package/dist/client/hooks/useDirtyStateTracking.d.ts

@@ -0,0 +1,37 @@
+/**
+ * useDirtyStateTracking - Track configuration changes and dirty state
+ *
+ * Extracts dirty state tracking logic from AnalyticsDashboard:
+ * - Tracks initial config to prevent saves during initial load
+ * - Detects meaningful changes from initial state
+ * - Manages dirty state through onDirtyStateChange callback
+ *
+ * @example
+ * const { handleConfigChange, handleSave } = useDirtyStateTracking({
+ *   initialConfig: config,
+ *   onConfigChange,
+ *   onSave,
+ *   onDirtyStateChange,
+ * })
+ */
+export interface UseDirtyStateTrackingOptions<T> {
+    /** Initial configuration to compare against */
+    initialConfig: T;
+    /** Original config change handler */
+    onConfigChange?: (config: T) => void;
+    /** Original save handler */
+    onSave?: (config: T) => Promise<void> | void;
+    /** Dirty state change callback */
+    onDirtyStateChange?: (isDirty: boolean) => void;
+}
+export interface UseDirtyStateTrackingResult<T> {
+    /** Wrapped config change handler that tracks dirty state */
+    handleConfigChange: (config: T) => void;
+    /** Wrapped save handler that tracks dirty state */
+    handleSave: (config: T) => Promise<void>;
+    /** Whether config has changed from initial */
+    hasChanged: () => boolean;
+    /** Reset the initial config reference (e.g., after external config update) */
+    resetInitialConfig: (config: T) => void;
+}
+export declare function useDirtyStateTracking<T>({ initialConfig, onConfigChange, onSave, onDirtyStateChange, }: UseDirtyStateTrackingOptions<T>): UseDirtyStateTrackingResult<T>;

package/dist/client/hooks/useFilterValues.d.ts

@@ -1,6 +1,6 @@
 /**
  * Hook for fetching distinct field values for filter dropdowns
- * Uses the /load API to get actual data values
+ * Uses TanStack Query via useCubeLoadQuery for data fetching
  */
 interface UseFilterValuesResult {
     values: any[];
@@ -11,6 +11,9 @@ interface UseFilterValuesResult {
 }
 /**
  * Custom hook to fetch distinct values for a field
+ *
+ * Uses TanStack Query for server state (data fetching, caching, loading).
+ * Values are derived via useMemo from query results - NOT stored in useState.
  */
 export declare function useFilterValues(fieldName: string | null, enabled?: boolean): UseFilterValuesResult;
 export {};

package/dist/client/hooks.d.ts

@@ -4,9 +4,11 @@
  * React hooks only - for applications that need data fetching hooks
  * without UI components.
  */
-export { useCubeQuery } from './hooks/useCubeQuery';
-export { useCubeMeta } from './hooks/useCubeMeta';
+export { useCubeMetaQuery, useCubeLoadQuery, useMultiCubeLoadQuery, useDryRunQuery, useMultiDryRunQueries, useDryRunQueries, } from './hooks/queries';
+export type { UseCubeMetaQueryOptions, UseCubeMetaQueryResult, UseCubeLoadQueryOptions, UseCubeLoadQueryResult, UseMultiCubeLoadQueryOptions, UseMultiCubeLoadQueryResult, DebugDataEntry, } from './hooks/queries';
 export { useDebounce } from './hooks/useDebounce';
+export { useDirtyStateTracking } from './hooks/useDirtyStateTracking';
+export type { UseDirtyStateTrackingOptions, UseDirtyStateTrackingResult } from './hooks/useDirtyStateTracking';
 export { useFilterValues } from './hooks/useFilterValues';
 export { useResponsiveDashboard } from './hooks/useResponsiveDashboard';
 export type { DashboardDisplayMode, UseResponsiveDashboardResult } from './hooks/useResponsiveDashboard';