drizzle-cube 0.5.8 → 0.6.0

package/dist/client/components/AnalysisBuilder/AnalysisQueryPanelParts.d.ts

@@ -0,0 +1,64 @@
+import { default as React } from 'react';
+import { AnalysisQueryPanelProps, BreakdownItem } from './types';
+import { MetaField } from '../../shared/types';
+import { QueryMergeStrategy } from '../../types';
+type Props = AnalysisQueryPanelProps;
+/** True when the funnel mode UI has all the callbacks it needs to render. */
+export declare function canRenderFunnelMode(p: Props): boolean;
+/** True when the flow mode UI has all the callbacks/state it needs to render. */
+export declare function canRenderFlowMode(p: Props): boolean;
+/**
+ * Whether a dedicated mode (funnel/flow/retention) replaces the standard layout.
+ */
+export declare function shouldRenderModeContent(p: Props): boolean;
+/**
+ * Renders the dedicated mode UI (funnel / flow / retention) when one of those
+ * analysis types is active and all the required callbacks are present. Returns
+ * null when the standard query/chart/display layout should be used instead.
+ */
+export declare function AnalysisModeContent(props: Props): React.JSX.Element | null;
+interface TabBarProps {
+    activeTab: Props['activeTab'];
+    onActiveTabChange: Props['onActiveTabChange'];
+    isMultiQuery: boolean;
+    queryCount: number;
+    activeQueryIndex: number;
+    onAddQuery?: Props['onAddQuery'];
+    getQueryTabLabel: (index: number) => string;
+    handleQueryTabClick: (index: number) => void;
+    handleRemoveQuery: (e: React.MouseEvent, index: number) => void;
+}
+export declare function QueryPanelTabBar(props: TabBarProps): React.JSX.Element;
+export declare function MergeStrategyControls({ mergeStrategy, onMergeStrategyChange, isFunnelMode, funnelBindingKey, onFunnelBindingKeyChange, schema, }: {
+    mergeStrategy: QueryMergeStrategy;
+    onMergeStrategyChange?: Props['onMergeStrategyChange'];
+    isFunnelMode: boolean;
+    funnelBindingKey?: Props['funnelBindingKey'];
+    onFunnelBindingKeyChange?: Props['onFunnelBindingKeyChange'];
+    schema: Props['schema'];
+}): React.JSX.Element;
+export declare function AdapterValidationBanner({ adapterValidation, }: {
+    adapterValidation: NonNullable<Props['adapterValidation']>;
+}): React.JSX.Element;
+export declare function MultiQueryValidationBanner({ multiQueryValidation, }: {
+    multiQueryValidation: NonNullable<Props['multiQueryValidation']>;
+}): React.JSX.Element;
+interface TabContentProps extends Props {
+    isMultiQuery: boolean;
+    getFieldMeta: (breakdown: BreakdownItem) => MetaField | null;
+    comparisonEnabledBreakdown: BreakdownItem | undefined;
+}
+/**
+ * Renders the active tab's body (query sections / chart config / display config)
+ * for the standard (non-mode) layout.
+ */
+export declare function QueryPanelTabContent(props: TabContentProps): React.JSX.Element | null;
+export declare function LockedBreakdownList({ breakdowns, getFieldMeta, comparisonEnabledBreakdown, onBreakdownGranularityChange, onBreakdownComparisonToggle, onMergeStrategyChange, }: {
+    breakdowns: BreakdownItem[];
+    getFieldMeta: (breakdown: BreakdownItem) => MetaField | null;
+    comparisonEnabledBreakdown: BreakdownItem | undefined;
+    onBreakdownGranularityChange: Props['onBreakdownGranularityChange'];
+    onBreakdownComparisonToggle?: Props['onBreakdownComparisonToggle'];
+    onMergeStrategyChange?: Props['onMergeStrategyChange'];
+}): React.JSX.Element;
+export {};

package/dist/client/components/AnalysisBuilder/AnalysisResultsHeader.d.ts

@@ -0,0 +1,67 @@
+/**
+ * AnalysisResultsHeader
+ *
+ * Presentational header for AnalysisResultsPanel: the status / row-count line,
+ * the toolbar of action buttons (display limit, AI, palette, share, refresh,
+ * clear, schema, debug) and the large-dataset performance warning. Extracted to
+ * keep the panel's renderHeader flat. Behaviour and markup are identical to the
+ * previous inline rendering.
+ *
+ * Props are grouped into cohesive named slices instead of a flat bag, and each
+ * sub-component receives only the slice it needs:
+ *   - `summary`  → results state / row-count line + debug-error indicator
+ *   - `toolbar`  → action handlers and their transient state
+ *   - `display`  → view / visibility flags driving which controls render
+ */
+type Row = Record<string, unknown>;
+/** Results state + row counts that drive the status line, warning and error dot. */
+export interface ResultsSummary {
+    executionResults: Row[] | null | undefined;
+    executionStatus: string;
+    totalRowCount: number | null;
+    resultsStale: boolean;
+    executionError: unknown;
+    debugDataPerQuery: Array<{
+        error?: unknown;
+    }>;
+}
+/** Action handlers and their transient state for the toolbar buttons. */
+export interface ResultsToolbarActions {
+    displayLimit: number;
+    onDisplayLimitChange?: (limit: number) => void;
+    isAIOpen?: boolean;
+    onAIToggle?: () => void;
+    onColorPaletteChange?: (palette: string) => void;
+    currentPaletteName?: string;
+    onShareClick?: () => void;
+    shareButtonState: string;
+    canShare: boolean;
+    onRefreshClick?: (opts: {
+        bustCache: boolean;
+    }) => void;
+    canRefresh: boolean;
+    isRefreshing: boolean;
+    showCacheBustIndicator: boolean;
+    setIsHoveringRefresh: (v: boolean) => void;
+    onClearClick?: () => void;
+    canClear: boolean;
+    setIsClearConfirmOpen: (v: boolean) => void;
+    setShowDebug: (v: boolean) => void;
+    setShowSchema: (v: boolean) => void;
+}
+/** View / visibility flags deciding which controls render. */
+export interface ResultsDisplayFlags {
+    activeView: string;
+    showDebug: boolean;
+    showSchema: boolean;
+    enableAI?: boolean;
+    isFunnelMode: boolean;
+    showSchemaDiagram: boolean;
+}
+export interface ResultsHeaderProps {
+    summary: ResultsSummary;
+    toolbar: ResultsToolbarActions;
+    display: ResultsDisplayFlags;
+}
+export default function ResultsHeader({ summary, toolbar, display }: ResultsHeaderProps): import("react").JSX.Element;
+export {};

package/dist/client/components/AnalysisBuilder/BreakdownComparisonToggle.d.ts

@@ -0,0 +1,13 @@
+/**
+ * BreakdownComparisonToggle Component
+ *
+ * "vs prior" period-comparison toggle for time-dimension breakdowns.
+ * Extracted from BreakdownItemCard to keep its render body flat.
+ */
+interface BreakdownComparisonToggleProps {
+    enableComparison?: boolean;
+    comparisonDisabled?: boolean;
+    onComparisonToggle: () => void;
+}
+declare const BreakdownComparisonToggle: import('react').NamedExoticComponent<BreakdownComparisonToggleProps>;
+export default BreakdownComparisonToggle;

package/dist/client/components/AnalysisBuilder/BreakdownRow.d.ts

@@ -0,0 +1,26 @@
+import { DragEvent } from 'react';
+import { MetaField } from '../../shared/types';
+import { BreakdownItem } from './types';
+interface BreakdownRowProps {
+    breakdown: BreakdownItem;
+    fieldMeta: MetaField | null;
+    sortDirection: 'asc' | 'desc' | null;
+    sortPriority: number | undefined;
+    index: number;
+    transform: string;
+    showGapBefore: boolean;
+    isAnyDragging: boolean;
+    isDragging: boolean;
+    comparisonDisabled: boolean;
+    onRemove: (id: string) => void;
+    onGranularityChange: (id: string, granularity: string) => void;
+    onComparisonToggle?: (id: string) => void;
+    onOrderChange?: (field: string, direction: 'asc' | 'desc' | null) => void;
+    onReorder?: (fromIndex: number, toIndex: number) => void;
+    onItemDragOver: (e: DragEvent, index: number) => void;
+    onItemDrop: (e: DragEvent) => void;
+    onDragStart: (e: DragEvent, index: number) => void;
+    onDragEnd: () => void;
+}
+declare const BreakdownRow: import('react').NamedExoticComponent<BreakdownRowProps>;
+export default BreakdownRow;

package/dist/client/components/AnalysisBuilder/DisplayOptionControl.d.ts

@@ -0,0 +1,10 @@
+import { ChartDisplayConfig, ColorPalette } from '../../types';
+import { DisplayOptionConfig } from '../../charts/chartConfigs';
+interface DisplayOptionControlProps {
+    option: DisplayOptionConfig;
+    displayConfig: ChartDisplayConfig;
+    colorPalette?: ColorPalette;
+    onDisplayConfigChange: (config: ChartDisplayConfig) => void;
+}
+export default function DisplayOptionControl({ option, displayConfig, colorPalette, onDisplayConfigChange, }: DisplayOptionControlProps): import("react").JSX.Element | null;
+export {};

package/dist/client/components/AnalysisBuilder/ExecutionPlanPanelParts.d.ts

@@ -0,0 +1,22 @@
+import { ReactNode } from 'react';
+import { ExplainResult } from '../../types';
+export declare function SqlBlock({ sql, sqlLoading, sqlError, sqlPlaceholder, formattedSql, title, height, headerRight, }: {
+    sql: {
+        sql: string;
+        params?: unknown[];
+    } | null | undefined;
+    sqlLoading: boolean;
+    sqlError?: Error | null;
+    sqlPlaceholder: string;
+    formattedSql: string;
+    title: string;
+    height: string;
+    headerRight: ReactNode;
+}): import("react").JSX.Element;
+export declare function ExplainResults({ explainLoading, explainError, explainResult, useAnalyze, aiButton, }: {
+    explainLoading: boolean;
+    explainError?: Error | null;
+    explainResult: ExplainResult | null;
+    useAnalyze: boolean;
+    aiButton: ReactNode;
+}): import("react").JSX.Element | null;

package/dist/client/components/AnalysisBuilder/FieldSearchResults.d.ts

@@ -0,0 +1,16 @@
+import { FieldOption } from './types';
+import { MetaResponse } from '../../shared/types';
+interface FieldSearchResultsProps {
+    mode: 'metrics' | 'breakdown' | 'filter' | 'dimensionFilter';
+    schema: MetaResponse | null;
+    searchTerm: string;
+    recentOptions: FieldOption[];
+    groupedFields: Map<string, FieldOption[]>;
+    filteredCount: number;
+    selectedFields: string[];
+    focusedIndex: number;
+    onSelectField: (field: FieldOption, fieldIndex: number, shiftKey: boolean) => void;
+    onFocusField: (field: FieldOption, index: number) => void;
+}
+declare const FieldSearchResults: import('react').NamedExoticComponent<FieldSearchResultsProps>;
+export default FieldSearchResults;

package/dist/client/components/AnalysisBuilder/FilterValueInput.d.ts

@@ -0,0 +1,63 @@
+import { ChangeEvent, MouseEvent, KeyboardEvent, RefObject } from 'react';
+import { SimpleFilter } from '../../types';
+import { DateRangeType } from '../../shared/types';
+type OperatorMeta = {
+    requiresValues?: boolean;
+    valueType?: string;
+    supportsMultipleValues?: boolean;
+} | undefined;
+/** Which control to render: the filter being edited and its operator metadata. */
+export interface FilterFieldContext {
+    filter: SimpleFilter;
+    operatorMeta: OperatorMeta;
+    shouldShowDateRange: boolean;
+    shouldShowComboBox: boolean;
+}
+/** State + handlers for the date-range selector (inDateRange on time fields). */
+export interface DateRangeGroup {
+    rangeType: DateRangeType;
+    numberValue: number;
+    label: string;
+    isOpen: boolean;
+    onToggle: (open: boolean) => void;
+    onRangeTypeChange: (rangeType: DateRangeType) => void;
+    onNumberValueChange: (value: number) => void;
+    onCustomStartDate: (e: ChangeEvent<HTMLInputElement>) => void;
+    onCustomEndDate: (e: ChangeEvent<HTMLInputElement>) => void;
+    /** Close sibling dropdowns when this one opens. */
+    onOpen: () => void;
+}
+/** Async distinct-value combo-box state + handlers (equals/in on dimensions). */
+export interface ComboBoxGroup {
+    isOpen: boolean;
+    options: unknown[];
+    loading: boolean;
+    error: unknown;
+    searchText: string;
+    highlightedIndex: number;
+    listRef: RefObject<HTMLDivElement>;
+    onSearchTextChange: (text: string) => void;
+    onHighlightedIndexChange: (index: number) => void;
+    onSelect: (value: unknown, event?: MouseEvent | {
+        shiftKey: boolean;
+    }) => void;
+    onRemove: (value: unknown) => void;
+    onKeyDown: (e: KeyboardEvent) => void;
+    /** Open the combo-box, closing sibling dropdowns. */
+    onOpen: () => void;
+}
+/** Handlers for the plain between/date/number/text inputs. */
+export interface SimpleInputHandlers {
+    onBetweenStart: (e: ChangeEvent<HTMLInputElement>) => void;
+    onBetweenEnd: (e: ChangeEvent<HTMLInputElement>) => void;
+    onDate: (e: ChangeEvent<HTMLInputElement>) => void;
+    onDirect: (e: ChangeEvent<HTMLInputElement>) => void;
+}
+export interface FilterValueInputProps {
+    field: FilterFieldContext;
+    dateRange: DateRangeGroup;
+    combo: ComboBoxGroup;
+    inputs: SimpleInputHandlers;
+}
+export default function FilterValueInput({ field, dateRange, combo, inputs }: FilterValueInputProps): import("react").JSX.Element;
+export {};

package/dist/client/components/AnalysisBuilder/FlowDepthControls.d.ts

@@ -0,0 +1,10 @@
+import { ChartType } from '../../types';
+interface FlowDepthControlsProps {
+    chartType: ChartType;
+    stepsBefore: number;
+    stepsAfter: number;
+    onStepsBeforeChange: (count: number) => void;
+    onStepsAfterChange: (count: number) => void;
+}
+declare const FlowDepthControls: import('react').NamedExoticComponent<FlowDepthControlsProps>;
+export default FlowDepthControls;

package/dist/client/components/AnalysisBuilder/FlowVisualizationPicker.d.ts

@@ -0,0 +1,7 @@
+import { ChartType } from '../../types';
+interface FlowVisualizationPickerProps {
+    chartType: ChartType;
+    onChartTypeChange: (type: ChartType) => void;
+}
+declare const FlowVisualizationPicker: import('react').NamedExoticComponent<FlowVisualizationPickerProps>;
+export default FlowVisualizationPicker;

package/dist/client/components/AnalysisBuilder/LegacyBooleanOptions.d.ts

@@ -0,0 +1,8 @@
+import { ChartDisplayConfig } from '../../types';
+interface LegacyBooleanOptionsProps {
+    displayOptions?: string[];
+    displayConfig: ChartDisplayConfig;
+    onDisplayConfigChange: (config: ChartDisplayConfig) => void;
+}
+declare const LegacyBooleanOptions: import('react').NamedExoticComponent<LegacyBooleanOptionsProps>;
+export default LegacyBooleanOptions;

package/dist/client/components/AnalysisBuilder/MetricRow.d.ts

@@ -0,0 +1,23 @@
+import { DragEvent } from 'react';
+import { MetaField } from '../../shared/types';
+import { MetricItem } from './types';
+interface MetricRowProps {
+    metric: MetricItem;
+    fieldMeta: MetaField | null;
+    sortDirection: 'asc' | 'desc' | null;
+    sortPriority: number | undefined;
+    index: number;
+    transform: string;
+    showGapBefore: boolean;
+    isAnyDragging: boolean;
+    isDragging: boolean;
+    onRemove: (id: string) => void;
+    onOrderChange?: (field: string, direction: 'asc' | 'desc' | null) => void;
+    onReorder?: (fromIndex: number, toIndex: number) => void;
+    onItemDragOver: (e: DragEvent, index: number) => void;
+    onItemDrop: (e: DragEvent) => void;
+    onDragStart: (e: DragEvent, index: number) => void;
+    onDragEnd: () => void;
+}
+declare const MetricRow: import('react').NamedExoticComponent<MetricRowProps>;
+export default MetricRow;

package/dist/client/components/AnalysisBuilder/SortToggleButton.d.ts

@@ -0,0 +1,13 @@
+/**
+ * SortToggleButton Component
+ *
+ * Shared sort-direction toggle used by MetricItemCard and BreakdownItemCard.
+ * Renders the direction icon, optional sort-priority badge, and tooltip.
+ */
+interface SortToggleButtonProps {
+    sortDirection?: 'asc' | 'desc' | null;
+    sortPriority?: number;
+    onToggleSort: () => void;
+}
+declare const SortToggleButton: import('react').NamedExoticComponent<SortToggleButtonProps>;
+export default SortToggleButton;

package/dist/client/components/AnalysisBuilder/StringArrayInput.d.ts

@@ -0,0 +1,17 @@
+/**
+ * StringArrayInput Component
+ *
+ * A textarea that edits an array of strings. Uses local state while editing and
+ * only commits to the parent on blur. Extracted from DisplayOptionControl so the
+ * structured-option renderers stay presentational. Behaviour is identical to the
+ * previous inline implementation.
+ */
+interface StringArrayInputProps {
+    label: string;
+    value: string[];
+    onChange: (value: string[]) => void;
+    placeholder?: string;
+    description?: string;
+}
+export default function StringArrayInput({ label, value, onChange, placeholder, description, }: StringArrayInputProps): import("react").JSX.Element;
+export {};

package/dist/client/components/AnalysisBuilder/filterConfigModalUtils.d.ts

@@ -0,0 +1,30 @@
+/**
+ * filterConfigModalUtils
+ *
+ * Pure helpers extracted from FilterConfigModal to keep the component's effects
+ * and render flat. Behaviour is identical to the previous inline logic.
+ *
+ * `deriveRangeFromDateRange` lives in the shared `dateRangeUtils` module and is
+ * re-exported here to keep existing import paths stable.
+ */
+export type { DerivedRange } from '../shared/dateRangeUtils';
+export { deriveRangeFromDateRange } from '../shared/dateRangeUtils';
+/** Action the value-dropdown keyboard handler should apply, decided purely. */
+export type ValueKeyAction = {
+    type: 'none';
+} | {
+    type: 'highlight';
+    index: number;
+} | {
+    type: 'select';
+    index: number;
+} | {
+    type: 'close';
+};
+/**
+ * Pure keyboard-navigation logic for the filter value dropdown. Given the key
+ * and current state, returns the action to apply (no side effects), so the
+ * branchy decision can be unit-tested and the React handler stays a thin
+ * dispatcher.
+ */
+export declare function resolveValueKeyboardAction(key: string, isOpen: boolean, length: number, highlightedIndex: number): ValueKeyAction;

package/dist/client/components/AnalysisBuilder/hooks/useAnalysisBuilderImperativeHandle.d.ts

@@ -0,0 +1,13 @@
+import { Ref } from 'react';
+import { StoreApi } from 'zustand';
+import { AnalysisBuilderRef } from '../types';
+import { AnalysisBuilderStore } from '../../../stores/analysisBuilderStore';
+interface ImperativeHandleDeps {
+    getQueryConfig: AnalysisBuilderRef['getQueryConfig'];
+    getChartConfig: AnalysisBuilderRef['getChartConfig'];
+    getAnalysisType: AnalysisBuilderRef['getAnalysisType'];
+    clearQuery: AnalysisBuilderRef['clearQuery'];
+    storeApi: StoreApi<AnalysisBuilderStore>;
+}
+export declare function useAnalysisBuilderImperativeHandle(ref: Ref<AnalysisBuilderRef>, deps: ImperativeHandleDeps): void;
+export {};

package/dist/client/components/AnalysisBuilder/hooks/useDragReorder.d.ts

@@ -0,0 +1,25 @@
+import { DragEvent } from 'react';
+/**
+ * Calculate the vertical transform for an item while a drag is in progress.
+ * Pure helper extracted to keep the hook body flat.
+ */
+export declare function computeItemTransform(itemIndex: number, draggedIndex: number | null, dropTargetIndex: number | null): string;
+export interface DragReorderApi {
+    draggedIndex: number | null;
+    dropTargetIndex: number | null;
+    handleDragStart: (e: DragEvent, index: number) => void;
+    handleDragEnd: () => void;
+    handleItemDragOver: (e: DragEvent, itemIndex: number) => void;
+    handleItemDrop: (e: DragEvent) => void;
+    handleSectionDragLeave: (e: DragEvent) => void;
+    handleEndZoneDragOver: (e: DragEvent) => void;
+    getItemTransform: (itemIndex: number) => string;
+    shouldShowGapIndicator: (itemIndex: number) => boolean;
+}
+/**
+ * @param dragType  Label written into the drag dataTransfer payload.
+ * @param getField  Resolves the field name for a given index (for the payload).
+ * @param itemCount Current number of items (used for end-of-list drop zone).
+ * @param onReorder Optional reorder callback (fromIndex, toIndex).
+ */
+export declare function useDragReorder(dragType: string, getField: (index: number) => string, itemCount: number, onReorder?: (fromIndex: number, toIndex: number) => void): DragReorderApi;

package/dist/client/components/AnalysisBuilder/hooks/useFieldSearchKeyboard.d.ts

@@ -0,0 +1,11 @@
+import { KeyboardEvent, RefObject } from 'react';
+import { FieldOption } from '../types';
+export interface FieldSearchKeyboardApi {
+    focusedField: FieldOption | null;
+    setFocusedField: (field: FieldOption | null) => void;
+    focusedIndex: number;
+    setFocusedIndex: (index: number) => void;
+    resultsContainerRef: RefObject<HTMLDivElement>;
+    handleKeyDown: (e: KeyboardEvent) => void;
+}
+export declare function useFieldSearchKeyboard(flatFieldsList: FieldOption[], onSelectField: (field: FieldOption, fieldIndex: number, shiftKey: boolean) => void, onClose: () => void): FieldSearchKeyboardApi;

package/dist/client/components/AnalysisBuilder/utils/axisConfigUtils.d.ts

@@ -0,0 +1,23 @@
+import { ChartAxisConfig } from '../../../types';
+interface DropZoneShape {
+    key: string;
+    maxItems?: number;
+    enableDualAxis?: boolean;
+}
+/**
+ * Compute the new config after dropping `field` onto `toAxis` (optionally moving
+ * it from `fromAxis`). Applies the default left/right yAxisAssignment for dual-axis
+ * drop zones.
+ */
+export declare function applyAxisDrop(chartConfig: ChartAxisConfig, field: string, fromAxis: string, toAxis: string, dropZoneConfig: DropZoneShape | undefined): ChartAxisConfig;
+/**
+ * Compute the new config after removing `field` from `fromAxis`, cleaning up any
+ * yAxisAssignment entry.
+ */
+export declare function applyAxisRemove(chartConfig: ChartAxisConfig, field: string, fromAxis: string): ChartAxisConfig;
+/**
+ * Compute the new config after reordering items within `axisKey`. Returns null
+ * when no reorder is applicable (non-array, single item, or no-op move).
+ */
+export declare function applyAxisReorder(chartConfig: ChartAxisConfig, fromIndex: number, toIndex: number, axisKey: string): ChartAxisConfig | null;
+export {};

package/dist/client/components/AnalysisBuilder/utils/executionPlanMarkdown.d.ts

@@ -0,0 +1,8 @@
+import { CubeQuery } from '../../../types';
+import { QueryAnalysis } from '../../../shared/types';
+/**
+ * Generate markdown representation of query execution plan.
+ */
+export declare function generateExecutionPlanMarkdown(analysis: QueryAnalysis, query: CubeQuery | null, sql?: {
+    sql: string;
+} | null): string;

package/dist/client/components/AnalysisBuilder/utils/fieldUtils.d.ts

@@ -26,6 +26,11 @@ export declare function getFieldTitle(fieldName: string, schema: MetaResponse |
 export declare function getFieldType(field: MetaField): FieldType;
 /**
  * Convert schema to flat list of field options
+ *
+ * - 'metrics': measures only
+ * - 'breakdown' / 'dimensionFilter': dimensions only ('dimensionFilter' is used
+ *   for funnel step filters where measures don't work)
+ * - 'filter': both measures and dimensions
  */
 export declare function schemaToFieldOptions(schema: MetaResponse | null, mode: 'metrics' | 'breakdown' | 'filter' | 'dimensionFilter'): FieldOption[];
 /**

package/dist/client/components/AnalysisBuilder/utils/resultsPanelDerive.d.ts

@@ -0,0 +1,68 @@
+/**
+ * resultsPanelDerive
+ *
+ * Small pure helpers for AnalysisResultsPanel derived values, extracted to keep
+ * the component body flat. Behaviour is identical to the previous inline logic.
+ */
+export interface DebugDataEntry {
+    sql: unknown;
+    analysis: unknown;
+    mode: unknown;
+    queryType: unknown;
+    joinType: unknown;
+    cubesUsed: unknown[];
+    modeMetadata: unknown;
+    loading: boolean;
+    error: unknown;
+}
+/**
+ * Resolve the active debug entry, falling back to an empty placeholder.
+ * The fallback is cast to the element type so callers keep their precise typing.
+ */
+export declare function resolveDebugData<T>(debugDataPerQuery: T[], activeDebugIndex: number): T;
+interface ChartViewParams {
+    isCurrentChartRenderable: boolean;
+    isFlowMode: boolean;
+    isFunnelMode: boolean;
+    isRetentionMode: boolean;
+}
+/** Whether the chart view toggle should be enabled. */
+export declare function isChartViewEnabled({ isCurrentChartRenderable, isFlowMode, isFunnelMode, isRetentionMode }: ChartViewParams): boolean;
+/**
+ * Whether the panel has meaningful results to display, accounting for the
+ * different data shapes per analysis mode.
+ */
+export declare function computeHasResults(executionResults: unknown[] | null | undefined, isFlowMode: boolean, isRetentionMode: boolean, retentionChartData: {
+    rows: unknown[];
+} | null | undefined): boolean;
+interface TableSelectionParams<Q, R> {
+    tableIndex: number | undefined;
+    isMultiQuery: unknown;
+    allQueries: Q[] | null | undefined;
+    perQueryResults: R[] | null | undefined;
+    executionResults: R | null | undefined;
+    combinedQueryForChart: Q | undefined;
+}
+/**
+ * Resolve the data + query object for a table view given the requested index.
+ * tableIndex: undefined = single query, -1 = merged view, 0+ = per-query view.
+ */
+export declare function selectTableData<Q, R>({ tableIndex, isMultiQuery, allQueries, perQueryResults, executionResults, combinedQueryForChart }: TableSelectionParams<Q, R>): {
+    tableData: R | null;
+    tableQuery: Q | undefined;
+};
+/**
+ * Resolve the display source/target event names for a flow Sankey link, handling
+ * both transformed (`source`/`target`) and raw (`source_id`/`target_id`) shapes.
+ */
+export declare function flowLinkNames(link: Record<string, unknown>): {
+    sourceName: string;
+    targetName: string;
+};
+/**
+ * Multi-query mode (but NOT funnel mode — funnels always show unified results).
+ */
+export declare function computeIsMultiQuery(isFunnelMode: boolean, queryCount: number, perQueryResults: unknown[] | null | undefined): boolean;
+/** Title/tooltip for the chart view toggle button. */
+export declare function chartViewButtonTitle(chartViewEnabled: boolean, chartViewUnavailableReason: string | undefined, t: (key: string) => string): string;
+export {};

package/dist/client/components/AnalysisBuilder/utils/shareStateUtils.d.ts

@@ -0,0 +1,68 @@
+import { AnalysisConfig } from '../../../types/analysisConfig';
+/**
+ * Extract funnel initial state from a shared AnalysisConfig.
+ *
+ * Phase 3: funnel config is in query.funnel, chart config is in charts.funnel.
+ */
+export declare function extractFunnelStateFromShare(sharedState: AnalysisConfig | null): {
+    funnelCube: null;
+    funnelSteps: never[];
+    funnelTimeDimension: string | null;
+    funnelBindingKey: {
+        dimension: string | {
+            cube: string;
+            dimension: string;
+        }[];
+    } | null;
+    funnelChartType: import('../../..').ChartType;
+    funnelChartConfig: import('../../..').ChartAxisConfig;
+    funnelDisplayConfig: import('../../..').ChartDisplayConfig;
+} | undefined;
+/**
+ * Extract flow initial state from a shared AnalysisConfig.
+ */
+export declare function extractFlowStateFromShare(sharedState: AnalysisConfig | null): {
+    flowCube: null;
+    flowBindingKey: {
+        dimension: string;
+    } | null;
+    flowTimeDimension: string | null;
+    startingStep: {
+        name: string;
+        filters: import('../../../types').Filter[];
+    };
+    stepsBefore: number;
+    stepsAfter: number;
+    eventDimension: string | null;
+    flowChartType: import('../../..').ChartType;
+    flowChartConfig: import('../../..').ChartAxisConfig;
+    flowDisplayConfig: import('../../..').ChartDisplayConfig;
+} | undefined;
+/**
+ * Extract retention initial state from a shared AnalysisConfig.
+ */
+export declare function extractRetentionStateFromShare(sharedState: AnalysisConfig | null): {
+    retentionCube: null;
+    retentionBindingKey: {
+        dimension: string;
+    } | {
+        dimension: {
+            cube: string;
+            dimension: string;
+        }[];
+    } | null;
+    retentionTimeDimension: string | null;
+    retentionDateRange: import('../../../types/retention').DateRange;
+    retentionCohortFilters: import('../../../types').Filter[];
+    retentionActivityFilters: import('../../../types').Filter[];
+    retentionBreakdowns: {
+        field: string;
+        label: string;
+    }[];
+    retentionViewGranularity: import('../../../types/retention').RetentionGranularity;
+    retentionPeriods: number;
+    retentionType: import('../../../types/retention').RetentionType;
+    retentionChartType: import('../../..').ChartType;
+    retentionChartConfig: import('../../..').ChartAxisConfig;
+    retentionDisplayConfig: import('../../..').ChartDisplayConfig;
+} | undefined;

package/dist/client/components/AnalysisBuilder/utils/sortUtils.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Sort direction cycle helper shared by query section components.
+ */
+/**
+ * Get next sort direction in the cycle: null -> asc -> desc -> null
+ */
+export declare function getNextSortDirection(current: 'asc' | 'desc' | null): 'asc' | 'desc' | null;