drizzle-cube 0.6.1 → 0.6.3

package/dist/cjs/client/hooks/queries/useRetentionQuery.d.ts

@@ -0,0 +1,67 @@
+import { ServerRetentionQuery, RetentionChartData, RetentionResultRow } from '../../types/retention.js';
+/**
+ * Options for retention query hook
+ */
+export interface UseRetentionQueryOptions {
+    /** Skip execution */
+    skip?: boolean;
+    /** Debounce delay in milliseconds */
+    debounceMs?: number;
+    /** Callback when query completes */
+    onComplete?: (result: RetentionChartData) => void;
+    /** Callback when query fails */
+    onError?: (error: Error) => void;
+    /** Function to resolve field names to human-readable display labels */
+    getFieldLabel?: (fieldName: string) => string;
+}
+/**
+ * Result from retention query hook
+ */
+export interface UseRetentionQueryResult {
+    /** Retention chart data */
+    chartData: RetentionChartData | null;
+    /** Raw data rows from server */
+    rawData: RetentionResultRow[] | null;
+    /** Current execution status */
+    status: 'idle' | 'loading' | 'success' | 'error';
+    /** Whether currently loading */
+    isLoading: boolean;
+    /** Whether fetching (includes refetch) */
+    isFetching: boolean;
+    /** Whether waiting for debounce */
+    isDebouncing: boolean;
+    /** Error if execution failed */
+    error: Error | null;
+    /** Cache metadata when served from cache */
+    cacheInfo?: {
+        hit: true;
+        cachedAt: string;
+        ttlMs: number;
+        ttlRemainingMs: number;
+    } | null;
+    /** Execute the query (for manual refresh mode) */
+    execute: (options?: {
+        bustCache?: boolean;
+    }) => Promise<RetentionChartData | null>;
+    /** Refetch the query */
+    refetch: () => void;
+    /**
+     * Whether the query needs to be refreshed (manual refresh mode only).
+     * True when the current query config differs from the last executed query.
+     */
+    needsRefresh: boolean;
+}
+/**
+ * Hook for server-side retention query execution
+ *
+ * Usage:
+ * ```tsx
+ * const { chartData, isLoading, error } = useRetentionQuery(serverQuery, {
+ *   debounceMs: 300,
+ *   skip: !hasRequiredFields
+ * })
+ *
+ * <RetentionHeatmap data={chartData} />
+ * ```
+ */
+export declare function useRetentionQuery(serverQuery: ServerRetentionQuery | null, options?: UseRetentionQueryOptions): UseRetentionQueryResult;

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

@@ -0,0 +1,60 @@
+import { PortletBlock, MarkdownBlock } from '../stores/notebookStore.js';
+export interface UseAgentChatOptions {
+    /** Override default agent endpoint (default: apiUrl + '/agent/chat') */
+    agentEndpoint?: string;
+    /** Client-side API key for demo/try-site use */
+    agentApiKey?: string;
+    /** Override LLM provider (anthropic | openai | google) */
+    agentProvider?: string;
+    /** Override LLM model (e.g. 'gpt-4o', 'gemini-2.0-flash') */
+    agentModel?: string;
+    /** Override provider endpoint URL (for OpenAI-compatible services) */
+    agentProviderEndpoint?: string;
+    /** Called when agent adds a portlet to the notebook */
+    onAddPortlet: (data: PortletBlock) => void;
+    /** Called when agent adds a markdown block to the notebook */
+    onAddMarkdown: (data: MarkdownBlock) => void;
+    /** Called when the agent saves a dashboard configuration */
+    onDashboardSaved?: (data: {
+        title: string;
+        description?: string;
+        dashboardConfig: any;
+    }) => void;
+    /** Called when streaming text arrives */
+    onTextDelta: (text: string) => void;
+    /** Called when a tool call starts */
+    onToolStart: (id: string, name: string, input?: unknown) => void;
+    /** Called when a tool call completes */
+    onToolResult: (id: string, name: string, result?: unknown, isError?: boolean) => void;
+    /** Called when the agent completes with session ID and optional trace ID */
+    onDone: (sessionId: string, traceId?: string) => void;
+    /** Called when a turn completes (between agentic turns) */
+    onTurnComplete?: () => void;
+    /** Called on error */
+    onError: (message: string) => void;
+}
+/** Simplified message format for sending conversation history */
+export interface AgentHistoryMessage {
+    role: 'user' | 'assistant';
+    content: string;
+    toolCalls?: Array<{
+        id: string;
+        name: string;
+        input?: unknown;
+        result?: unknown;
+        status: 'running' | 'complete' | 'error';
+    }>;
+}
+export interface UseAgentChatResult {
+    /** Send a message to the agent, optionally with prior conversation history */
+    sendMessage: (content: string, sessionId?: string | null, history?: AgentHistoryMessage[]) => Promise<void>;
+    /** Whether the agent is currently streaming */
+    isStreaming: boolean;
+    /** Abort the current stream */
+    abort: () => void;
+}
+/**
+ * Hook for streaming chat with the agentic notebook backend.
+ * Uses fetch() with ReadableStream to consume SSE events.
+ */
+export declare function useAgentChat(options: UseAgentChatOptions): UseAgentChatResult;

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/useAnalysisEffects.d.ts

@@ -0,0 +1,33 @@
+import { CubeQuery, ChartType, ChartAxisConfig, ChartDisplayConfig } from '../types.js';
+import { AIState } from '../components/AnalysisBuilder/types.js';
+import { UseAnalysisStateResult } from './useAnalysisState.js';
+import { UseAnalysisQueryResult } from './useAnalysisQuery.js';
+export interface UseAnalysisEffectsOptions {
+    /** State responsibility hook result (store reads/derivation + actions) */
+    state: UseAnalysisStateResult;
+    /** Query responsibility hook result (execution + hasDebounced) */
+    query: UseAnalysisQueryResult;
+    /** AI endpoint URL */
+    aiEndpoint?: string;
+    /** Callback when query changes */
+    onQueryChange?: (query: CubeQuery) => void;
+    /** Callback when chart config changes */
+    onChartConfigChange?: (config: {
+        chartType: ChartType;
+        chartConfig: ChartAxisConfig;
+        displayConfig: ChartDisplayConfig;
+    }) => void;
+}
+export declare function useAnalysisEffects(options: UseAnalysisEffectsOptions): {
+    aiState: AIState;
+    openAI: () => void;
+    closeAI: () => void;
+    setAIPrompt: (prompt: string) => void;
+    generateAI: () => Promise<void>;
+    acceptAI: () => void;
+    cancelAI: () => void;
+    shareButtonState: "idle" | "copied" | "copied-no-chart";
+    share: () => Promise<void>;
+    canShare: boolean;
+};
+export type UseAnalysisEffectsResult = ReturnType<typeof useAnalysisEffects>;

package/dist/{client/hooks/useAnalysisQueryExecution.d.ts → cjs/client/hooks/useAnalysisQuery.d.ts}

@@ -4,7 +4,7 @@ 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 {
+export interface UseAnalysisQueryOptions {
     /** Current query (for single-query mode) */
     currentQuery: CubeQuery;
     /** All queries (for dry-run and multi-query) */
@@ -57,7 +57,7 @@ export interface UseAnalysisQueryExecutionOptions {
         warnings: string[];
     } | null;
 }
-export interface UseAnalysisQueryExecutionResult {
+export interface UseAnalysisQueryResult {
     /** Query execution status */
     executionStatus: ExecutionStatus;
     /** Query results (merged for multi-query) */
@@ -141,4 +141,4 @@ export interface UseAnalysisQueryExecutionResult {
      */
     warnings: import('../shared/types.js').QueryWarning[] | undefined;
 }
-export declare function useAnalysisQueryExecution(options: UseAnalysisQueryExecutionOptions): UseAnalysisQueryExecutionResult;
+export declare function useAnalysisQuery(options: UseAnalysisQueryOptions): UseAnalysisQueryResult;

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

@@ -0,0 +1,165 @@
+import { MultiQueryValidationResult } from '../utils/multiQueryValidation.js';
+import { ColorPalette } from '../utils/colorPalettes.js';
+import { MultiQueryConfig, ChartType, ChartAxisConfig, ChartDisplayConfig } from '../types.js';
+import { MetricItem, BreakdownItem } from '../components/AnalysisBuilder/types.js';
+import { ChartAvailabilityMap } from '../shared/chartDefaults.js';
+import { MetaField } from '../shared/types.js';
+export interface UseAnalysisStateOptions {
+    /** External color palette (overrides local) */
+    externalColorPalette?: string[] | ColorPalette;
+}
+export declare function useAnalysisState(options?: UseAnalysisStateOptions): {
+    storeApi: import('zustand').StoreApi<import('../index.js').AnalysisBuilderStore>;
+    queryState: import('../components/AnalysisBuilder/types.js').AnalysisBuilderState;
+    queryStates: import('../components/AnalysisBuilder/types.js').AnalysisBuilderState[];
+    activeQueryIndex: number;
+    mergeStrategy: import('../types.js').QueryMergeStrategy;
+    isMultiQueryMode: boolean;
+    mergeKeys: string[] | undefined;
+    currentQuery: import('../types.js').CubeQuery;
+    allQueries: import('../types.js').CubeQuery[];
+    multiQueryConfig: MultiQueryConfig | null;
+    multiQueryValidation: MultiQueryValidationResult | null;
+    /** Raw query/multi validity (independent of mode) */
+    isValidQuery: boolean | undefined;
+    /** Mode-aware validity (funnel/flow/retention/query) */
+    effectiveIsValidQuery: boolean;
+    combinedMetrics: MetricItem[];
+    combinedBreakdowns: BreakdownItem[];
+    effectiveBreakdowns: BreakdownItem[];
+    analysisType: import('../types.js').AnalysisType;
+    funnelBindingKey: import('../types.js').FunnelBindingKey | null;
+    isFunnelModeEnabled: boolean;
+    funnelCube: string | null;
+    funnelSteps: import('../types.js').FunnelStepState[];
+    activeFunnelStepIndex: number;
+    funnelTimeDimension: string | null;
+    funnelChartType: ChartType;
+    funnelChartConfig: ChartAxisConfig;
+    funnelDisplayConfig: ChartDisplayConfig;
+    serverFunnelQuery: import('../types.js').ServerFunnelQuery | null;
+    flowCube: string | null;
+    flowBindingKey: import('../types.js').FunnelBindingKey | null;
+    flowTimeDimension: string | null;
+    eventDimension: string | null;
+    startingStep: import('../types.js').FlowStartingStep;
+    stepsBefore: number;
+    stepsAfter: number;
+    joinStrategy: "auto" | "lateral" | "window";
+    flowDisplayConfig: ChartDisplayConfig;
+    serverFlowQuery: import('../types.js').ServerFlowQuery | null;
+    retentionCube: string | null;
+    retentionBindingKey: import('../types.js').FunnelBindingKey | null;
+    retentionTimeDimension: string | null;
+    retentionDateRange: import('../types/retention.js').DateRange;
+    retentionCohortFilters: import('../types.js').Filter[];
+    retentionActivityFilters: import('../types.js').Filter[];
+    retentionBreakdowns: import('../types/retention.js').RetentionBreakdownItem[];
+    retentionViewGranularity: import('../types/retention.js').RetentionGranularity;
+    retentionPeriods: number;
+    retentionType: import('../types/retention.js').RetentionType;
+    retentionDisplayConfig: ChartDisplayConfig | undefined;
+    serverRetentionQuery: import('../types/retention.js').ServerRetentionQuery | null;
+    retentionValidation: {
+        isValid: boolean;
+        errors: string[];
+        warnings: string[];
+    } | null;
+    chartType: ChartType;
+    chartConfig: ChartAxisConfig;
+    displayConfig: ChartDisplayConfig;
+    colorPalette: ColorPalette;
+    localPaletteName: string;
+    chartAvailability: ChartAvailabilityMap;
+    userManuallySelectedChart: boolean;
+    activeTab: import('../components/AnalysisBuilder/types.js').QueryPanelTab;
+    activeView: "table" | "chart";
+    displayLimit: number;
+    showFieldModal: boolean;
+    fieldModalMode: import('../index.js').FieldModalMode;
+    activeTableIndex: number;
+    adapterValidation: import('../adapters/modeAdapter.js').ValidationResult;
+    getQueryConfig: () => import('../types.js').CubeQuery | import('../types.js').ServerFunnelQuery | {
+        queries: import('../types.js').CubeQuery[];
+        mergeStrategy: import('../types.js').QueryMergeStrategy;
+        mergeKeys: string[] | undefined;
+        queryLabels: string[];
+        funnelBindingKey: import('../types.js').FunnelBindingKey | null;
+        stepTimeToConvert: (string | null)[];
+    };
+    getChartConfig: () => {
+        chartType: ChartType;
+        chartConfig: ChartAxisConfig;
+        displayConfig: ChartDisplayConfig;
+    };
+    getAnalysisType: () => import('../types.js').AnalysisType;
+    actions: {
+        setActiveQueryIndex: (index: number) => void;
+        setMergeStrategy: (strategy: import('../types.js').QueryMergeStrategy) => void;
+        addQuery: () => void;
+        removeQuery: (index: number) => 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: import('../types.js').Filter[]) => void;
+        dropFieldToFilter: (field: string) => void;
+        setOrder: (fieldName: string, direction: "asc" | "desc" | null) => void;
+        setLimit: (limit: number | undefined) => void;
+        setFunnelBindingKey: (bindingKey: import('../types.js').FunnelBindingKey | null) => void;
+        setAnalysisType: (type: import('../types.js').AnalysisType) => void;
+        setFunnelCube: (cube: string | null) => void;
+        addFunnelStep: () => void;
+        removeFunnelStep: (index: number) => void;
+        updateFunnelStep: (index: number, updates: Partial<import('../types.js').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: import('../types.js').FunnelBindingKey | null) => void;
+        setFlowTimeDimension: (dim: string | null) => void;
+        setEventDimension: (dim: string | null) => void;
+        setStartingStepName: (name: string) => void;
+        setStartingStepFilters: (filters: import('../types.js').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.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;
+        setUserManuallySelectedChart: (value: boolean) => void;
+        setActiveTab: (tab: import('../components/AnalysisBuilder/types.js').QueryPanelTab) => void;
+        setActiveView: (view: "table" | "chart") => void;
+        setDisplayLimit: (limit: number) => void;
+        closeFieldModal: () => void;
+        setActiveTableIndex: import('react').Dispatch<import('react').SetStateAction<number>>;
+        clearQuery: () => void;
+        clearCurrentMode: () => void;
+        handleFieldSelected: (field: MetaField, fieldType: "measure" | "dimension" | "timeDimension", _cubeName: string, keepOpen?: boolean) => void;
+    };
+};
+export type UseAnalysisStateResult = ReturnType<typeof useAnalysisState>;

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;