react-semaphor 0.1.504 → 0.1.505

package/dist/types/lib/hooks/use-calendar-context.d.ts

@@ -0,0 +1,13 @@
+import { CalendarContext, ReportPreferenceSources, WeekStart } from '../../shared/report-runtime-context/index.js';
+import { ResolvedTemporalValueFormatPreferences, ResolvedValueFormatPreferences } from '../../shared/value-format-preferences/index.js';
+export declare function useCalendarContext(): CalendarContext | null;
+export declare function useTimezone(): string | null;
+export declare function useWeekStart(): WeekStart | null;
+export declare function useResolvedValueFormatPreferences(): ResolvedValueFormatPreferences | null;
+export declare function useResolvedTemporalStylePreferences(): ResolvedTemporalValueFormatPreferences | null;
+export declare function useResolvedValueFormatLocale(): string | null;
+export declare function useResolvedDateStyle(): ResolvedValueFormatPreferences['dateStyle'] | null;
+export declare function useResolvedDateTimeDateStyle(): ResolvedValueFormatPreferences['dateTime']['dateStyle'] | null;
+export declare function useResolvedDateTimeTimeStyle(): ResolvedValueFormatPreferences['dateTime']['timeStyle'] | null;
+export declare function useResolvedDefaultCurrency(): string | null;
+export declare function useReportPreferenceSources(): ReportPreferenceSources | null;

package/dist/types/lib/hooks/use-calendar-preferences.d.ts

@@ -0,0 +1,16 @@
+import { CalendarPreferences, CalendarPreferencesResponse } from '../../shared/report-runtime-context/index.js';
+interface UseCalendarPreferencesResult {
+    preferences: CalendarPreferencesResponse | null;
+    isLoading: boolean;
+    isSaving: boolean;
+    isClearing: boolean;
+    error: string | null;
+    updatePreferences: (prefs: CalendarPreferences) => Promise<boolean>;
+    clearPreferences: () => Promise<boolean>;
+    refetch: () => Promise<void>;
+}
+interface UseCalendarPreferencesOptions {
+    enabled?: boolean;
+}
+export declare function useCalendarPreferences(options?: UseCalendarPreferencesOptions): UseCalendarPreferencesResult;
+export {};

package/dist/types/lib/hooks/use-card-filter-values.d.ts

@@ -0,0 +1,19 @@
+/**
+ * React hook that returns filters and filter values applicable to a specific card,
+ * taking into account both sheet-level and card-level scoping.
+ *
+ * This hook fetches the necessary data from the dashboard store and delegates
+ * the filtering logic to the calculateCardFilterValues utility function.
+ *
+ * Scoping logic:
+ * 1. Sheet-level scope is applied first (applyToSheetIds, excludeSheetIds)
+ * 2. Card-level scope is applied second (applyToCardIds, excludeCardIds)
+ * 3. Filters without scope properties apply to all sheets/cards (default)
+ *
+ * @param cardId - The ID of the card to get filters for
+ * @returns Object containing cardFilters and cardFilterValues
+ */
+export declare function useCardFilterValues(cardId: string): {
+    cardFilters: import('../types/index.js').TFilter[] | undefined;
+    cardFilterValues: import('../types/index.js').TFilterValue[] | undefined;
+};

package/dist/types/lib/hooks/use-card-numeric-presentation.d.ts

@@ -0,0 +1,11 @@
+import { ResolvedValueFormatPreferences } from '../../shared/value-format-preferences/index.js';
+import { CurrencyPresentationTarget, TCard } from '../types/common-types.js';
+import { CardNumericPresentationContext } from '../formatters/numeric-presentation.js';
+import { MatrixCardCatalog } from '../matrix-table/matrix-card-adapter.js';
+export declare function useCardNumericPresentation(card?: TCard, resultColumnKeys?: readonly string[], matrixCatalog?: MatrixCardCatalog): CardNumericPresentationContext;
+export declare function usePrimaryKpiNumericPresentation(card: TCard, records?: Record<string, unknown>[] | null): {
+    preferences: ResolvedValueFormatPreferences | null;
+    boundCurrency?: string;
+    resultColumnKeys: readonly string[];
+    resolveBoundCurrency: (target: CurrencyPresentationTarget) => string | undefined;
+};

package/dist/types/lib/hooks/use-card-summary.d.ts

@@ -0,0 +1,17 @@
+import { SummaryResponse } from '../types/summary-types.js';
+import { TCard } from '../types/common-types.js';
+type UseCardSummaryOptions = {
+    enabled?: boolean;
+};
+export declare function useCardSummary(card: TCard, options?: UseCardSummaryOptions): {
+    data: SummaryResponse | undefined;
+    isLoading: boolean;
+    isFetching: boolean;
+    isError: boolean;
+    error: Error | null;
+    refresh: import('@tanstack/react-query').UseMutateAsyncFunction<SummaryResponse, Error, void, unknown>;
+    isRefreshing: boolean;
+    applyAction: (action: import('../types/summary-types.js').SummaryAction) => Promise<void>;
+    enabled: boolean;
+};
+export {};

package/dist/types/lib/hooks/use-chart-numeric-presentation.d.ts

@@ -0,0 +1,3 @@
+import { TCard } from '../types/common-types.js';
+import { ChartNumericPresentationContext } from '../formatters/chart-numeric-presentation.js';
+export declare function useChartNumericPresentation(card: TCard | undefined, records?: readonly Record<string, unknown>[]): ChartNumericPresentationContext;

package/dist/types/lib/hooks/use-click-outside.d.ts

@@ -0,0 +1,21 @@
+import { RefObject } from 'react';
+interface UseClickOutsideOptions {
+    enabled?: boolean;
+    eventType?: 'mousedown' | 'click' | 'pointerdown';
+    /**
+     * Extra elements treated as "inside" — events starting within them do
+     * not fire the callback. Use for a popover's own trigger: closing on
+     * the trigger's pointerdown would race the trigger's click toggle
+     * (close → immediately reopen). Leaving the trigger to Radix lets its
+     * native toggle close the popover exactly once.
+     */
+    ignoreRefs?: RefObject<HTMLElement | null>[];
+}
+/**
+ * Hook to handle click outside of a referenced element
+ * @param callback Function to call when click is detected outside
+ * @param options Configuration options
+ * @returns Ref object to attach to the target element
+ */
+export declare function useClickOutside<T extends HTMLElement = HTMLElement>(callback: () => void, options?: UseClickOutsideOptions): RefObject<T | null>;
+export {};

package/dist/types/lib/hooks/use-column-sizing.d.ts

@@ -0,0 +1,27 @@
+import { ColumnSizingState } from '@tanstack/react-table';
+import { ColumnSettingsMap } from '../../components/visual/data-table/types/data-table.js';
+interface UseColumnSizingProps {
+    initialSizing?: ColumnSizingState;
+    /** Authored updates replace local sizing; unchanged values do not reset a drag. */
+    externalSizing?: ColumnSizingState;
+    columnSettings?: ColumnSettingsMap;
+    onSizingChange?: (sizing: ColumnSizingState) => void;
+    onColumnSettingsChange?: (settings: ColumnSettingsMap) => void;
+    debounceMs?: number;
+}
+interface ColumnSizingPreset {
+    name: string;
+    sizing: ColumnSizingState;
+}
+export declare function useColumnSizing({ initialSizing, externalSizing, columnSettings, onSizingChange, onColumnSettingsChange, debounceMs, }: UseColumnSizingProps): {
+    columnSizing: ColumnSizingState;
+    handleColumnSizingChange: (updater: ColumnSizingState | ((old: ColumnSizingState) => ColumnSizingState)) => void;
+    autoFitColumn: (columnId: string, tableElement: HTMLTableElement) => void;
+    autoFitAllColumns: (tableElement: HTMLTableElement) => void;
+    fitColumnsToPage: (tableElement: HTMLTableElement, pageWidth?: number) => void;
+    savePreset: (name: string) => void;
+    loadPreset: (name: string) => void;
+    resetSizing: () => void;
+    presets: ColumnSizingPreset[];
+};
+export {};

package/dist/types/lib/hooks/use-connections.d.ts

@@ -0,0 +1,27 @@
+import { AuthToken, TDbCapabilities } from '../types/common-types.js';
+import { Dialect } from '../types/explorer-types.js';
+type TConnection = {
+    id: string;
+    name: string;
+    type: string;
+    dialect?: Dialect;
+    uiType?: 'database' | 'api' | 's3';
+    capabilities: TDbCapabilities;
+};
+export declare function useConnections(token?: AuthToken): {
+    isPending: boolean;
+    error: boolean;
+    connectionsData: any;
+    connections: TConnection[];
+    isConnectionsLoading: boolean;
+    isConnectionsError: boolean;
+    refetchConnections: (options?: import('@tanstack/query-core').RefetchOptions) => Promise<import('@tanstack/query-core').QueryObserverResult<any, Error>>;
+    selectedConnection: TConnection | undefined;
+};
+export declare function useSelectedConnection(token?: AuthToken): {
+    selectedConnection: TConnection | undefined;
+    capabilities: TDbCapabilities | undefined;
+    connectionType: string | undefined;
+    hasSchemaSupport: boolean | undefined;
+};
+export {};

package/dist/types/lib/hooks/use-control-values-query.d.ts

@@ -0,0 +1,48 @@
+import { ControlDefinition, SqlQueryControlSource } from '../types/common-types.js';
+import { TFilterValue } from '../../components/surfboard/filter/types.js';
+export type ControlValuesOption = {
+    value: string;
+    label: string;
+};
+export type ControlValuesResponse = {
+    options: ControlValuesOption[];
+    metadata: {
+        limit: number;
+        truncated: boolean;
+    };
+};
+export type ControlValuesErrorPayload = {
+    error?: string;
+    code?: string;
+    details?: unknown;
+};
+type UseControlValuesQueryArgs = {
+    controlId: string;
+    source: SqlQueryControlSource | undefined;
+    enabled?: boolean;
+    controlDefinitionsOverride?: ControlDefinition[];
+    controlValuesOverride?: Record<string, unknown>;
+    activeFiltersOverride?: TFilterValue[];
+};
+/**
+ * Resolve options for a SQL-backed control by calling POST /v1/control-values.
+ *
+ * Used by both authoring-time preview and runtime option loading so the two
+ * paths stay in lockstep. Query key intentionally depends on the full source
+ * config, current dashboard control values, and current-sheet active filter
+ * state — we do not parse SQL in the client to derive narrower dependencies.
+ */
+export declare function useControlValuesQuery({ controlId, source, enabled, controlDefinitionsOverride, controlValuesOverride, activeFiltersOverride, }: UseControlValuesQueryArgs): {
+    data: ControlValuesResponse | undefined;
+    options: ControlValuesOption[];
+    metadata: {
+        limit: number;
+        truncated: boolean;
+    } | undefined;
+    isLoading: boolean;
+    isFetching: boolean;
+    isError: boolean;
+    error: ControlValuesErrorPayload | undefined;
+    refetch: (options?: import('@tanstack/query-core').RefetchOptions) => Promise<import('@tanstack/query-core').QueryObserverResult<ControlValuesResponse, Error>>;
+};
+export {};

package/dist/types/lib/hooks/use-copy-paste-frame.d.ts

@@ -0,0 +1,2 @@
+export declare function useCopyPasteFrame(refSheetContent: React.RefObject<HTMLDivElement | null>): void;
+export declare function isEditableShortcutTarget(target: EventTarget | null): boolean;

package/dist/types/lib/hooks/use-custom-visuals-query.d.ts

@@ -0,0 +1,30 @@
+import { SlotDefinition } from '../../components/visual/custom-visual/custom-visual-types.js';
+export type PluginVisual = {
+    name: string;
+    pluginName: string;
+    componentType?: 'chart' | 'editor' | 'settings';
+    pluginType: 'custom' | 'standard';
+    icon?: string;
+    chartType?: string;
+    visualType?: 'single' | 'multiple';
+    minInputs?: number;
+    maxInputs?: number;
+    slots?: SlotDefinition[];
+    url: string;
+};
+export type PluginFilter = {
+    name: string;
+    component: string;
+    pluginName: string;
+    pluginType: 'custom' | 'standard';
+    icon?: string;
+    filterType?: string;
+    supportedDataTypes?: string[];
+    url: string;
+};
+export declare function useCustomVisualsQuery(): {
+    data: PluginVisual[];
+    filters: PluginFilter[];
+    isLoading: boolean;
+    isError: boolean;
+};

package/dist/types/lib/hooks/use-dashboard-authoring.d.ts

@@ -0,0 +1,49 @@
+import { DashboardPlan, DashboardSuggestion } from '../../shared/dashboard-authoring/index.js';
+import { SemaphorSourceRef } from '../../shared/analytics-protocol/index.js';
+type DashboardAuthoringDatasetRef = Extract<SemaphorSourceRef, {
+    kind: 'semantic' | 'physical';
+}>;
+type DashboardCreateSharing = {
+    visibility: 'private' | 'org_users' | 'tenant_all' | 'tenant_user';
+    shareRole?: 'VIEWER' | 'EDITOR' | 'CONTRIBUTOR';
+    tenantContext?: {
+        tenantId: string;
+        tenantUserId?: string;
+    };
+};
+export type DashboardAuthoringSource = DashboardAuthoringDatasetRef & {
+    domainName?: string;
+    domainLabel?: string;
+    description?: string;
+    connectionType?: string;
+    database?: string;
+    schema?: string;
+    table?: string;
+    primaryDateField?: string;
+};
+export type DashboardSuggestionRequest = {
+    dataset: SemaphorSourceRef;
+    instruction?: string;
+} | {
+    domainId: string;
+    datasetNames?: string[];
+    instruction?: string;
+};
+export type DashboardPlanRequest = {
+    prompt: string;
+    dataset: SemaphorSourceRef;
+} | {
+    prompt: string;
+    domainId: string;
+    datasetNames?: string[];
+};
+export declare function useDashboardAuthoringSources(open?: boolean): import('@tanstack/react-query').UseQueryResult<DashboardAuthoringSource[], Error>;
+export declare function useDashboardAuthoring(): {
+    planDashboard: import('@tanstack/react-query').UseMutationResult<DashboardPlan, Error, DashboardPlanRequest, unknown>;
+    suggestDashboards: import('@tanstack/react-query').UseMutationResult<DashboardSuggestion[], Error, DashboardSuggestionRequest, unknown>;
+    createDashboardFromPlan: import('@tanstack/react-query').UseMutationResult<any, Error, DashboardPlan | {
+        plan: DashboardPlan;
+        sharing?: DashboardCreateSharing;
+    }, unknown>;
+};
+export {};

package/dist/types/lib/hooks/use-dashboard-card-query.d.ts

@@ -0,0 +1,4 @@
+import { TCard } from '../types/common-types.js';
+import { DashboardCardQueryOptions, DashboardCardQueryResult } from './use-dashboard-frame-query.js';
+export declare function useDashboardCardQuery(card: TCard, options?: DashboardCardQueryOptions): DashboardCardQueryResult;
+export declare function useEditorCardQuery(card: TCard): DashboardCardQueryResult;

package/dist/types/lib/hooks/use-dashboard-card.d.ts

@@ -0,0 +1,41 @@
+import { Chart } from 'chart.js';
+import { TCard } from '../types/common-types.js';
+export declare function useCard(cardId: string): {
+    data: any;
+    card: TCard;
+    isPending: boolean;
+    isError: boolean;
+    isLoading: boolean;
+    isFetching: boolean;
+    fetchStatus: import('@tanstack/query-core').FetchStatus;
+    visualKey: number;
+    handleDatapointClick: (chart: Chart, datasetIndex: number, clickIndex: number, value: number) => void;
+    cfg: any;
+    isRetainingSourceResult: boolean;
+    queryKey: string[];
+    queryRequestPayload: Record<string, unknown> | undefined;
+    pagination: import('../types/index.js').PaginationMetadata | undefined;
+    comparisonMetadata: import('../../shared/analytics-protocol/index.js').MetricComparisonMetadataMap | undefined;
+    resolvedPrimaryDateField: import('../types/semantic-runtime-types.js').ResolvedPrimaryDateField | undefined;
+    effectiveCardConfig: import('../types/index.js').CardConfig | undefined;
+    isCurrentQueryResult: boolean;
+};
+export declare function useDashboardCard(card: TCard): {
+    isPending: boolean;
+    isError: boolean;
+    isLoading: boolean;
+    isFetching: boolean;
+    fetchStatus: import('@tanstack/query-core').FetchStatus;
+    data: any;
+    visualKey: number;
+    handleDatapointClick: (chart: Chart, datasetIndex: number, clickIndex: number, value: number) => void;
+    cfg: any;
+    isRetainingSourceResult: boolean;
+    queryKey: string[];
+    queryRequestPayload: Record<string, unknown> | undefined;
+    pagination: import('../types/index.js').PaginationMetadata | undefined;
+    comparisonMetadata: import('../../shared/analytics-protocol/index.js').MetricComparisonMetadataMap | undefined;
+    resolvedPrimaryDateField: import('../types/semantic-runtime-types.js').ResolvedPrimaryDateField | undefined;
+    effectiveCardConfig: import('../types/index.js').CardConfig | undefined;
+    isCurrentQueryResult: boolean;
+};

package/dist/types/lib/hooks/use-dashboard-creation.d.ts

@@ -0,0 +1,17 @@
+interface UseDashboardCreationOptions {
+    /**
+     * Optional callback when dashboard is selected after creation
+     */
+    onDashboardSelect?: (dashboardId: string) => void;
+}
+/**
+ * Hook that provides the success callback for dashboard creation.
+ * Handles:
+ * - Immediate navigation (fast UX)
+ * - Background refetch for complete permissions
+ * - Race condition guard
+ */
+export declare function useDashboardCreation(options?: UseDashboardCreationOptions): {
+    onCreateSuccess: (createdDashboard: any, refetch: () => Promise<any>) => void;
+};
+export {};

package/dist/types/lib/hooks/use-dashboard-filter-mapping-candidates.d.ts

@@ -0,0 +1,22 @@
+import { TFilter } from '../../components/surfboard/filter/types.js';
+import { DashboardInputScope } from '../types/common-types.js';
+import { DashboardFilterOptionSource } from '../../shared/dashboard-authoring/index.js';
+export declare function useDashboardFilterMappingCandidates(params: {
+    filter: TFilter;
+    enabled: boolean;
+    outerScope: Extract<DashboardInputScope, {
+        kind: 'allSheets' | 'sheets';
+    }>;
+    optionSource?: DashboardFilterOptionSource;
+}): {
+    candidatesByCardId: Record<string, import('../dashboard-inputs/index.js').DashboardFilterMappingCandidateCatalog | undefined>;
+    fieldLabels: import('../dashboard-inputs/dashboard-filter-mapping-candidate-metadata.js').DashboardFilterMappingFieldLabels;
+    selectionField: Pick<import('../../shared/dashboard-authoring/index.js').DashboardFilterTargetField, "name"> | {
+        source: import('../../shared/dashboard-authoring/index.js').DashboardFilterTargetSource;
+        name: string;
+    } | undefined;
+    automaticSelectionSources: import('../../shared/dashboard-authoring/index.js').DashboardFilterTargetSource[];
+    selectionDataType: string;
+    isLoading: boolean;
+    retry: () => void;
+};

package/dist/types/lib/hooks/use-dashboard-filter-option-fields.d.ts

@@ -0,0 +1,15 @@
+import { DashboardFilterMappingFieldLabels, DashboardFilterOptionFieldChoice } from '../dashboard-inputs/dashboard-filter-mapping-candidate-metadata.js';
+import { TDataColumn } from '../types/common-types.js';
+import { DashboardFilterOptionSource } from '../../shared/dashboard-authoring/index.js';
+export declare function buildDashboardFilterOptionFieldChoice(column: TDataColumn, source: DashboardFilterOptionSource['source']): DashboardFilterOptionFieldChoice | undefined;
+/** Loads the governed field inventory for one option source. */
+export declare function useDashboardFilterOptionFields(params: {
+    optionSource?: DashboardFilterOptionSource;
+    enabled: boolean;
+}): {
+    fields: DashboardFilterOptionFieldChoice[];
+    fieldLabels: DashboardFilterMappingFieldLabels;
+    isLoading: boolean;
+    error: Error | null;
+    retry: (options?: import('@tanstack/query-core').RefetchOptions) => Promise<import('@tanstack/query-core').QueryObserverResult<any, Error>>;
+};

package/dist/types/lib/hooks/use-dashboard-frame-query.d.ts

@@ -0,0 +1,44 @@
+import { UseQueryResult } from '@tanstack/react-query';
+import { ControlDefinition, DashboardInputValues, TCard } from '../types/common-types.js';
+import { CardConfig, PaginationMetadata, TableTotalsRequest } from '../types/explorer-types.js';
+import { AutoJoinMetadata, ComparisonMetadataMap } from '../types/query-types.js';
+import { SemanticExecutionPayloadAuthority } from '../query-context/use-semantic-execution-payload-for-cards.js';
+import { TFilterValue } from '../../components/surfboard/filter/types.js';
+import { ResolvedPrimaryDateField } from '../types/semantic-runtime-types.js';
+import { DocumentTableDataPolicy } from '../document/document-table-data-policy.js';
+import { TemporalResultOwner } from '../../shared/dashboard-authoring/index.js';
+type QueryError = {
+    error: string;
+    sql: string;
+};
+type AdditionalState = {
+    isFilteringCard: boolean;
+    isSingleCardFrame: boolean;
+    queryKey: string[];
+    errorMessage: string;
+    errorSql: string;
+    pagination?: PaginationMetadata;
+    autoJoinMetadata?: AutoJoinMetadata;
+    comparisonMetadata?: ComparisonMetadataMap;
+    queryRequestPayload?: Record<string, unknown>;
+    resolvedPrimaryDateField?: ResolvedPrimaryDateField;
+    effectiveCardConfig?: CardConfig;
+    resultOwner: TemporalResultOwner;
+    isCurrentQueryResult: boolean;
+    isRetainingSourceResult: boolean;
+};
+export type DashboardCardQueryResult = UseQueryResult<any, Error> & AdditionalState;
+export type DashboardCardQueryOptions = {
+    semanticPayloadAuthority?: SemanticExecutionPayloadAuthority;
+    runtimeContext?: 'dashboard' | 'documentSection';
+    documentSheetId?: string;
+    documentSectionId?: string;
+    documentTableDataPolicy?: DocumentTableDataPolicy;
+    documentFilterValues?: TFilterValue[];
+    documentControlDefinitions?: ControlDefinition[];
+    documentControlValues?: Record<string, unknown>;
+    documentDashboardInputValues?: DashboardInputValues;
+    tableTotalsRequest?: TableTotalsRequest;
+};
+export declare function useDashboardFrameQuery(cards: TCard[], options?: DashboardCardQueryOptions): DashboardCardQueryResult[];
+export type { AdditionalState, QueryError };

package/dist/types/lib/hooks/use-dashboard-input-target-context.d.ts

@@ -0,0 +1,24 @@
+import { TFilter } from '../../components/surfboard/filter/types.js';
+import { DashboardInputTargetContext, DashboardInputTargetScope } from '../dashboard-inputs/dashboard-input-target-context.js';
+export type DashboardInputTargetContextOptions = {
+    /**
+     * An explicit context supplied by the surface (explorer field probes,
+     * captured execution). Returned as is; nothing is read from the store.
+     */
+    inputContext?: DashboardInputTargetContext;
+    /**
+     * The target's scope. Sheet id defaults to the selected sheet; sheet kind
+     * is inferred from the dashboard when the presentation does not state it.
+     */
+    scope?: DashboardInputTargetScope;
+};
+/**
+ * The store-backed way to obtain the Input target context for a filter. Every
+ * option hook reads scope, peers, values and controls from here; none of them
+ * looks at `dashboard.filters` or the selected sheet id directly.
+ *
+ * Card-local targets resolve against the editor's draft card and draft inline
+ * values while a visual edit is open, so previews browse the values being
+ * edited rather than the last saved ones.
+ */
+export declare function useDashboardInputTargetContext(filter: TFilter, options?: DashboardInputTargetContextOptions): DashboardInputTargetContext;

package/dist/types/lib/hooks/use-dashboard-interaction-mode.d.ts

@@ -0,0 +1 @@
+export declare function useDashboardInteractionMode(): import('../utils/dashboard-interaction-mode.js').DashboardInteractionMode;

package/dist/types/lib/hooks/use-dashboard-kpi-actions.d.ts

@@ -0,0 +1,11 @@
+import { TCard } from '../types/common-types.js';
+/**
+ * Hook that provides KPI card actions scoped to visual editor mode.
+ */
+export declare function useDashboardKpiActions(_card: TCard): {
+    setTitle: (title: string) => void;
+    setCountryLogo: (countryId: string | null) => void;
+    isEditable: boolean;
+    isDashboardEditing: boolean;
+    isVisualEditing: boolean;
+};

package/dist/types/lib/hooks/use-dashboard-preferences.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Hook to access dashboard UI mode preferences (developer mode, console mode, etc.)
+ * Note: For card display preferences, use useDisplayPreferences() instead
+ */
+export declare function useDashboardPreferences(): import('../contexts/dashboard-preferences-context.js').DashboardPreferencesContextType;

package/dist/types/lib/hooks/use-dashboard-query.d.ts

@@ -0,0 +1,28 @@
+export declare function useDashboardQuery(): {
+    data: {
+        initialReportContext: import('../../shared/report-runtime-context/index.js').ReportRuntimeContext;
+        dashboard: import('../types/index.js').TDashboard;
+        lenses: import('../types/index.js').TLens[];
+        filterValues?: import('../types/index.js').TFilterValue[] | null;
+        inputValues?: import('../types/index.js').LensInputValuesSnapshot | null;
+        defaultLensId?: string;
+        assistantProfileId?: string;
+        semanticExecutionPayload: import('../types/semantic-runtime-types.js').SemanticExecutionPayload;
+        organizationAppearance?: import('../types/index.js').AppearanceSpec | null;
+    } | null | undefined;
+    isLoading: boolean;
+    isFetching: boolean;
+    isError: boolean;
+    refetch: (options?: import('@tanstack/query-core').RefetchOptions) => Promise<import('@tanstack/query-core').QueryObserverResult<{
+        initialReportContext: import('../../shared/report-runtime-context/index.js').ReportRuntimeContext;
+        dashboard: import('../types/index.js').TDashboard;
+        lenses: import('../types/index.js').TLens[];
+        filterValues?: import('../types/index.js').TFilterValue[] | null;
+        inputValues?: import('../types/index.js').LensInputValuesSnapshot | null;
+        defaultLensId?: string;
+        assistantProfileId?: string;
+        semanticExecutionPayload: import('../types/semantic-runtime-types.js').SemanticExecutionPayload;
+        organizationAppearance?: import('../types/index.js').AppearanceSpec | null;
+    } | null, Error>>;
+    dashboardIdToFetch: string | null;
+};

package/dist/types/lib/hooks/use-dashboard-summary.d.ts

@@ -0,0 +1,13 @@
+import { SummaryAction, SummaryResponse } from '../types/summary-types.js';
+export declare function useDashboardSummary(): {
+    data: SummaryResponse | undefined;
+    isLoading: boolean;
+    isFetching: boolean;
+    isError: boolean;
+    error: Error | null;
+    refetch: (options?: import('@tanstack/query-core').RefetchOptions) => Promise<import('@tanstack/query-core').QueryObserverResult<SummaryResponse, Error>>;
+    refresh: import('@tanstack/react-query').UseMutateAsyncFunction<SummaryResponse, Error, void, unknown>;
+    isRefreshing: boolean;
+    applyAction: (action: SummaryAction) => Promise<void>;
+    enabled: boolean;
+};

package/dist/types/lib/hooks/use-dashboard-unsaved-changes-check.d.ts

@@ -0,0 +1,3 @@
+import { TDashboard } from '../types/common-types.js';
+/** Share the editor's baseline with host navigation, without a second dirty flag. */
+export declare function useDashboardUnsavedChangesCheck(pristineDashboard: TDashboard | null, isInspectionMode: boolean, lifecycleEnabled?: boolean): () => boolean;

package/dist/types/lib/hooks/use-dashboard.d.ts

@@ -0,0 +1,49 @@
+import { AuthToken, ControlBinding, ControlDefinition, CustomCard, DashboardLifecycleEvent, DashboardInputExecutionSnapshot, TDashboard, TEvent, TStyle } from '../types/common-types.js';
+import { PresentationExecutionSnapshot } from '../../shared/format-utils/index.js';
+import { TFilterValue } from '../../components/index.js';
+import { InteractionState } from '../types/interaction-types.js';
+type UseDashboardProps = {
+    id?: string;
+    version?: string;
+    authToken: AuthToken | undefined;
+    defaultFilterValues?: {
+        filterId: string;
+        values: string[] | number[];
+    }[] | TFilterValue[];
+    defaultControlValues?: Record<string, unknown>;
+    controlContractOverrides?: {
+        controlDefinitions?: ControlDefinition[];
+        cardControlDefinitions?: ControlDefinition[];
+        controlBindings?: ControlBinding[];
+    };
+    dashboardInputExecutionSnapshot?: DashboardInputExecutionSnapshot;
+    interactionExecutionSnapshot?: Record<string, InteractionState>;
+    presentationExecutionSnapshot?: PresentationExecutionSnapshot;
+    customStyle?: TStyle;
+    currentTheme?: 'light' | 'dark' | 'system';
+    onSave?: (dashboard: TDashboard) => void;
+    onEvent?: (event: TEvent) => void;
+    onDashboardLifecycleEvent?: (event: DashboardLifecycleEvent) => void;
+    onFilterValuesChange?: (filterValues: TFilterValue[]) => void;
+    customCards?: CustomCard[];
+    selectedSheetId?: string;
+    type?: 'dashboard' | 'visual';
+    cardId?: string;
+};
+export declare function useDashboard({ customStyle, currentTheme, onSave, onEvent, onDashboardLifecycleEvent, defaultFilterValues, defaultControlValues, controlContractOverrides, dashboardInputExecutionSnapshot, interactionExecutionSnapshot, presentationExecutionSnapshot, type, cardId, selectedSheetId, onFilterValuesChange, }: UseDashboardProps): {
+    isFetching: boolean;
+    isLoading: boolean;
+    isError: boolean;
+    refetch: (options?: import('@tanstack/query-core').RefetchOptions) => Promise<import('@tanstack/query-core').QueryObserverResult<{
+        initialReportContext: import('../../shared/report-runtime-context/index.js').ReportRuntimeContext;
+        dashboard: TDashboard;
+        lenses: import('../../components/index.js').TLens[];
+        filterValues?: TFilterValue[] | null;
+        inputValues?: import('../../components/index.js').LensInputValuesSnapshot | null;
+        defaultLensId?: string;
+        assistantProfileId?: string;
+        semanticExecutionPayload: import('../types/semantic-runtime-types.js').SemanticExecutionPayload;
+        organizationAppearance?: import('../../components/index.js').AppearanceSpec | null;
+    } | null, Error>>;
+};
+export {};

package/dist/types/lib/hooks/use-data-columns.d.ts

@@ -0,0 +1,8 @@
+import { AuthToken, TDataColumn } from '../types/common-types.js';
+export declare function useDataColumns(token?: AuthToken): {
+    columns: TDataColumn[];
+    isColumnsLoading: boolean;
+    isColumnsFetching: boolean;
+    isColumnsError: boolean;
+    refetchColumns: (options?: import('@tanstack/query-core').RefetchOptions) => Promise<import('@tanstack/query-core').QueryObserverResult<any, Error>>;
+};