drizzle-cube 0.6.0 → 0.6.2

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

@@ -0,0 +1,245 @@
+import { ColorPalette } from '../utils/colorPalettes.js';
+import { CubeQuery, MultiQueryConfig, ChartType, ChartAxisConfig, ChartDisplayConfig, Filter, QueryMergeStrategy, FunnelBindingKey, AnalysisType, FunnelStepState } from '../types.js';
+import { AnalysisBuilderState, MetricItem, BreakdownItem, ExecutionStatus, QueryPanelTab } from '../components/AnalysisBuilder/types.js';
+import { ChartAvailabilityMap } from '../shared/chartDefaults.js';
+import { DebugDataEntry } from './queries/index.js';
+import { MultiQueryValidationResult } from '../utils/multiQueryValidation.js';
+import { MetaField } from '../shared/types.js';
+import { ValidationResult } from '../adapters/modeAdapter.js';
+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: QueryMergeStrategy;
+    isMultiQueryMode: boolean;
+    mergeKeys: string[] | undefined;
+    currentQuery: CubeQuery;
+    allQueries: CubeQuery[];
+    multiQueryConfig: MultiQueryConfig | null;
+    multiQueryValidation: MultiQueryValidationResult | null;
+    funnelBindingKey: FunnelBindingKey | null;
+    /** Whether funnel mode is properly configured and ready for execution */
+    isFunnelModeEnabled: boolean;
+    /** Current analysis type (query, multi, funnel) */
+    analysisType: AnalysisType;
+    /** Selected cube for funnel mode (all steps use this cube) */
+    funnelCube: string | null;
+    /** Dedicated funnel steps (when analysisType === 'funnel') */
+    funnelSteps: FunnelStepState[];
+    /** Index of currently active funnel step */
+    activeFunnelStepIndex: number;
+    /** Time dimension for funnel temporal ordering */
+    funnelTimeDimension: string | null;
+    /** Chart type for funnel mode (separate from query mode) */
+    funnelChartType: ChartType;
+    /** Chart config for funnel mode (separate from query mode) */
+    funnelChartConfig: ChartAxisConfig;
+    /** Display config for funnel mode (separate from query mode) */
+    funnelDisplayConfig: ChartDisplayConfig;
+    /** Selected cube for flow mode */
+    flowCube: string | null;
+    /** Binding key for flow mode (entity linking) */
+    flowBindingKey: FunnelBindingKey | null;
+    /** Time dimension for flow mode (event ordering) */
+    flowTimeDimension: string | null;
+    /** Event dimension for flow mode (node labels in Sankey) */
+    eventDimension: string | null;
+    /** Starting step configuration */
+    startingStep: import('../types/flow.js').FlowStartingStep;
+    /** Number of steps to explore before starting step */
+    stepsBefore: number;
+    /** Number of steps to explore after starting step */
+    stepsAfter: number;
+    /** Join strategy for flow execution */
+    joinStrategy: 'auto' | 'lateral' | 'window';
+    /** Display config for flow mode */
+    flowDisplayConfig: ChartDisplayConfig;
+    /** Single cube for retention analysis */
+    retentionCube: string | null;
+    /** Binding key for retention mode */
+    retentionBindingKey: import('../types/funnel.js').FunnelBindingKey | null;
+    /** Single timestamp dimension for retention mode */
+    retentionTimeDimension: string | null;
+    /** Date range for cohort analysis (REQUIRED) */
+    retentionDateRange: import('../types/retention.js').DateRange;
+    /** Cohort filters for retention mode */
+    retentionCohortFilters: import('../types.js').Filter[];
+    /** Activity filters for retention mode */
+    retentionActivityFilters: import('../types.js').Filter[];
+    /** Optional breakdown dimensions for segmenting the cohort */
+    retentionBreakdowns: import('../types/retention.js').RetentionBreakdownItem[];
+    /** Granularity for viewing retention periods (day/week/month) */
+    retentionViewGranularity: import('../types/retention.js').RetentionGranularity;
+    /** Number of periods for retention mode */
+    retentionPeriods: number;
+    /** Retention calculation type */
+    retentionType: import('../types/retention.js').RetentionType;
+    /** Display config for retention mode */
+    retentionDisplayConfig: ChartDisplayConfig | undefined;
+    executionStatus: ExecutionStatus;
+    executionResults: unknown[] | null;
+    perQueryResults: (unknown[] | null)[] | null;
+    isLoading: boolean;
+    isFetching: boolean;
+    error: Error | null;
+    isValidQuery: boolean;
+    debugDataPerQuery: DebugDataEntry[];
+    /**
+     * Whether the current query config differs from the last executed query.
+     * Used for manual refresh mode to show "needs refresh" indicator.
+     */
+    needsRefresh: boolean;
+    /**
+     * Query warnings from the server (e.g., fan-out without dimensions).
+     * Displayed as a banner above results.
+     */
+    warnings: import('../shared/types.js').QueryWarning[] | undefined;
+    /** In funnel mode, the actually executed queries with binding key dimension and IN filters */
+    funnelExecutedQueries: CubeQuery[] | null;
+    /** In funnel mode, the actual server query { funnel: {...} } sent to the API */
+    funnelServerQuery: unknown | null;
+    /** In funnel mode, unified debug data (SQL, analysis, mode metadata) */
+    funnelDebugData: DebugDataEntry | null;
+    /** In flow mode, the actual server query { flow: {...} } sent to the API */
+    flowServerQuery: unknown | null;
+    /** In flow mode, unified debug data (SQL, analysis, mode metadata) */
+    flowDebugData: DebugDataEntry | null;
+    /** In retention mode, the actual server query { retention: {...} } sent to the API */
+    retentionServerQuery: unknown | null;
+    /** In retention mode, unified debug data (SQL, analysis, mode metadata) */
+    retentionDebugData: DebugDataEntry | null;
+    /** In retention mode, the chart data (cohort × period matrix) */
+    retentionChartData: import('../types/retention.js').RetentionChartData | null;
+    /** In retention mode, validation result (errors explaining why query cannot be built) */
+    retentionValidation: {
+        isValid: boolean;
+        errors: string[];
+        warnings: string[];
+    } | null;
+    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;
+    /** Validation result from the adapter for the current analysis type */
+    adapterValidation: ValidationResult;
+    actions: {
+        setActiveQueryIndex: (index: number) => void;
+        setMergeStrategy: (strategy: QueryMergeStrategy) => 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;
+        setLimit: (limit: number | undefined) => void;
+        addQuery: () => void;
+        removeQuery: (index: number) => void;
+        setFunnelBindingKey: (bindingKey: FunnelBindingKey | null) => void;
+        setAnalysisType: (type: AnalysisType) => void;
+        setFunnelCube: (cube: string | null) => void;
+        addFunnelStep: () => void;
+        removeFunnelStep: (index: number) => void;
+        updateFunnelStep: (index: number, updates: Partial<FunnelStepState>) => void;
+        setActiveFunnelStepIndex: (index: number) => void;
+        reorderFunnelSteps: (fromIndex: number, toIndex: number) => void;
+        setFunnelTimeDimension: (dimension: string | null) => void;
+        setFunnelDisplayConfig: (config: ChartDisplayConfig) => void;
+        setFlowCube: (cube: string | null) => void;
+        setFlowBindingKey: (key: FunnelBindingKey | null) => void;
+        setFlowTimeDimension: (dim: string | null) => void;
+        setEventDimension: (dim: string | null) => void;
+        setStartingStepName: (name: string) => void;
+        setStartingStepFilters: (filters: Filter[]) => void;
+        setStepsBefore: (count: number) => void;
+        setStepsAfter: (count: number) => void;
+        setJoinStrategy: (strategy: 'auto' | 'lateral' | 'window') => void;
+        setFlowDisplayConfig: (config: ChartDisplayConfig) => void;
+        setRetentionCube: (cube: string | null) => void;
+        setRetentionBindingKey: (key: import('../types/funnel.js').FunnelBindingKey | null) => void;
+        setRetentionTimeDimension: (dim: string | null) => void;
+        setRetentionDateRange: (range: import('../types/retention.js').DateRange) => void;
+        setRetentionCohortFilters: (filters: import('../types.js').Filter[]) => void;
+        setRetentionActivityFilters: (filters: import('../types.js').Filter[]) => void;
+        setRetentionBreakdowns: (breakdowns: import('../types/retention.js').RetentionBreakdownItem[]) => void;
+        addRetentionBreakdown: (breakdown: import('../types/retention.js').RetentionBreakdownItem) => void;
+        removeRetentionBreakdown: (field: string) => void;
+        setRetentionViewGranularity: (granularity: import('../types/retention.js').RetentionGranularity) => void;
+        setRetentionPeriods: (periods: number) => void;
+        setRetentionType: (type: import('../types/retention.js').RetentionType) => void;
+        setRetentionDisplayConfig: (config: ChartDisplayConfig) => 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;
+        clearCurrentMode: () => void;
+        refetch: (options?: {
+            bustCache?: boolean;
+        }) => void;
+        handleFieldSelected: (field: MetaField, fieldType: 'measure' | 'dimension' | 'timeDimension', cubeName: string, keepOpen?: boolean) => void;
+    };
+    getQueryConfig: () => CubeQuery | MultiQueryConfig | import('../types/funnel.js').ServerFunnelQuery;
+    getChartConfig: () => {
+        chartType: ChartType;
+        chartConfig: ChartAxisConfig;
+        displayConfig: ChartDisplayConfig;
+    };
+    getAnalysisType: () => AnalysisType;
+}
+export declare function useAnalysisBuilder(options?: UseAnalysisBuilderOptions): UseAnalysisBuilderResult;

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

@@ -0,0 +1,35 @@
+import { ColorPalette } from '../utils/colorPalettes.js';
+import { ChartType, ChartAxisConfig, ChartDisplayConfig } from '../types.js';
+import { MetricItem, BreakdownItem } from '../components/AnalysisBuilder/types.js';
+import { ChartAvailabilityMap } from '../shared/chartDefaults.js';
+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/cjs/client/hooks/useAnalysisCombinedFields.d.ts

@@ -0,0 +1,18 @@
+import { AnalysisBuilderState, MetricItem, BreakdownItem } from '../components/AnalysisBuilder/types.js';
+import { QueryMergeStrategy } from '../types.js';
+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/cjs/client/hooks/useAnalysisInitialization.d.ts

@@ -0,0 +1,25 @@
+import { CubeQuery, ChartType, ChartAxisConfig, ChartDisplayConfig } from '../types.js';
+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/cjs/client/hooks/useAnalysisQueryBuilder.d.ts

@@ -0,0 +1,32 @@
+import { MultiQueryValidationResult } from '../utils/multiQueryValidation.js';
+import { CubeQuery, MultiQueryConfig, QueryMergeStrategy } from '../types.js';
+import { AnalysisBuilderState } from '../components/AnalysisBuilder/types.js';
+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/cjs/client/hooks/useAnalysisQueryExecution.d.ts

@@ -0,0 +1,144 @@
+import { DebugDataEntry } from './queries/index.js';
+import { CubeQuery, MultiQueryConfig, FunnelBindingKey, QueryMergeStrategy, AnalysisType } from '../types.js';
+import { ExecutionStatus } from '../components/AnalysisBuilder/types.js';
+import { ServerFunnelQuery } from '../types/funnel.js';
+import { ServerFlowQuery, FlowChartData } from '../types/flow.js';
+import { ServerRetentionQuery, RetentionChartData } from '../types/retention.js';
+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[];
+    /** Merge strategy (for detecting funnel mode - legacy) */
+    mergeStrategy?: QueryMergeStrategy;
+    /** Funnel binding key (required for funnel mode) */
+    funnelBindingKey?: FunnelBindingKey | null;
+    /**
+     * Whether funnel mode is properly configured (from store).
+     * This includes filter-only step validation that isMultiQueryMode doesn't provide.
+     * @deprecated Use analysisType === 'funnel' instead
+     */
+    isFunnelModeEnabled?: boolean;
+    /**
+     * Analysis type for explicit mode routing.
+     * When provided, takes precedence over legacy mode detection.
+     */
+    analysisType?: AnalysisType;
+    /**
+     * Pre-built server funnel query from store's buildFunnelQueryFromSteps().
+     * Used when analysisType === 'funnel' with the new dedicated funnel state.
+     */
+    serverFunnelQuery?: ServerFunnelQuery | null;
+    /**
+     * Pre-built server flow query from store's buildFlowQuery().
+     * Used when analysisType === 'flow' with the new dedicated flow state.
+     */
+    serverFlowQuery?: ServerFlowQuery | null;
+    /**
+     * Pre-built server retention query from store's buildRetentionQuery().
+     * Used when analysisType === 'retention' with the new dedicated retention state.
+     */
+    serverRetentionQuery?: ServerRetentionQuery | null;
+    /**
+     * Validation result for retention mode from store's getRetentionValidation().
+     * Used to display specific errors in the debug panel.
+     */
+    retentionValidation?: {
+        isValid: boolean;
+        errors: string[];
+        warnings: string[];
+    } | null;
+}
+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 (for non-funnel modes) */
+    debugDataPerQuery: DebugDataEntry[];
+    /** Whether query has been debounced (for smart defaults trigger) */
+    hasDebounced: boolean;
+    /** Refetch function. Pass { bustCache: true } to bypass client and server caches. */
+    refetch: (options?: {
+        bustCache?: boolean;
+    }) => void;
+    /**
+     * In funnel mode, these are the actually executed queries with:
+     * - Binding key dimension auto-added
+     * - IN filter applied for steps 2+
+     * Use these for debug display instead of the original queries.
+     * @deprecated Server-side funnel uses a unified query. Use funnelServerQuery instead.
+     */
+    funnelExecutedQueries: CubeQuery[] | null;
+    /**
+     * The actual server funnel query { funnel: {...} }
+     * This is the unified query sent to the server (not per-step queries).
+     */
+    funnelServerQuery: ServerFunnelQuery | null;
+    /**
+     * Debug data specifically for funnel mode
+     * Contains unified dry-run SQL and mode metadata.
+     */
+    funnelDebugData: DebugDataEntry | null;
+    /**
+     * The server flow query being executed (when analysisType === 'flow')
+     */
+    flowServerQuery: ServerFlowQuery | null;
+    /**
+     * Flow chart data (nodes and links for Sankey visualization)
+     */
+    flowChartData: FlowChartData | null;
+    /**
+     * Debug data specifically for flow mode
+     * Contains unified dry-run SQL and mode metadata.
+     */
+    flowDebugData: DebugDataEntry | null;
+    /**
+     * The server retention query being executed (when analysisType === 'retention')
+     */
+    retentionServerQuery: ServerRetentionQuery | null;
+    /**
+     * Retention chart data (cohort × period matrix)
+     */
+    retentionChartData: RetentionChartData | null;
+    /**
+     * Debug data specifically for retention mode
+     * Contains unified dry-run SQL and mode metadata.
+     */
+    retentionDebugData: DebugDataEntry | null;
+    /**
+     * Retention validation result (errors explaining why query cannot be built)
+     */
+    retentionValidation: {
+        isValid: boolean;
+        errors: string[];
+        warnings: string[];
+    } | null;
+    /**
+     * Whether the current query config differs from the last executed query.
+     * Used for manual refresh mode to show "needs refresh" indicator.
+     */
+    needsRefresh: boolean;
+    /**
+     * Query warnings from the server (e.g., fan-out without dimensions).
+     * Displayed as a banner above results.
+     */
+    warnings: import('../shared/types.js').QueryWarning[] | undefined;
+}
+export declare function useAnalysisQueryExecution(options: UseAnalysisQueryExecutionOptions): UseAnalysisQueryExecutionResult;

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

@@ -0,0 +1,18 @@
+import { AnalysisConfig } from '../types/analysisConfig.js';
+interface UseAnalysisShareOptions {
+    /** Whether the current query is valid */
+    isValidQuery: boolean;
+    /**
+     * Getter for the AnalysisConfig (from store.save())
+     * This is the new Phase 3 API - returns complete AnalysisConfig
+     */
+    getAnalysisConfig: () => AnalysisConfig;
+}
+interface UseAnalysisShareResult {
+    /** Current share button state */
+    shareButtonState: 'idle' | 'copied' | 'copied-no-chart';
+    /** Handle share button click */
+    handleShare: () => Promise<void>;
+}
+export declare function useAnalysisShare({ isValidQuery, getAnalysisConfig, }: UseAnalysisShareOptions): UseAnalysisShareResult;
+export {};

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

@@ -0,0 +1,24 @@
+import { FieldModalMode } from '../stores/analysisBuilderStore.js';
+import { QueryPanelTab } from '../components/AnalysisBuilder/types.js';
+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/cjs/client/hooks/useCubeFieldLabel.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Optimized hook that only subscribes to field label functionality
+ * from CubeMeta context. This prevents re-renders when unrelated
+ * contexts (CubeApi, Features) change.
+ *
+ * Use this instead of useCubeContext() when you only need getFieldLabel.
+ */
+/**
+ * Returns a stable reference to the getFieldLabel function.
+ * Components using this hook will only re-render when the field label
+ * mapping actually changes, not when unrelated API or feature contexts update.
+ *
+ * @returns Function to get human-readable label for a field name
+ * @throws Error if used outside CubeProvider
+ */
+export declare function useCubeFieldLabel(): (fieldName: string) => string;