react-semaphor 0.1.503 → 0.1.505

package/dist/types/lib/stores/drill-actions.d.ts

@@ -0,0 +1,139 @@
+import { DrillHierarchy, CardInteractionConfig } from '../types/interaction-types.js';
+import { Field, CardConfig } from '../types/explorer-types.js';
+import { TCard } from '../types/index.js';
+import { EditorStore } from './editor-store.js';
+export declare const EMPTY_DRILL_HIERARCHIES: DrillHierarchy[];
+export declare const EMPTY_DRILL_TARGETS: Field[];
+export interface DrillActions {
+    updateDrillHierarchies: (h: DrillHierarchy[]) => void;
+    addDrillHierarchy: (h: DrillHierarchy) => void;
+    removeDrillHierarchy: (hierarchyId: string) => void;
+    updateDrillHierarchy: (hierarchyId: string, updates: Partial<DrillHierarchy>) => void;
+    setDefaultHierarchy: (hierarchyId: string) => void;
+    updateAllowedDrillTargets: (t: Field[]) => void;
+    addDrillTarget: (t: Field) => void;
+    removeDrillTarget: (targetId: string) => void;
+    updateInlineDrillPreview: (s: {
+        enabled: boolean;
+        limit: number;
+        mode: 'lazy' | 'preloaded';
+    }) => void;
+    toggleInlineDrillPreview: (enabled: boolean) => void;
+    updateInteractionConfig: (c: Partial<CardInteractionConfig>) => void;
+    resetDrillConfiguration: () => void;
+}
+export declare const createDrillActions: (set: (fn: (s: EditorStore) => Partial<EditorStore>) => void) => DrillActions;
+export declare const useCard: () => TCard;
+export declare const useDrillActions: () => import('./table-actions.js').TableActions & import('./explorer-actions.js').ExplorerActions & DrillActions & {
+    resetEditorStore: () => void;
+    setEditorFilterMode: (filterColumnName: string, filterMode: "include" | "exclude") => void;
+    setValueAlignment: (valueAlignment: "left" | "center") => void;
+    clearEditorFilter: (filterColumn: import('../types/query-types.js').FilterByColumn) => void;
+    removeEditorFilter: (filterColumn: import('../types/query-types.js').FilterByColumn) => void;
+    updateEditorFilterValue: (filterColumnName: string, filterValue: import('../types/query-types.js').OldFilterValue, clearFilter?: boolean) => void;
+    setTempQueryData: (tempQueryData: {
+        queryKey: string[];
+        queryData: any;
+    }) => void;
+    clearQueryConfig: () => void;
+    setQueryConfig: (queryConfig: import('../types/query-types.js').QueryConfig | undefined) => void;
+    setCardTitle: (title: string) => void;
+    setCardDescription: (description: string) => void;
+    setCardInfo: (info: string) => void;
+    setCardId: (cardId: string) => void;
+    setCountryLogo: (countryLogoId: string | null) => void;
+    setIsDevMode: (isDevMode: boolean) => void;
+    switchEditorMode: (targetMode: "dev" | "standard", options?: {
+        sqlToLoad?: string;
+        skipDraftSave?: boolean;
+    }) => void;
+    initializeModeDrafts: (card: TCard) => void;
+    mergeDraftsIntoCard: () => void;
+    clearModeDrafts: () => void;
+    setOrderByColumns: (orderByColumns: import('../types/query-types.js').OrderBy[]) => void;
+    addOrderByColumn: (orderByColumn: import('../types/query-types.js').OrderBy) => void;
+    removeOrderByColumn: (orderByColumn: import('../types/query-types.js').OrderBy) => void;
+    updateOrderByColumn: (orderByColumn: import('../types/query-types.js').OrderBy) => void;
+    setGroupByColumns: (groupByColumns: import('../types/query-types.js').GroupByColumn[]) => void;
+    setMetricColumns: (metricColumns: import('../types/query-types.js').MetricColumn[]) => void;
+    setPivotByColumns: (pivotColumns: import('../types/query-types.js').GroupByColumn[]) => void;
+    removeColumnFromGroupBy: (columnId: string) => void;
+    removeColumnFromMetricColumns: (columnId: string) => void;
+    removeColumnFromPivotBy: (columnId: string) => void;
+    addColumnToGroupBy: (column: import('../types/query-types.js').GroupByColumn) => void;
+    addColumnToMetricColumns: (column: import('../types/query-types.js').MetricColumn) => void;
+    setFilterColumns: (filterColumns: import('../types/query-types.js').FilterByColumn[]) => void;
+    addColumnToFilterColumns: (column: import('../types/query-types.js').FilterByColumn) => void;
+    removeColumnFromFilterColumns: (columnId: string) => void;
+    updateMetricColumnOld: (columnId: string, column: import('../types/query-types.js').MetricColumn) => void;
+    updateGroupByColumnOld: (columnId: string, column: import('../types/query-types.js').GroupByColumn) => void;
+    updatePivotByColumnOld: (columnId: string, column: import('../types/query-types.js').GroupByColumn) => void;
+    updateFilterColumn: (columnId: string, column: import('../types/query-types.js').FilterByColumn) => void;
+    setCurrentAssitantScope: (currentAssitantScope: import('../types/index.js').AIScopeTable[]) => void;
+    setChartGrid: (chartGrid: "xy" | "x" | "y" | "none") => void;
+    setLegendOptions: (legendOptions: import('../types/index.js').TLegendOptions) => void;
+    runAssistant: (message: string) => void;
+    setShowAIDialog: (showAIDialog: boolean) => void;
+    setUserInputForAI: (userInputForAI: string) => void;
+    setTriggerAIRun: (triggerAIRun: boolean) => void;
+    setActiveTabCardId: (activeTabCardId: string) => void;
+    updateCardTab: (activeTabCardId: string, currentCard: TCard) => void;
+    setSortChart: (sortChart: "asc" | "desc" | "none") => void;
+    setChartOrientation: (indexAxis: "x" | "y") => void;
+    setCustomVisualCode: (code: string) => void;
+    setCardRefreshInterval: (refreshInterval: string) => void;
+    setNumberFormat: (decimalPlaces: number, currency: string, locale: string, suffix: string) => void;
+    setColorRanges: (colorRanges: import('../types/index.js').ColorRange[]) => void;
+    setIsShowingVisual: (isShowingVisual: boolean) => void;
+    setQueryResultColumns: (columns: string[], columnKeyMap?: import('../types/explorer-types.js').QueryColumnKeyMap) => void;
+    setRunSql: (runSql: boolean) => void;
+    setCardPreferences: (preferences: import('../types/index.js').TCardPreferences) => void;
+    setCustomCardPreferences: (customPreferences: import('../types/index.js').TCustomCardPreferences) => void;
+    setVisualizationMode: (mode: import('../types/index.js').TVisualizationMode) => void;
+    setDynamicCardPreferences: (dynamicPreferences: import('../types/index.js').TDynamicCardPreferences | undefined) => void;
+    setFilterOnClickField: (field: string) => void;
+    setFilterOnClickColumnIndex: (index: number) => void;
+    setIsSqlRunning: (isSqlRunning: boolean) => void;
+    setCard: (card: TCard) => void;
+    setFrame: (frame: import('../types/index.js').TFrame) => void;
+    replaceFrameCards: (cards: TCard[]) => void;
+    updateCardInFrame: (card: TCard) => void;
+    setSqlGen: (sqlGen: import('../types/index.js').SqlGen) => void;
+    setSqlGenMeasure: (name: string, calc: import('../types/index.js').AggregateCalc) => void;
+    setSqlGenDimension: (dimension: string) => void;
+    switchCardType: (type: import('../types/index.js').TChartType) => void;
+    setCardType: (type: import('../types/index.js').TChartType) => void;
+    setCardSql: (sql: string | undefined) => void;
+    setCardPython: (python: string | undefined) => void;
+    setPythonStdOut: (pythonStdOut: string) => void;
+    setCardCustomCfg: (cfg: any) => void;
+    setCardConfig: (config: CardConfig | undefined) => void;
+    setShowFilters: (showFilters: boolean) => void;
+    setApplyFilters: (applyFilters: boolean) => void;
+    setFilterValues: (filterValues: import('../types/index.js').TFilterValue[]) => void;
+    setInlineFilterValuesMap: (map: Record<string, import('../types/index.js').TFilterValue[]>) => void;
+    setCardInlineFilterValue: (cardId: string, filterValue: import('../types/index.js').TFilterValue) => void;
+    removeCardInlineFilterValue: (cardId: string, filterId: string) => void;
+    setSelectedConnectionId: (connectionId: string) => void;
+    setSelectedDatamodelId: (datamodelId: string) => void;
+    setSelectedDatabaseName: (databaseName: string) => void;
+    setSelectedSchemaName: (schemaName: string) => void;
+    setSelectedTableName: (tableName: string) => void;
+    setOnConnectionChange: (onConnectionChange: (connectionId: string) => void) => void;
+    setOnDatabaseChange: (onDatabaseChange: (databaseName: string) => void) => void;
+    setOnSchemaChange: (onSchemaChange: (schemaName: string) => void) => void;
+    setOnTableChange: (onTableChange: (tableNmae: string) => void) => void;
+    setOnSave: (onSave: (card: import('../types/index.js').TFrame) => void) => void;
+    setOnClose: (onClose: () => void) => void;
+    setEditorContext: (context: import('./editor-store.js').EditorContext) => void;
+    clearEditorContext: () => void;
+};
+export declare const selectDrillHierarchies: (s: EditorStore) => DrillHierarchy[];
+export declare const selectAllowedDrillTargets: (s: EditorStore) => Field[];
+export declare const selectInlineDrillPreview: (s: EditorStore) => {
+    enabled: boolean;
+    limit: number;
+    mode: "lazy" | "preloaded";
+};
+export declare const selectDefaultHierarchy: (s: EditorStore) => DrillHierarchy | undefined;
+export declare const selectHierarchyById: (hierarchyId: string) => (s: EditorStore) => DrillHierarchy | undefined;

package/dist/types/lib/stores/editor-store.d.ts

@@ -0,0 +1,222 @@
+import { ColorRange, TCard, TDynamicCardPreferences, TCardPreferences, TCustomCardPreferences, TFrame, TLegendOptions, TVisualizationMode, AggregateCalc, SqlGen, ControlDefinition } from '../types/common-types.js';
+import { TFilterValue } from '../../components/surfboard/filter/types.js';
+import { TChartType } from '../charts/types.js';
+import { AIScopeTable } from '../../components/index.js';
+import { FilterByColumn, OldFilterValue, GroupByColumn, MetricColumn, OrderBy, QueryConfig } from '../types/query-types.js';
+import { TableActions } from './table-actions.js';
+import { CardConfig, QueryColumnKeyMap } from '../types/explorer-types.js';
+import { ExplorerActions } from './explorer-actions.js';
+import { DrillActions } from './drill-actions.js';
+/**
+ * Draft slots for preserving work when switching between dev and standard modes.
+ * When user switches FROM a mode, the current work is saved to that mode's draft slot.
+ * When user switches TO a mode, the draft slot is restored (if available).
+ */
+export type ModeDrafts = {
+    /** SQL draft - preserved when switching from dev mode to standard mode */
+    sqlDraft: string | null;
+    /** Python draft - preserved when switching from dev mode to standard mode (Python is tied to dev mode) */
+    pythonDraft: string | null;
+    /** Config draft - preserved when switching from standard mode to dev mode */
+    configDraft: CardConfig | null;
+    /** Tracks which mode the card was originally in when editor opened */
+    originalMode: 'dev' | 'standard' | 'both' | 'none';
+};
+export type EditorContext = {
+    type: 'dashboard';
+} | {
+    type: 'documentSection';
+    sheetId: string;
+    sectionId: string;
+    cardId: string;
+    documentFilterValues?: TFilterValue[];
+    documentControlDefinitions?: ControlDefinition[];
+    documentControlValues?: Record<string, unknown>;
+    missingRequiredInputLabels?: string[];
+};
+/**
+ * Factory function to create empty KPI card configuration
+ * Returns a fresh config with new array instances to prevent shared references
+ * Used when switching to KPI chart type
+ */
+export declare const createEmptyKpiConfig: () => CardConfig;
+export type EditorStore = {
+    /** Ephemeral preview selection for Matrix field/ranking settings; never persisted. */
+    matrixSelection?: {
+        cardId: string;
+        coordinate: import('../../shared/analytics-protocol/index.js').MatrixCoordinate;
+    };
+    /** Live preview command port only; never persisted or copied into card config. */
+    matrixPreview?: {
+        cardId: string;
+        runtime: import('../matrix-table/use-matrix-editor-refresh.js').MatrixEditorRuntime;
+    };
+    /** Live delivery capture of the editor preview for Export; never persisted. */
+    matrixEditorDelivery?: {
+        cardId: string;
+        delivery: import('../matrix-table/matrix-delivery.js').MatrixDeliveryContext;
+    };
+    tempQueryData?: {
+        queryKey: string[];
+        queryData: any;
+    };
+    isDevMode: boolean;
+    isShowingVisual: boolean;
+    showAIDialog: boolean;
+    userInputForAI: string;
+    triggerAIRun: boolean;
+    runSql: boolean;
+    isSqlRunning: boolean;
+    actions: Actions;
+    sqlGen: SqlGen;
+    frame: TFrame;
+    card: TCard;
+    activeTabCardId?: string | null;
+    showFilters: boolean;
+    applyFilters: boolean;
+    filterValues?: TFilterValue[];
+    inlineFilterValuesMap: Record<string, TFilterValue[]>;
+    queryResultColumns: string[];
+    queryResultColumnKeyMap?: QueryColumnKeyMap;
+    queryError?: string;
+    pythonStdOut?: string;
+    selectedConnectionId?: string;
+    selectedDatamodelId?: string;
+    selectedDatabaseName?: string;
+    selectedSchemaName?: string;
+    selectedTableName?: string;
+    currentAssitantScope?: AIScopeTable[];
+    onConnectionChange?: (connectionId: string) => void;
+    onDatamodelChange?: (datamodelId: string) => void;
+    onDatabaseChange?: (databaseName: string) => void;
+    onTableChange?: (tableName: string) => void;
+    onSchemaChange?: (schemaName: string) => void;
+    onSave?: (card: TFrame) => void | Promise<void>;
+    onClose?: () => void;
+    editorContext?: EditorContext;
+    /** Draft slots for mode switching - preserves work when toggling between dev/standard */
+    modeDrafts: ModeDrafts;
+};
+type Actions = TableActions & ExplorerActions & DrillActions & {
+    /** Resets the editor store to its initial state. Called when loading a new dashboard. */
+    resetEditorStore: () => void;
+    setEditorFilterMode: (filterColumnName: string, filterMode: 'include' | 'exclude') => void;
+    setValueAlignment: (valueAlignment: 'left' | 'center') => void;
+    clearEditorFilter: (filterColumn: FilterByColumn) => void;
+    removeEditorFilter: (filterColumn: FilterByColumn) => void;
+    updateEditorFilterValue: (filterColumnName: string, filterValue: OldFilterValue, clearFilter?: boolean) => void;
+    setTempQueryData: (tempQueryData: {
+        queryKey: string[];
+        queryData: any;
+    }) => void;
+    clearQueryConfig: () => void;
+    setQueryConfig: (queryConfig: QueryConfig | undefined) => void;
+    setCardTitle: (title: string) => void;
+    setCardDescription: (description: string) => void;
+    setCardInfo: (info: string) => void;
+    setCardId: (cardId: string) => void;
+    setCountryLogo: (countryLogoId: string | null) => void;
+    setIsDevMode: (isDevMode: boolean) => void;
+    /**
+     * Switches between dev mode and standard mode with draft preservation.
+     * This is the unified mode switching action - all entry points should use this.
+     * @param targetMode - The mode to switch to
+     * @param options - Optional parameters for the switch
+     */
+    switchEditorMode: (targetMode: 'dev' | 'standard', options?: {
+        /** SQL to set when switching to dev mode (e.g., from "View in SQL Editor") */
+        sqlToLoad?: string;
+        /** Whether to skip saving draft (for initial setup) */
+        skipDraftSave?: boolean;
+    }) => void;
+    /** Initialize mode drafts when opening editor (call from use-editor-setup) */
+    initializeModeDrafts: (card: TCard) => void;
+    /** Merge drafts back into card (call before switching cards to preserve inactive mode's data) */
+    mergeDraftsIntoCard: () => void;
+    /** Clear mode drafts (call when switching cards or closing editor) */
+    clearModeDrafts: () => void;
+    setOrderByColumns: (orderByColumns: OrderBy[]) => void;
+    addOrderByColumn: (orderByColumn: OrderBy) => void;
+    removeOrderByColumn: (orderByColumn: OrderBy) => void;
+    updateOrderByColumn: (orderByColumn: OrderBy) => void;
+    setGroupByColumns: (groupByColumns: GroupByColumn[]) => void;
+    setMetricColumns: (metricColumns: MetricColumn[]) => void;
+    setPivotByColumns: (pivotColumns: GroupByColumn[]) => void;
+    removeColumnFromGroupBy: (columnId: string) => void;
+    removeColumnFromMetricColumns: (columnId: string) => void;
+    removeColumnFromPivotBy: (columnId: string) => void;
+    addColumnToGroupBy: (column: GroupByColumn) => void;
+    addColumnToMetricColumns: (column: MetricColumn) => void;
+    setFilterColumns: (filterColumns: FilterByColumn[]) => void;
+    addColumnToFilterColumns: (column: FilterByColumn) => void;
+    removeColumnFromFilterColumns: (columnId: string) => void;
+    updateMetricColumnOld: (columnId: string, column: MetricColumn) => void;
+    updateGroupByColumnOld: (columnId: string, column: GroupByColumn) => void;
+    updatePivotByColumnOld: (columnId: string, column: GroupByColumn) => void;
+    updateFilterColumn: (columnId: string, column: FilterByColumn) => void;
+    setCurrentAssitantScope: (currentAssitantScope: AIScopeTable[]) => void;
+    setChartGrid: (chartGrid: 'xy' | 'x' | 'y' | 'none') => void;
+    setLegendOptions: (legendOptions: TLegendOptions) => void;
+    runAssistant: (message: string) => void;
+    setShowAIDialog: (showAIDialog: boolean) => void;
+    setUserInputForAI: (userInputForAI: string) => void;
+    setTriggerAIRun: (triggerAIRun: boolean) => void;
+    setActiveTabCardId: (activeTabCardId: string) => void;
+    updateCardTab: (activeTabCardId: string, currentCard: TCard) => void;
+    setSortChart: (sortChart: 'asc' | 'desc' | 'none') => void;
+    setChartOrientation: (indexAxis: 'x' | 'y') => void;
+    setCustomVisualCode: (code: string) => void;
+    setCardRefreshInterval: (refreshInterval: string) => void;
+    setNumberFormat: (decimalPlaces: number, currency: string, locale: string, suffix: string) => void;
+    setColorRanges: (colorRanges: ColorRange[]) => void;
+    setIsShowingVisual: (isShowingVisual: boolean) => void;
+    setQueryResultColumns: (columns: string[], columnKeyMap?: QueryColumnKeyMap) => void;
+    setRunSql: (runSql: boolean) => void;
+    setCardPreferences: (preferences: TCardPreferences) => void;
+    setCustomCardPreferences: (customPreferences: TCustomCardPreferences) => void;
+    setVisualizationMode: (mode: TVisualizationMode) => void;
+    setDynamicCardPreferences: (dynamicPreferences: TDynamicCardPreferences | undefined) => void;
+    setFilterOnClickField: (field: string) => void;
+    setFilterOnClickColumnIndex: (index: number) => void;
+    setIsSqlRunning: (isSqlRunning: boolean) => void;
+    setCard: (card: TCard) => void;
+    setFrame: (frame: TFrame) => void;
+    /** Replaces all cards in the frame with new cards. Sets first card as active. */
+    replaceFrameCards: (cards: TCard[]) => void;
+    updateCardInFrame: (card: TCard) => void;
+    setSqlGen: (sqlGen: SqlGen) => void;
+    setSqlGenMeasure: (name: string, calc: AggregateCalc) => void;
+    setSqlGenDimension: (dimension: string) => void;
+    switchCardType: (type: TChartType) => void;
+    setCardType: (type: TChartType) => void;
+    setCardSql: (sql: string | undefined) => void;
+    setCardPython: (python: string | undefined) => void;
+    setPythonStdOut: (pythonStdOut: string) => void;
+    setCardCustomCfg: (cfg: any) => void;
+    setCardConfig: (config: CardConfig | undefined) => void;
+    setShowFilters: (showFilters: boolean) => void;
+    setApplyFilters: (applyFilters: boolean) => void;
+    setFilterValues: (filterValues: TFilterValue[]) => void;
+    setInlineFilterValuesMap: (map: Record<string, TFilterValue[]>) => void;
+    setCardInlineFilterValue: (cardId: string, filterValue: TFilterValue) => void;
+    removeCardInlineFilterValue: (cardId: string, filterId: string) => void;
+    setSelectedConnectionId: (connectionId: string) => void;
+    setSelectedDatamodelId: (datamodelId: string) => void;
+    setSelectedDatabaseName: (databaseName: string) => void;
+    setSelectedSchemaName: (schemaName: string) => void;
+    setSelectedTableName: (tableName: string) => void;
+    setOnConnectionChange: (onConnectionChange: (connectionId: string) => void) => void;
+    setOnDatabaseChange: (onDatabaseChange: (databaseName: string) => void) => void;
+    setOnSchemaChange: (onSchemaChange: (schemaName: string) => void) => void;
+    setOnTableChange: (onTableChange: (tableNmae: string) => void) => void;
+    setOnSave: (onSave: (card: TFrame) => void) => void;
+    setOnClose: (onClose: () => void) => void;
+    setEditorContext: (context: EditorContext) => void;
+    clearEditorContext: () => void;
+};
+export declare const useEditorStore: import('zustand').UseBoundStore<Omit<import('zustand').StoreApi<EditorStore>, "setState"> & {
+    setState(nextStateOrUpdater: EditorStore | Partial<EditorStore> | ((state: import('immer').WritableDraft<EditorStore>) => void), shouldReplace?: false): void;
+    setState(nextStateOrUpdater: EditorStore | ((state: import('immer').WritableDraft<EditorStore>) => void), shouldReplace: true): void;
+}>;
+export declare const useEditorActions: () => Actions;
+export {};

package/dist/types/lib/stores/explorer-actions.d.ts

@@ -0,0 +1,45 @@
+import { CardConfig, DataSource, GroupByField, MetricField, FilterGroup, Join, PivotByField, SortByField } from '../types/explorer-types.js';
+import { TCard, TFrame } from '../types/common-types.js';
+import { EditorStore } from './editor-store.js';
+export interface ExplorerActions {
+    updateFrame: (updates: Partial<TFrame>) => void;
+    setActiveCardInFrame: (cardId: string) => void;
+    addCard: () => void;
+    removeCard: (cardId: string) => void;
+    updateCard: (cardId: string, updates: Partial<TCard>) => void;
+    setActiveCard: (cardId: string) => void;
+    setActiveTabCard: (cardId: string | null) => void;
+    updateDataSource: (dataSource: DataSource) => void;
+    setDataSource: (dataSource: DataSource) => void;
+    updateSemanticDomain: (semanticDomainId: string) => void;
+    updateDirectSource: (updates: Partial<DataSource>) => void;
+    getAvailableFields: () => Array<{
+        id: string;
+        name: string;
+        label: string;
+        dataType: string;
+        icon: any;
+        qualifiedEntityName?: string;
+    }>;
+    updateCardConfig: (cardId: string, config: Partial<CardConfig>) => void;
+    updateRowLimit: (cardId: string, rowLimit: number) => void;
+    addGroupByColumn: (cardId: string, column: GroupByField) => void;
+    removeGroupByColumn: (cardId: string, columnId: string) => void;
+    updateGroupByColumn: (cardId: string, columnId: string, updates: Partial<GroupByField>) => void;
+    addMetricColumn: (cardId: string, column: MetricField) => void;
+    removeMetricColumn: (cardId: string, columnId: string) => void;
+    updateMetricColumn: (cardId: string, columnId: string, updates: Partial<MetricField>) => void;
+    addPivotByColumn: (cardId: string, column: PivotByField) => void;
+    removePivotByColumn: (cardId: string, columnId: string) => void;
+    updatePivotByColumn: (cardId: string, columnId: string, updates: Partial<PivotByField>) => void;
+    addSortByColumn: (cardId: string, column: SortByField) => void;
+    removeSortByColumn: (cardId: string, columnId: string) => void;
+    updateSortByColumn: (cardId: string, columnId: string, updates: Partial<SortByField>) => void;
+    updateFilters: (cardId: string, filters: FilterGroup) => void;
+    clearFilters: (cardId: string) => void;
+    addJoin: (cardId: string, join: Join) => void;
+    removeJoin: (cardId: string, joinId: string) => void;
+    updateJoin: (cardId: string, joinId: string, updates: Partial<Join>) => void;
+    reorderJoins: (cardId: string, joinIds: string[]) => void;
+}
+export declare const createExplorerActions: (set: (fn: (draft: EditorStore) => void) => void, get: () => EditorStore) => ExplorerActions;

package/dist/types/lib/stores/explorer-empty-states.d.ts

@@ -0,0 +1,8 @@
+import { DatabaseEntityType, DataSource, JoinPlan } from '../types/explorer-types.js';
+export declare const EMPTY_DATA_SOURCE: DataSource;
+export declare const EMPTY_DB_SELECTION: {
+    database: string;
+    schema: string;
+    entityType: DatabaseEntityType;
+};
+export declare const EMPTY_JOIN_PLAN: JoinPlan;

package/dist/types/lib/stores/export-store.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Represents an active or recently completed export job.
+ */
+export interface ActiveExport {
+    id: string;
+    status: 'pending' | 'processing' | 'chunking' | 'compacting' | 'completed' | 'failed' | 'cancelled';
+    progress: number | null;
+    title: string;
+    totalRows: number | null;
+    totalChunks: number | null;
+    rowsProcessed?: number;
+    completedChunks: number;
+    startedAt: Date;
+    lastUpdatedAt: Date;
+    completedAt?: Date;
+    downloadUrl?: string;
+    fileSize?: number;
+    error?: string;
+    expiresAt: Date;
+}
+type ExportStoreState = {
+    /** Map of export ID to export data */
+    activeExports: Map<string, ActiveExport>;
+};
+type ExportStoreActions = {
+    /** Add a new export to the store */
+    addExport: (exportData: ActiveExport) => void;
+    /** Update an existing export */
+    updateExport: (id: string, updates: Partial<ActiveExport>) => void;
+    /** Remove an export from the store */
+    removeExport: (id: string) => void;
+    /** Get all in-progress exports */
+    getInProgressExports: () => ActiveExport[];
+    /** Get all exports as an array */
+    getAllExports: () => ActiveExport[];
+    /** Clear all completed/failed exports */
+    clearCompleted: () => void;
+    /** Check if there are any in-progress exports */
+    hasInProgressExports: () => boolean;
+};
+export type ExportStore = ExportStoreState & {
+    actions: ExportStoreActions;
+};
+export declare const useExportStore: import('zustand').UseBoundStore<Omit<import('zustand').StoreApi<ExportStore>, "setState"> & {
+    setState(nextStateOrUpdater: ExportStore | Partial<ExportStore> | ((state: import('immer').WritableDraft<ExportStore>) => void), shouldReplace?: false): void;
+    setState(nextStateOrUpdater: ExportStore | ((state: import('immer').WritableDraft<ExportStore>) => void), shouldReplace: true): void;
+}>;
+export declare const useExportActions: () => ExportStoreActions;
+export declare const useActiveExports: () => Map<string, ActiveExport>;
+export declare const useInProgressExportsCount: () => number;
+export {};

package/dist/types/lib/stores/index.d.ts

@@ -0,0 +1,10 @@
+export { useInteractionStore, useResolvedCardConfig, useClickFiltersForCard, createInitialInteractionState, } from './interaction-store.js';
+export { useChartJSStore } from './chartjs-store.js';
+export { useDashboardStore } from './dashboard-store.js';
+export { usePointerInteractionStore } from './pointer-interaction-store.js';
+export { useEditorStore, useEditorActions } from './editor-store.js';
+export { useAssistantLayoutStore, useAssistantPanel, useFullscreenAssistant, useAssistantContainer, } from './assistant-layout-store.js';
+export { useAIInteractionStore, useCurrentAIContext, useAISelectedEntities, useAIActions, } from './ai-interaction-store.js';
+export { useManagementStore, useSelectedDashboard, useSelectedVisual, useLastSelectedDashboard, useLastSelectedVisual, useManagementActions, useIsDashboardSelected, useIsVisualSelected, } from './management-store.js';
+export { useExportStore, useExportActions, useActiveExports, useInProgressExportsCount, type ActiveExport, type ExportStore, } from './export-store.js';
+export * from './utils.js';

package/dist/types/lib/stores/interaction-store.d.ts

@@ -0,0 +1,113 @@
+import { ShelfCard } from '../utils/card-definition.js';
+import { InteractionEvent, InteractionState, ClickFilterEvent, ClickFilterCondition } from '../types/interaction-types.js';
+import { CardConfig, FilterGroup } from '../types/explorer-types.js';
+import { TCard } from '../types/common-types.js';
+/**
+ * Special card ID for global drill-through context
+ * Stores drill filters that apply to all cards on the destination dashboard
+ */
+export declare const DRILL_CONTEXT_CARD_ID = "__DRILL_CONTEXT__";
+/**
+ * Creates the initial state for interaction tracking
+ */
+export declare function createInitialInteractionState(): InteractionState;
+interface InteractionStore {
+    /** Maps card IDs to their interaction states */
+    interactionStates: Record<string, InteractionState>;
+    /** Maps card IDs to insight replacements (for replace-card display mode) */
+    replacedCards: Record<string, {
+        insightId: string;
+        filters?: any[];
+        contextMode?: 'interactionFilters' | 'full' | 'none';
+    }>;
+    /** Pending drill-through navigation (waiting for metadata to load) */
+    pendingDrillThrough: {
+        targetDashboardId: string;
+        sourceDashboardId: string;
+        sourceDashboardTitle?: string;
+        filters: ClickFilterCondition[];
+        contextMode: 'interactionFilters' | 'full' | 'none';
+    } | null;
+    /** Sets the interaction state for a specific card */
+    setInteractionState: (cardId: string, state: InteractionState) => void;
+    /** Resets the interaction state for a specific card to initial state */
+    resetInteractionState: (cardId: string) => void;
+    /** Applies an interaction event to a card, optionally replacing existing events */
+    applyInteractionEvent: (cardId: string, event: InteractionEvent, replaceExisting?: boolean) => void;
+    /** Toggles a click filter on/off for a card */
+    toggleClickFilter: (cardId: string, event: ClickFilterEvent) => void;
+    /** Removes click filters that match a specific field-value combination */
+    removeClickFiltersByValue: (cardId: string, fieldName: string, value: string | number | null) => void;
+    /** Removes the last interaction step (breadcrumb) from a card */
+    popInteractionStep: (cardId: string) => void;
+    /** Clears the last interaction event for a card (after execution) */
+    clearLastInteractionEvent: (cardId: string) => void;
+    /** Replaces a card with an insight (for replace-card display mode) */
+    replaceCardWithInsight: (cardId: string, insightId: string, filters?: any[], contextMode?: 'interactionFilters' | 'full' | 'none') => void;
+    /** Restores a replaced card to its original state */
+    restoreCard: (cardId: string) => void;
+    /** Clears all click filters across all cards */
+    clearAllClickFilters: () => void;
+    /** Sets pending drill-through navigation */
+    setPendingDrillThrough: (params: {
+        targetDashboardId: string;
+        sourceDashboardId: string;
+        sourceDashboardTitle?: string;
+        filters: ClickFilterCondition[];
+        contextMode: 'interactionFilters' | 'full' | 'none';
+    }) => void;
+    /** Clears pending drill-through navigation */
+    clearPendingDrillThrough: () => void;
+    /** Resets all interaction states. Called when loading a new dashboard. */
+    resetAllInteractionStates: () => void;
+}
+export declare const useInteractionStore: import('zustand').UseBoundStore<Omit<import('zustand').StoreApi<InteractionStore>, "setState" | "devtools"> & {
+    setState(partial: InteractionStore | Partial<InteractionStore> | ((state: InteractionStore) => InteractionStore | Partial<InteractionStore>), replace?: false | undefined, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    setState(state: InteractionStore | ((state: InteractionStore) => InteractionStore), replace: true, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    devtools: {
+        cleanup: () => void;
+    };
+}>;
+/**
+ * Hook to get all click filters that apply to a specific card
+ * Filters out filters from the card itself and applies inclusion/exclusion rules
+ */
+export declare function getClickFiltersForCardFromStates(cardId: string, interactionStates: Record<string, InteractionState | undefined>): ClickFilterEvent[];
+export declare const useClickFiltersForCard: (cardId: string) => ClickFilterEvent[];
+/**
+ * Combines static filters, click filters, and drill breadcrumbs into a single merged FilterGroup.
+ *
+ * Filter combination logic:
+ * - Inside a filter group (group.filters): AND
+ * - Between filter groups in ClickFilterEvent or DrillBreadcrumb: OR
+ * - Between breadcrumbs (drill steps): AND
+ * - Between click filters, drill filters, and static filters: AND
+ */
+export declare function resolveFiltersFromInteractionStates(card: TCard, interactionStates: Record<string, InteractionState | undefined>, currentDashboardId?: string, options?: {
+    includeAuthoredFilters?: boolean;
+}): FilterGroup | undefined;
+export declare function useResolvedFilters(card: TCard): FilterGroup | undefined;
+/**
+ * Returns a modified copy of card.config where groupBy is overridden
+ * by the most recent drill target field from breadcrumbs (if any).
+ * Also updates sortByColumns to prevent SQL errors when drilling.
+ */
+export declare function resolveCardConfigFromInteractionStates(card: TCard, interactionStates: Record<string, InteractionState | undefined>, resolvedFilters?: FilterGroup): CardConfig;
+export declare function resolveShelfCardConfigFromInteractionStates(card: ShelfCard, interactionStates: Record<string, InteractionState | undefined>, resolvedFilters?: FilterGroup): CardConfig;
+export declare function useResolvedCardConfig(card: TCard): CardConfig;
+/**
+ * Generates a stable key for React Query based on the final resolved filters
+ */
+export declare function getFinalFilterGroupKeyFromInteractionStates(card: TCard, interactionStates: Record<string, InteractionState | undefined>, resolvedFilters?: FilterGroup): string | undefined;
+export declare function useFinalFilterGroupKey(card: TCard): string | undefined;
+export {};

package/dist/types/lib/stores/management-store.d.ts

@@ -0,0 +1,31 @@
+import { ResourceListItem } from '../../components/sharing-and-management/hooks/use-resource-management.js';
+type ManagementStore = {
+    initialDashboard: ResourceListItem | null;
+    selectedDashboard: ResourceListItem | null;
+    selectedVisual: ResourceListItem | null;
+    lastSelectedDashboard: ResourceListItem | null;
+    lastSelectedVisual: ResourceListItem | null;
+    showHub: boolean;
+    actions: Actions;
+};
+type Actions = {
+    selectDashboard: (dashboard: ResourceListItem) => void;
+    updateSelectedDashboard: (dashboard: ResourceListItem) => void;
+    selectVisual: (visual: ResourceListItem) => void;
+    clearSelectedDashboard: () => void;
+    clearSelectedVisual: () => void;
+    setInitialDashboard: (dashboard: ResourceListItem) => void;
+    setShowHub: (show: boolean) => void;
+};
+export declare const useManagementStore: import('zustand').UseBoundStore<Omit<import('zustand').StoreApi<ManagementStore>, "setState"> & {
+    setState(nextStateOrUpdater: ManagementStore | Partial<ManagementStore> | ((state: import('immer').WritableDraft<ManagementStore>) => void), shouldReplace?: false): void;
+    setState(nextStateOrUpdater: ManagementStore | ((state: import('immer').WritableDraft<ManagementStore>) => void), shouldReplace: true): void;
+}>;
+export declare const useSelectedDashboard: () => ResourceListItem | null;
+export declare const useSelectedVisual: () => ResourceListItem | null;
+export declare const useLastSelectedDashboard: () => ResourceListItem | null;
+export declare const useLastSelectedVisual: () => ResourceListItem | null;
+export declare const useManagementActions: () => Actions;
+export declare const useIsDashboardSelected: (dashboardId: string) => boolean;
+export declare const useIsVisualSelected: (visualId: string) => boolean;
+export {};

package/dist/types/lib/stores/mount-store-devtool.d.ts

@@ -0,0 +1,2 @@
+import { StoreApi, UseBoundStore } from 'zustand';
+export declare const mountStoreDevtoolOnce: <T extends object>(storeName: string, store: UseBoundStore<StoreApi<T>>) => void;

package/dist/types/lib/stores/pointer-interaction-store.d.ts

@@ -0,0 +1,18 @@
+import { ClickFilterCondition, ClickedMetricValue } from '../types/interaction-types.js';
+export type PointerInteractionType = 'leftClick' | 'rightClick' | 'hover' | 'longPress' | 'multiClick';
+export interface PointerInteractionContext {
+    type: PointerInteractionType;
+    cardId: string;
+    conditions: ClickFilterCondition[];
+    metric?: ClickedMetricValue;
+    anchorPosition?: {
+        x: number;
+        y: number;
+    };
+}
+export declare const usePointerInteractionStore: import('zustand').UseBoundStore<import('zustand').StoreApi<{
+    context: PointerInteractionContext | null;
+    setContext: (ctx: PointerInteractionContext) => void;
+    appendCondition: (cond: ClickFilterCondition) => void;
+    clear: () => void;
+}>>;