drizzle-cube 0.5.7 → 0.6.0

package/dist/client/components/shared/utils.d.ts

@@ -1,5 +1,9 @@
 import { CubeQuery, Filter, SimpleFilter } from '../../types';
 import { MetaField, MetaResponse } from './types';
+export { getSortDirection, getSortTooltip, getNextSortDirection, } from './queryFieldUtils';
+export type { DatePreset } from './dateRangeUtils';
+export { DATE_PRESETS, XTD_OPTIONS, calculateDateRange, formatDateRangeDisplay, detectPresetFromDateRange, } from './dateRangeUtils';
+export { formatFilterValueDisplay } from './filterDisplayUtils';
 export { isSimpleFilter, isGroupFilter, isAndFilter, isOrFilter, flattenFilters, countFilters, createSimpleFilter, createAndFilter, createOrFilter, cleanupFilters, transformFiltersForServer, transformFiltersFromServer, hasQueryContent, cleanQuery, cleanQueryForServer, transformQueryForUI, getCubeNameFromField, getFieldType, getFieldTitle, getAvailableOperators, getAllFilterableFields, convertDateRangeTypeToValue, requiresNumberInput, formatDateForCube, } from '../../shared/utils';
 /**
  * Check if a field is selected in the current query
@@ -65,46 +69,3 @@ export declare function hasTimeDimensions(query: CubeQuery): boolean;
  * Clean up order object by removing fields that are no longer in the query
  */
 export declare function cleanupOrder(order: Record<string, 'asc' | 'desc'> | undefined, query: CubeQuery): Record<string, 'asc' | 'desc'> | undefined;
-/**
- * Get sort direction for a field from the order object
- */
-export declare function getSortDirection(fieldName: string, order: Record<string, 'asc' | 'desc'> | undefined): 'asc' | 'desc' | null;
-/**
- * Get tooltip text for sort button based on current direction
- */
-export declare function getSortTooltip(direction: 'asc' | 'desc' | null): string;
-/**
- * Get next sort direction in the cycle: null -> asc -> desc -> null
- */
-export declare function getNextSortDirection(current: 'asc' | 'desc' | null): 'asc' | 'desc' | null;
-/**
- * Date preset configuration for compact filter bar
- */
-export interface DatePreset {
-    id: string;
-    label: string;
-    value: string;
-}
-export declare const DATE_PRESETS: DatePreset[];
-export declare const XTD_OPTIONS: DatePreset[];
-/**
- * Calculate actual date range from a preset string
- * Returns start and end dates for display purposes
- */
-export declare function calculateDateRange(preset: string): {
-    start: Date;
-    end: Date;
-} | null;
-/**
- * Format a date range for display (e.g., "Jan 1, 2024 - Jan 31, 2024")
- */
-export declare function formatDateRangeDisplay(start: Date, end: Date): string;
-/**
- * Detect preset ID from a date range value
- * Returns the preset ID (e.g., '7d', 'mtd') or 'custom' if not a preset
- */
-export declare function detectPresetFromDateRange(dateRange: string | string[] | undefined): string | null;
-/**
- * Format filter value for display in a compact chip
- */
-export declare function formatFilterValueDisplay(values: any[], operator: string): string;

package/dist/client/components.js

@@ -1,3 +1,3 @@
-import { E as e, J as t, S as n, T as r, a as i, h as a, i as o, m as s, n as c, p as l, r as u, s as d, t as f } from "./chunks/DashboardEditModal-6KRE36mm.js";
-import { a as p, n as m, o as h, r as g, s as _, t as v } from "./chunks/utils-kqa-JIMg.js";
-export { d as AnalysisDisplayConfigPanel, u as AnalyticsDashboard, t as AnalyticsPortlet, f as DashboardEditModal, a as DashboardFilterBar, o as DashboardGrid, s as DashboardGridSurface, i as DashboardModals, r as DashboardProvider, n as DashboardToolbar, l as Modal, c as PortletContainer, v as createDashboardLayout, m as createSamplePortlet, g as findNextPosition, p as generatePortletId, h as generateResponsiveLayouts, e as useDashboardContext, _ as validateCubeQuery };
+import { C as e, D as t, E as n, Y as r, a as i, h as a, i as o, m as s, n as c, p as l, r as u, s as d, t as f } from "./chunks/DashboardEditModal-okVfH8ZK.js";
+import { a as p, n as m, o as h, r as g, s as _, t as v } from "./chunks/utils-3P6z1vz5.js";
+export { d as AnalysisDisplayConfigPanel, u as AnalyticsDashboard, r as AnalyticsPortlet, f as DashboardEditModal, a as DashboardFilterBar, o as DashboardGrid, s as DashboardGridSurface, i as DashboardModals, n as DashboardProvider, e as DashboardToolbar, l as Modal, c as PortletContainer, v as createDashboardLayout, m as createSamplePortlet, g as findNextPosition, p as generatePortletId, h as generateResponsiveLayouts, t as useDashboardContext, _ as validateCubeQuery };

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

@@ -0,0 +1,39 @@
+import { PortletBlock, MarkdownBlock } from '../stores/notebookStore';
+/** Clean up raw API errors into user-friendly messages */
+export declare function formatUserFacingError(message: string): string;
+export interface AgentSSEEvent {
+    type: 'text_delta' | 'tool_use_start' | 'tool_use_result' | 'add_portlet' | 'add_markdown' | 'dashboard_saved' | 'turn_complete' | 'done' | 'error';
+    data: any;
+}
+/** Subset of the hook options that handleAgentEvent dispatches to. */
+export interface AgentEventCallbacks {
+    onAddPortlet: (data: PortletBlock) => void;
+    onAddMarkdown: (data: MarkdownBlock) => void;
+    onDashboardSaved?: (data: {
+        title: string;
+        description?: string;
+        dashboardConfig: any;
+    }) => void;
+    onTextDelta: (text: string) => void;
+    onToolStart: (id: string, name: string, input?: unknown) => void;
+    onToolResult: (id: string, name: string, result?: unknown, isError?: boolean) => void;
+    onDone: (sessionId: string, traceId?: string) => void;
+    onTurnComplete?: () => void;
+    onError: (message: string) => void;
+}
+/** Dispatch a single decoded SSE event to the relevant callback. */
+export declare function handleAgentEvent(event: AgentSSEEvent, cb: AgentEventCallbacks): void;
+/**
+ * Parse one block of SSE text (possibly multi-line) and dispatch each
+ * `data: ` line. Malformed JSON lines are skipped silently.
+ */
+export declare function dispatchSSEBlock(block: string, dispatch: (event: AgentSSEEvent) => void): void;
+export interface AgentRequestHeaderOptions {
+    baseHeaders?: Record<string, string>;
+    agentApiKey?: string;
+    agentProvider?: string;
+    agentModel?: string;
+    agentProviderEndpoint?: string;
+}
+/** Build request headers matching CubeClient's auth pattern plus agent overrides. */
+export declare function buildAgentHeaders(opts: AgentRequestHeaderOptions): Record<string, string>;

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

@@ -0,0 +1,133 @@
+/**
+ * Pure mode-selection helpers for useAnalysisQueryExecution.
+ *
+ * The hook coordinates five execution modes (retention, flow, funnel, multi,
+ * single). Almost every derived value is "pick the field from whichever mode is
+ * active". These helpers collapse the repeated 5-way ternary chains into a
+ * single normalized per-mode descriptor plus a selector, without changing any
+ * behaviour: the selected values are byte-for-byte equivalent to the original
+ * nested ternaries.
+ */
+/** The active execution mode, in priority order (retention > flow > funnel > multi > single). */
+export type ActiveMode = 'retention' | 'flow' | 'funnel' | 'multi' | 'single';
+export interface ModeFlags {
+    isRetentionMode: boolean | undefined;
+    isFlowMode: boolean | undefined;
+    isFunnelMode: boolean | undefined;
+    isMultiMode: boolean | undefined;
+}
+/**
+ * Resolve the single active mode from the boolean flags, using the same
+ * precedence as the original nested ternaries (retention first, single last).
+ */
+export declare function resolveActiveMode(flags: ModeFlags): ActiveMode;
+/**
+ * A value resolved per-mode. Pass the value each mode contributes; `pickByMode`
+ * returns the one for the active mode. This mirrors the original
+ * `isRetentionMode ? a : isFlowMode ? b : ...` chains exactly. Each field may
+ * have its own type — the return type is the union across all modes.
+ */
+export type PerMode<R extends Record<ActiveMode, unknown>> = R;
+export declare function pickByMode<R extends Record<ActiveMode, unknown>>(mode: ActiveMode, values: R): R[ActiveMode];
+/**
+ * Inputs for deriving the per-mode "debug / server query / chart data" outputs.
+ * Each field is the raw value the corresponding mode hook exposes; the helper
+ * gates it on the matching mode flag (returning null otherwise), exactly as the
+ * original inline `isXMode ? value : null` expressions did.
+ */
+export interface ModeOutputsInput<FunnelExecuted, FunnelServer, FlowServer, FlowChart, RetentionServer, RetentionChart, Debug> {
+    isFunnelMode: boolean | undefined;
+    isFlowMode: boolean;
+    isRetentionMode: boolean;
+    funnelExecutedQueries: FunnelExecuted[] | undefined;
+    funnelServerQuery: FunnelServer;
+    funnelDebugData: Debug;
+    flowServerQuery: FlowServer;
+    flowData: FlowChart;
+    flowDebugData: Debug;
+    retentionServerQuery: RetentionServer;
+    retentionChartData: RetentionChart;
+    retentionDebugData: Debug;
+}
+export interface ModeOutputs<FunnelExecuted, FunnelServer, FlowServer, FlowChart, RetentionServer, RetentionChart, Debug> {
+    funnelExecutedQueries: FunnelExecuted[] | null;
+    funnelServerQuery: FunnelServer | null;
+    funnelDebugData: Debug | null;
+    flowServerQuery: FlowServer | null;
+    flowChartData: FlowChart | null;
+    flowDebugData: Debug | null;
+    retentionServerQuery: RetentionServer | null;
+    retentionChartData: RetentionChart | null;
+    retentionDebugData: Debug | null;
+}
+export declare function deriveModeOutputs<FunnelExecuted, FunnelServer, FlowServer, FlowChart, RetentionServer, RetentionChart, Debug>(input: ModeOutputsInput<FunnelExecuted, FunnelServer, FlowServer, FlowChart, RetentionServer, RetentionChart, Debug>): ModeOutputs<FunnelExecuted, FunnelServer, FlowServer, FlowChart, RetentionServer, RetentionChart, Debug>;
+/** Inputs for computing the per-query-hook `skip` flags. */
+export interface SkipFlagsInput {
+    isValidQuery: boolean;
+    isSingleMode: boolean;
+    isMultiMode: boolean;
+    isFunnelMode: boolean | undefined;
+    isFlowMode: boolean;
+    isRetentionMode: boolean;
+    hasMultiQueryConfig: boolean;
+    hasFunnelConfig: boolean;
+    hasServerFunnelQuery: boolean;
+    hasServerFlowQuery: boolean;
+    hasServerRetentionQuery: boolean;
+}
+export interface SkipFlags {
+    single: boolean;
+    multi: boolean;
+    funnel: boolean;
+    flow: boolean;
+    retention: boolean;
+    dryRun: boolean;
+}
+/**
+ * Compute the `skip` flag for each query hook. Extracted from the inline
+ * boolean expressions so the hook body stays flat. Logic is unchanged.
+ */
+export declare function computeSkipFlags(input: SkipFlagsInput): SkipFlags;
+/** Inputs for the unified execution-status computation. */
+export interface ExecutionStatusInput {
+    hasResults: unknown;
+    initialData: unknown[] | undefined;
+    isValidQuery: boolean;
+    isLoading: boolean;
+    isFetching: boolean;
+    error: unknown;
+}
+/**
+ * Compute the unified execution status. Extracted verbatim from the original
+ * useMemo body to keep the hook flat; the `hasResults` per-mode pick is done by
+ * the caller and passed in.
+ */
+export declare function computeExecutionStatus(input: ExecutionStatusInput): 'idle' | 'loading' | 'refreshing' | 'error' | 'success';
+/** Inputs for computing the unified execution results array. */
+export interface ExecutionResultsInput {
+    isRetentionMode: boolean;
+    isFlowMode: boolean;
+    isFunnelMode: boolean | undefined;
+    isMultiMode: boolean;
+    retentionChartData: {
+        rows: Array<{
+            period: number;
+            retentionRate: number;
+            retainedUsers: number;
+            cohortSize: number;
+            breakdownValue?: string | null;
+        }>;
+    } | null | undefined;
+    flowData: unknown;
+    funnelChartData: unknown[] | null | undefined;
+    multiData: unknown[] | null | undefined;
+    singleRawData: unknown[] | null | undefined;
+    initialData: unknown[] | undefined;
+}
+/**
+ * Compute the unified execution results array. This is a priority cascade
+ * (not a strict per-mode pick): when the active mode has no data yet, it falls
+ * through to lower-priority sources, ending at initialData. Extracted verbatim
+ * from the original useMemo body to preserve behaviour.
+ */
+export declare function computeExecutionResults(input: ExecutionResultsInput): unknown[] | null;

package/dist/client/hooks/dashboard/useDashboardController.d.ts

@@ -1,6 +1,6 @@
 import { MutableRefObject, RefObject } from 'react';
 import { StoreApi } from 'zustand';
-import { DashboardConfig, DashboardGridSettings, DashboardLayoutMode, PortletConfig, RowLayout, ThumbnailFeatureConfig } from '../../types';
+import { DashboardConfig, DashboardFilterMapping, DashboardGridSettings, DashboardLayoutMode, PortletConfig, RowLayout, ThumbnailFeatureConfig } from '../../types';
 import { DashboardStore, DashboardStoreActions } from '../../stores/dashboardStore';
 interface UseDashboardControllerOptions {
     allowedModes: DashboardLayoutMode[];
@@ -47,7 +47,7 @@ export declare function useDashboardController({ allowedModes, canChangeLayoutMo
     }) => void;
     toggleFilterForPortlet: (portletId: string, filterId: string) => Promise<void>;
     selectAllForFilter: (filterId: string) => Promise<void>;
-    saveFilterConfig: (mapping: string[]) => Promise<void>;
+    saveFilterConfig: (mapping: DashboardFilterMapping) => Promise<void>;
     handlePaletteChange: (paletteName: string) => Promise<void>;
 };
 export {};

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

@@ -0,0 +1,25 @@
+import { DrillOption, DrillPathEntry } from '../types/drill';
+import { ChartAxisConfig, CubeQuery } from '../types';
+/**
+ * Find an existing drill-path level for the given option and compute the
+ * "navigate back" descriptor (the truncated path + the query/chartConfig to
+ * restore). Returns null when there is no matching existing level.
+ *
+ * Used for both time-granularity drilling (matched by `granularity`) and
+ * hierarchy-dimension drilling (matched by `dimension`).
+ */
+export declare function findNavigateBackToExistingLevel(drillPath: DrillPathEntry[], matches: (entry: DrillPathEntry) => boolean): {
+    newPath: DrillPathEntry[];
+    query: CubeQuery;
+    chartConfig: ChartAxisConfig | null;
+} | null;
+/**
+ * Whether selecting this option means returning all the way to the root via the
+ * original time granularity.
+ */
+export declare function isDrillBackToRootGranularity(option: DrillOption, originalGranularity: string | null): boolean;
+/**
+ * Compute the granularity to remember as the "original" when first drilling via
+ * a time-granularity option. Returns null when nothing should be stored.
+ */
+export declare function computeOriginalGranularity(option: DrillOption, query: CubeQuery): string | null;

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

@@ -1,7 +1,7 @@
 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';
+import { DashboardConfig, PortletConfig, RowLayout, DashboardFilter, DashboardFilterMapping, DashboardGridSettings, DashboardLayoutMode } from '../types';
 export interface UseDashboardOptions {
     /** Dashboard configuration */
     config: DashboardConfig;
@@ -112,7 +112,7 @@ export interface UseDashboardActions {
     }) => void;
     toggleFilterForPortlet: (portletId: string, filterId: string) => Promise<void>;
     selectAllForFilter: (filterId: string) => Promise<void>;
-    saveFilterConfig: (mapping: string[]) => Promise<void>;
+    saveFilterConfig: (mapping: DashboardFilterMapping) => Promise<void>;
     handlePaletteChange: (paletteName: string) => Promise<void>;
     openDeleteConfirm: (portletId: string) => void;
     closeDeleteConfirm: () => void;

package/dist/client/hooks.js

@@ -1,5 +1,5 @@
-import { q as e } from "./chunks/chart-data-table-Cm5jrpaw.js";
-import { S as t, a as n, c as r, d as i, i as a, l as o, n as s, o as c, r as l, s as u, t as d } from "./chunks/useDirtyStateTracking-B5wCDJSj.js";
-import { a as f, i as p, n as m, o as h, r as g, t as _ } from "./chunks/useExplainAI-CCeCYzDm.js";
+import { R as e } from "./chunks/chart-data-table-CKauQXme.js";
+import { S as t, a as n, c as r, d as i, i as a, l as o, n as s, o as c, r as l, s as u, t as d } from "./chunks/useDirtyStateTracking-MbpxH_v6.js";
+import { a as f, i as p, n as m, o as h, r as g, t as _ } from "./chunks/useExplainAI-evnZkjCY.js";
 import { t as v } from "./chunks/useNotebookLayout-Ck3Z3uzg.js";
 export { m as createExplainQueryKey, c as createFlowQueryKey, r as createFunnelQueryKey, t as useCubeLoadQuery, t as useCubeQuery, e as useCubeMetaQuery, s as useDebounce, d as useDirtyStateTracking, p as useDryRunQueries, f as useDryRunQuery, _ as useExplainAI, g as useExplainQuery, l as useFilterValues, u as useFlowQuery, o as useFunnelQuery, i as useMultiCubeLoadQuery, h as useMultiDryRunQueries, v as useNotebookLayout, a as useResponsiveDashboard, n as useRetentionQuery };

package/dist/client/icons.d.ts

@@ -1,2 +1,2 @@
-export * from './icons/index'
+export * from './icons/index.js'
 export {}

package/dist/client/icons.js

@@ -1,2 +1,2 @@
-import { A as e, D as t, E as n, F as r, M as i, N as a, O as o, P as s, T as c, j as l, k as u } from "./chunks/chart-data-table-Cm5jrpaw.js";
-export { r as DEFAULT_ICONS, c as getChartTypeIcon, n as getFieldTypeIcon, t as getIcon, o as getIconData, u as getIconRegistry, e as getIconsByCategory, l as getMeasureTypeIcon, i as registerIcons, a as resetIcons, s as setIcon };
+import { C as e, E as t, S as n, T as r, _ as i, b as a, g as o, v as s, w as c, x as l, y as u } from "./chunks/chart-data-table-CKauQXme.js";
+export { t as DEFAULT_ICONS, o as getChartTypeIcon, i as getFieldTypeIcon, s as getIcon, u as getIconData, a as getIconRegistry, l as getIconsByCategory, n as getMeasureTypeIcon, e as registerIcons, c as resetIcons, r as setIcon };