@wisdomai/react 0.0.8

package/dist/dashboard/filterForms/DateFilterForm.d.ts

@@ -0,0 +1,21 @@
+import { DateExpression, DateFilter, RHS, type TimePeriodGranularity } from '@wisdomai/visualization/sdk-filters';
+import type { Maybe } from '../../generated/graphql/graphql';
+interface DateFilterFormProps {
+    filter: DateFilter;
+    close: () => void;
+    onSubmit: () => void;
+    fyStartMonth?: number;
+}
+export declare const getDateResolution: (rhs: RHS<Maybe<DateExpression>>) => TimePeriodGranularity;
+export declare const splitDateStringToNumber: (dateString: string | undefined) => [number, number];
+export declare enum DateFilterType {
+    CURRENT = "CURRENT",
+    PREVIOUS = "PREVIOUS",
+    NEXT = "NEXT",
+    SINGLE = "SINGLE",
+    RANGE = "RANGE",
+    NULL = "NULL",
+    NOT_NULL = "NOT_NULL"
+}
+export declare function DateFilterForm({ filter, close, onSubmit, fyStartMonth: fyStartMonthFromDomain }: DateFilterFormProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/dist/dashboard/filterForms/EnumFilterForm.d.ts

@@ -0,0 +1,13 @@
+import { EnumFilter } from '@wisdomai/visualization/sdk-filters';
+import type { ColumnRefInput } from '../../generated/graphql/graphql';
+import type { UseStringFilterSuggestionsResult } from './useStringFilterSuggestions';
+interface EnumFilterFormProps {
+    filter: EnumFilter;
+    close: () => void;
+    onSubmit: () => void;
+    columnRefs?: ColumnRefInput[];
+    suggestions?: UseStringFilterSuggestionsResult;
+    onSearchTextChange?: (searchText: string | undefined) => void;
+}
+export declare function EnumFilterForm({ filter, close, onSubmit, columnRefs, suggestions, onSearchTextChange, }: EnumFilterFormProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/dist/dashboard/filterForms/FilterPill.d.ts

@@ -0,0 +1,12 @@
+import { type ParsedVisualizationFilter } from '@wisdomai/visualization/sdk-filters';
+import { type SdkDashboardFilterSpecFragmentFragment } from '../../generated/graphql/graphql';
+import type { DomainFilterColumn } from '../../resources/dashboards';
+export interface FilterPillProps {
+    spec: SdkDashboardFilterSpecFragmentFragment;
+    currentFilter: ParsedVisualizationFilter | null;
+    isLoading: boolean;
+    onSubmit: (filter: ParsedVisualizationFilter | null) => void;
+    /** Eagerly-fetched domain filter columns; used to give a fresh enum its static allowed set. */
+    filterColumns?: DomainFilterColumn[];
+}
+export declare function FilterPill({ spec, currentFilter, isLoading, onSubmit, filterColumns }: FilterPillProps): import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/dashboard/filterForms/LeftIntervalSelect.d.ts

@@ -0,0 +1,7 @@
+import { DataframeFunctionType, IntervalClosed } from '@wisdomai/visualization/sdk-filters';
+type Props = {
+    rangeClosed: IntervalClosed;
+    onRangeClosedChange: (value: DataframeFunctionType | undefined) => void;
+};
+export declare const LeftIntervalSelect: ({ rangeClosed, onRangeClosedChange }: Props) => import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/dist/dashboard/filterForms/NextDateInput.d.ts

@@ -0,0 +1,13 @@
+import { DateFilter, type PreviousNextTimeGranularity } from '@wisdomai/visualization/sdk-filters';
+import { DateFilterType } from './DateFilterForm';
+type Props = {
+    nextDate: string | undefined;
+    nextDateType: PreviousNextTimeGranularity;
+    filterType: DateFilterType | undefined;
+    setFilterType: (filterType: DateFilterType) => void;
+    setNextDate: (nextDate: string) => void;
+    setNextDateType: (nextDateType: PreviousNextTimeGranularity) => void;
+};
+export declare const getDefaultNextDateType: (filter: DateFilter) => PreviousNextTimeGranularity;
+export declare const NextDateInput: ({ nextDate, filterType, setFilterType, setNextDate, setNextDateType, nextDateType, }: Props) => import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/dist/dashboard/filterForms/NumberFilterForm.d.ts

@@ -0,0 +1,9 @@
+import { NumberFilter, RHS } from '@wisdomai/visualization/sdk-filters';
+type Props = {
+    filter: NumberFilter;
+    close: () => void;
+    onSubmit: () => void;
+};
+export declare const parseNumber: (value: RHS<number> | string | undefined) => number | undefined;
+export declare const NumberFilterForm: ({ filter, close, onSubmit }: Props) => import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/dist/dashboard/filterForms/PreviousDateInput.d.ts

@@ -0,0 +1,15 @@
+import { DateFilter, PreviousNextTimeExpressionType, type PreviousNextTimeGranularity } from '@wisdomai/visualization/sdk-filters';
+import { DateFilterType } from './DateFilterForm';
+type Props = {
+    previousDate: string | undefined;
+    previousDateType: PreviousNextTimeGranularity;
+    filterType: DateFilterType | undefined;
+    setFilterType: (filterType: DateFilterType) => void;
+    setPreviousDate: (previousDate: string) => void;
+    setPreviousDateType: (previousDateType: PreviousNextTimeGranularity) => void;
+};
+export declare const getDefaultPreviousDateType: (filter: DateFilter) => PreviousNextTimeGranularity;
+export declare const getValueForPreviousNext: (filter: DateFilter, type: PreviousNextTimeExpressionType) => string | undefined;
+export declare const getValueForIncludeCurrentTimePeriod: (filter: DateFilter) => boolean;
+export declare const PreviousDateInput: ({ previousDate, previousDateType, filterType, setFilterType, setPreviousDate, setPreviousDateType, }: Props) => import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/dist/dashboard/filterForms/QuarterInputField.d.ts

@@ -0,0 +1,6 @@
+type Props = {
+    quarter: string | undefined;
+    onChange: (value: string) => void;
+};
+export declare const QuarterInputField: ({ quarter, onChange, ...props }: Props) => import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/dist/dashboard/filterForms/RangeDateInput.d.ts

@@ -0,0 +1,25 @@
+import { DataframeFunctionType, IntervalClosed, type TimePeriodGranularity } from '@wisdomai/visualization/sdk-filters';
+import { DateTime } from 'luxon';
+type Props = {
+    rangeDateResolution: TimePeriodGranularity;
+    start: DateTime | null;
+    end: DateTime | null;
+    startYear: string | undefined;
+    endYear: string | undefined;
+    startWeek: string | undefined;
+    endWeek: string | undefined;
+    startQuarter: string | undefined;
+    endQuarter: string | undefined;
+    setRangeDateResolution: (rangeDateResolution: TimePeriodGranularity) => void;
+    onRangeChange: (start: DateTime | null, end: DateTime | null) => void;
+    onStartYearChange: (year: string) => void;
+    onEndYearChange: (year: string) => void;
+    onStartWeekChange: (week: string) => void;
+    onEndWeekChange: (week: string) => void;
+    onStartQuarterChange: (quarter: string) => void;
+    onEndQuarterChange: (quarter: string) => void;
+    rangeClosed?: IntervalClosed;
+    onRangeClosedChange?: (value: DataframeFunctionType | undefined) => void;
+};
+export declare const RangeDateInput: ({ start, end, startYear, endYear, startWeek, endWeek, startQuarter, endQuarter, rangeDateResolution, setRangeDateResolution, onRangeChange, onStartYearChange, onEndYearChange, onStartWeekChange, onEndWeekChange, onStartQuarterChange, onEndQuarterChange, rangeClosed, onRangeClosedChange, }: Props) => import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/dist/dashboard/filterForms/RelativeDateInput.d.ts

@@ -0,0 +1,20 @@
+import { DataframeFunctionType, type PreviousNextTimeGranularity } from '@wisdomai/visualization/sdk-filters';
+import { DateFilterType } from './DateFilterForm';
+type Props = {
+    currentDateType: DataframeFunctionType;
+    filterType: DateFilterType | undefined;
+    previousDate: string | undefined;
+    previousDateType: PreviousNextTimeGranularity;
+    nextDate: string | undefined;
+    nextDateType: PreviousNextTimeGranularity;
+    setFilterType: (filterType: DateFilterType) => void;
+    setCurrentDateType: (currentDateType: DataframeFunctionType) => void;
+    setPreviousDate: (previousDate: string) => void;
+    setPreviousDateType: (previousDateType: PreviousNextTimeGranularity) => void;
+    setNextDate: (nextDate: string) => void;
+    setNextDateType: (nextDateType: PreviousNextTimeGranularity) => void;
+    includeCurrentTimePeriod: boolean;
+    setIncludeCurrentTimePeriod: (includeCurrentTimePeriod: boolean) => void;
+};
+export declare const RelativeDateInput: ({ currentDateType, filterType, previousDate, previousDateType, nextDate, nextDateType, setFilterType, setCurrentDateType, setPreviousDate, setPreviousDateType, setNextDate, setNextDateType, includeCurrentTimePeriod, setIncludeCurrentTimePeriod, }: Props) => import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/dist/dashboard/filterForms/RightIntervalSelect.d.ts

@@ -0,0 +1,7 @@
+import { DataframeFunctionType, IntervalClosed } from '@wisdomai/visualization/sdk-filters';
+type Props = {
+    rangeClosed: IntervalClosed;
+    onRangeClosedChange: (value: DataframeFunctionType | undefined) => void;
+};
+export declare const RightIntervalSelect: ({ rangeClosed, onRangeClosedChange }: Props) => import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/dist/dashboard/filterForms/SingleDateInput.d.ts

@@ -0,0 +1,20 @@
+import { type TimePeriodGranularity } from '@wisdomai/visualization/sdk-filters';
+import { DateTime } from 'luxon';
+type Props = {
+    dateResolution: TimePeriodGranularity;
+    value: DateTime | null;
+    year: string | undefined;
+    week: string | undefined;
+    quarter: string | undefined;
+    fiscalQuarter: string | undefined;
+    fiscalYear: string | undefined;
+    onValueChange: (date: DateTime | null) => void;
+    onYearChange: (year: string) => void;
+    onWeekChange: (week: string) => void;
+    onQuarterChange: (quarter: string) => void;
+    onFiscalQuarterChange: (quarter: string) => void;
+    onFiscalYearChange: (year: string) => void;
+    setDateResolution: (dateResolution: TimePeriodGranularity) => void;
+};
+export declare const SingleDateInput: ({ dateResolution, value, onValueChange, year, onYearChange, week, onWeekChange, quarter, onQuarterChange, fiscalQuarter, onFiscalQuarterChange, fiscalYear, onFiscalYearChange, setDateResolution, }: Props) => import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/dist/dashboard/filterForms/StringFilterForm.d.ts

@@ -0,0 +1,18 @@
+import { StringFilter } from '@wisdomai/visualization/sdk-filters';
+import type { ColumnRefInput } from '../../generated/graphql/graphql';
+import { type StringFilterOperator } from './buildFilter';
+import type { UseStringFilterSuggestionsResult } from './useStringFilterSuggestions';
+interface StringFilterFormProps {
+    filter: StringFilter;
+    close: () => void;
+    onSubmit: () => void;
+    columnRefs: ColumnRefInput[];
+    suggestions?: UseStringFilterSuggestionsResult;
+    onSearchTextChange?: (searchText: string | undefined) => void;
+    exactMatches?: boolean;
+    exactOperatorsOnly?: boolean;
+}
+export declare function getOperatorBasedOnFilterValue(filter: StringFilter): StringFilterOperator;
+export declare function getStringFilterSuggestionFetchArgs(columnRefs: ColumnRefInput[], searchText: string | undefined, suggestions: UseStringFilterSuggestionsResult | undefined): [ColumnRefInput[], string | undefined];
+export declare function StringFilterForm({ filter, close, onSubmit, columnRefs, suggestions, onSearchTextChange, exactMatches, exactOperatorsOnly, }: StringFilterFormProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/dist/dashboard/filterForms/WeekInputField.d.ts

@@ -0,0 +1,6 @@
+type Props = {
+    week: string | undefined;
+    onChange: (value: string) => void;
+};
+export declare const WeekInputField: ({ week, onChange, ...props }: Props) => import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/dist/dashboard/filterForms/YearInputField.d.ts

@@ -0,0 +1,6 @@
+type Props = {
+    year: string | undefined;
+    onChange: (value: string) => void;
+};
+export declare const YearInputField: ({ year, onChange, ...props }: Props) => import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/dist/dashboard/filterForms/buildFilter.d.ts

@@ -0,0 +1,56 @@
+import { BoolFilter, DateFilter, EnumFilter, NumberFilter, StringFilter, type ParsedVisualizationFilter } from '@wisdomai/visualization/sdk-filters';
+import { type SdkDashboardFilterSpecFragmentFragment } from '../../generated/graphql/graphql';
+import type { DomainFilterColumn } from '../../resources/dashboards';
+/**
+ * Match a dashboard filter spec's columnRef to its domain column. Mirrors the
+ * frontend's getAllowedValuesForFilterSpec (fallbackToTableIdMatch=true): the
+ * table is keyed by id == columnRef.tableRef.uuid, preferring a version match
+ * but falling back to id-only when versions differ. The skipWidgetData
+ * dashboard payload carries no visualization id, so domainId is the entry key.
+ */
+export declare function findFilterColumnForRef(columns: readonly DomainFilterColumn[], columnRef: SdkDashboardFilterSpecFragmentFragment['columnRef']): DomainFilterColumn | undefined;
+export type StringFilterOperator = 'matches' | 'matches_multiple' | 'doesnt_match' | 'contains' | 'starts_with' | 'ends_with';
+export declare const STRING_OPERATOR_LABELS: {
+    [key in StringFilterOperator]: string;
+};
+export declare function buildStringFilter(spec: SdkDashboardFilterSpecFragmentFragment, value: string, op: StringFilterOperator, values?: string[]): StringFilter;
+/**
+ * Build a `column = NULL` (equalsNull=true) or `column != NULL` (equalsNull=false) filter.
+ * Mirrors the frontend's "Null" / "≠ Null" radio rows in StringFilterForm.
+ */
+export declare function buildStringNullFilter(spec: SdkDashboardFilterSpecFragmentFragment, equalsNull: boolean): StringFilter;
+/** Seed a placeholder StringFilter for the fresh (no current filter) case. */
+export declare function buildStringFilterSeed(spec: SdkDashboardFilterSpecFragmentFragment): StringFilter;
+/** Seed a placeholder NumberFilter for the fresh (no current filter) case. */
+export declare function buildNumberFilter(spec: SdkDashboardFilterSpecFragmentFragment): NumberFilter;
+/**
+ * Static allowed values carried by an already-applied filter's column metadata.
+ * Returns [] for first-time enum specs (no current filter); the EnumFilterForm
+ * then relies solely on the dynamic literal fetch.
+ */
+export declare function allowedValuesFromSpec(spec: SdkDashboardFilterSpecFragmentFragment): string[];
+/** Seed a placeholder EnumFilter for the fresh (no current filter) case. */
+export declare function buildEnumFilterSeed(spec: SdkDashboardFilterSpecFragmentFragment, matchedColumn?: DomainFilterColumn): EnumFilter;
+/** Seed a placeholder BoolFilter for the fresh (no current filter) case. */
+export declare function buildBoolFilterSeed(spec: SdkDashboardFilterSpecFragmentFragment): BoolFilter;
+/** Seed a placeholder DateFilter for the fresh (no current filter) case. */
+export declare function buildDateFilterSeed(spec: SdkDashboardFilterSpecFragmentFragment): DateFilter;
+export type StringFilterMode = 'string' | 'null' | 'not_null';
+export interface StringFormState {
+    mode: StringFilterMode;
+    op: StringFilterOperator;
+    value: string;
+    values: string[];
+}
+export declare function initialStringFormState(filter: ParsedVisualizationFilter | null): StringFormState;
+export type EnumFilterMode = 'values' | 'null' | 'not_null';
+export interface EnumFormState {
+    mode: EnumFilterMode;
+    values: string[];
+}
+export declare function initialEnumFormState(filter: ParsedVisualizationFilter | null): EnumFormState;
+export interface BoolFormState {
+    values: boolean[];
+}
+export declare function initialBoolFormState(filter: ParsedVisualizationFilter | null): BoolFormState;
+export declare function formatFilterDisplayValue(filter: ParsedVisualizationFilter): string;

package/dist/dashboard/filterForms/columnInput.d.ts

@@ -0,0 +1,2 @@
+import { type DataframeColumnInput, type SdkDashboardFilterSpecFragmentFragment } from '../../generated/graphql/graphql';
+export declare function buildColumnInputFromSpec(spec: SdkDashboardFilterSpecFragmentFragment): DataframeColumnInput;

package/dist/dashboard/filterForms/dateLabels.d.ts

@@ -0,0 +1,7 @@
+export declare const dayLabel: (nextDate: string | undefined) => "Days" | "Day";
+export declare const weekLabel: (nextDate: string | undefined) => "Week" | "Weeks";
+export declare const monthLabel: (nextDate: string | undefined) => "Month" | "Months";
+export declare const quarterLabel: (nextDate: string | undefined) => "Quarter" | "Quarters";
+export declare const fiscalQuarterLabel: (nextDate: string | undefined) => "Fiscal Quarter" | "Fiscal Quarters";
+export declare const yearLabel: (nextDate: string | undefined) => "Year" | "Years";
+export declare const fiscalYearLabel: (nextDate: string | undefined) => "Fiscal Year" | "Fiscal Years";

package/dist/dashboard/filterForms/getGranularityOptions.d.ts

@@ -0,0 +1,5 @@
+import { type TimePeriodGranularity } from '@wisdomai/visualization/sdk-filters';
+export declare const getGranularityOptions: () => Array<{
+    value: TimePeriodGranularity;
+    label: string;
+}>;

package/dist/dashboard/filterForms/granularityLabels.d.ts

@@ -0,0 +1,2 @@
+import { type PreviousNextTimeGranularity } from '@wisdomai/visualization/sdk-filters';
+export declare const granularityLabels: Map<PreviousNextTimeGranularity, string>;

package/dist/dashboard/filterForms/useStringFilterSuggestions.d.ts

@@ -0,0 +1,14 @@
+import type { ColumnRefInput } from '../../generated/graphql/graphql';
+export interface UseStringFilterSuggestionsResult {
+    options: string[];
+    loading: boolean;
+}
+/**
+ * Mirrors the frontend's `usePossibleColumnLiterals`: fires a prefix-filtered query
+ * (when the user is typing) and a no-prefix browse-mode query in parallel, merges
+ * them with deduping + case-insensitive prefix matching.
+ *
+ * Without Apollo's cache the no-prefix fetch is held in component state for the
+ * lifetime of the form so that re-typing doesn't refetch it.
+ */
+export declare function useStringFilterSuggestions(columnRefs: ColumnRefInput[], prefix: string | undefined): UseStringFilterSuggestionsResult;

package/dist/dashboard/useDashboardFilters.d.ts

@@ -0,0 +1,23 @@
+import { type ParsedVisualizationFilter } from '@wisdomai/visualization/sdk-filters';
+import type { SdkDashboardFilterSpecFragmentFragment } from '../generated/graphql/graphql';
+import type { DomainFilterColumn } from '../resources/dashboards';
+export interface DashboardFilterEntry {
+    spec: SdkDashboardFilterSpecFragmentFragment;
+    /** The currently applied filter, parsed for editing. Null when no value is set. */
+    currentFilter: ParsedVisualizationFilter | null;
+    /** True while a server-side mutation for this filter is in flight. */
+    isActive: boolean;
+}
+export interface UseDashboardFiltersResult {
+    filters: DashboardFilterEntry[];
+    setFilterValue: (filterId: string, filter: ParsedVisualizationFilter | null) => Promise<void>;
+    /** True while any filter operation is in flight (cancel-and-restart means at most one at a time). */
+    isLoading: boolean;
+}
+export declare function parseCurrentFilter(spec: SdkDashboardFilterSpecFragmentFragment, matchedColumn?: DomainFilterColumn): ParsedVisualizationFilter | null;
+/**
+ * Headless hook for the dashboard's filters. Returns the current filter
+ * specs (with parsed current values, ready to clone+edit) and a
+ * setFilterValue mutator that opens a v2 update-filter-value subscription.
+ */
+export declare function useDashboardFilters(): UseDashboardFiltersResult;

package/dist/dashboard/useDashboardWidget.d.ts

@@ -0,0 +1,25 @@
+import type { SdkDashboardWidgetWithDataFragmentFragment } from '../generated/graphql/graphql';
+import { type WidgetStatus } from './widgetStore';
+export interface UseDashboardWidgetResult {
+    widget: SdkDashboardWidgetWithDataFragmentFragment | null;
+    status: WidgetStatus;
+    error: string | null;
+    /**
+     * Re-fetches the widget from offset 0 with a larger `limit`, replacing the
+     * cached visualization with the wider window. Resolves to the number of
+     * rows loaded after the attempt (unchanged on failure / abort / no-op), so
+     * callers can decide whether a target page is now reachable.
+     */
+    fetchMore: (nextLimit: number) => Promise<number>;
+}
+/**
+ * Headless hook for a single widget's reactive state. Owns the widget's
+ * data lifecycle: subscribes to the store, kicks off the per-widget
+ * `getWidgetData` query when the slot is cold, and aborts the in-flight
+ * query if the user activates a filter (the subscription becomes the
+ * authoritative writer at that point).
+ *
+ * Multiple call sites for the same `widgetId` share one fetch — the second
+ * mount sees `status === 'loading'` and just subscribes to the slot.
+ */
+export declare function useDashboardWidget(widgetId: string, dashboardIdProp?: string): UseDashboardWidgetResult;

package/dist/dashboard/useDashboardsList.d.ts

@@ -0,0 +1,21 @@
+import type { DashboardListItem } from '../resources/dashboards';
+export interface UseDashboardsListOptions {
+    workspaceID?: string;
+}
+export type UseDashboardsListResult = {
+    status: 'loading';
+    dashboards: null;
+    error: null;
+    refetch: () => Promise<void>;
+} | {
+    status: 'error';
+    dashboards: null;
+    error: Error;
+    refetch: () => Promise<void>;
+} | {
+    status: 'success';
+    dashboards: DashboardListItem[];
+    error: null;
+    refetch: () => Promise<void>;
+};
+export declare function useDashboardsList(options?: UseDashboardsListOptions): UseDashboardsListResult;

package/dist/dashboard/useSummaryWidget.d.ts

@@ -0,0 +1,25 @@
+export type SummaryStatus = 'empty' | 'cached' | 'streaming' | 'error' | 'unsupported';
+export interface UseSummaryWidgetResult {
+    summary: string;
+    status: SummaryStatus;
+    /** True while a fresh summary is being generated (drives auto-scroll). */
+    isStreaming: boolean;
+    /** Force a fresh generation, bypassing the cache. */
+    refresh: () => void;
+}
+/**
+ * Owns a summary widget's content lifecycle. Cache-first: renders the
+ * persisted `markdownContent` when present and unfiltered; otherwise streams a
+ * fresh summary from the `dashboardSummary` subscription and persists it.
+ *
+ * Filter-aware: while a filter is applied it regenerates against the dashboard
+ * version and never persists (the per-user cache slot is keyed only by widget,
+ * so persisting a filtered summary would poison the canonical one). Clearing
+ * the filter reverts to the canonical summary without regenerating. A refetch
+ * (or `refresh()`) forces regeneration to stay consistent with the charts.
+ *
+ * Anchors to the stable root `widgetId` and reads the widget from the preserved
+ * `dashboard.widgets` array — never the widget store slot, which filtering
+ * overwrites with versioned clone ids.
+ */
+export declare function useSummaryWidget(widgetId: string): UseSummaryWidgetResult;

package/dist/dashboard/widgetFilterStateAccessors.d.ts

@@ -0,0 +1,15 @@
+import { WidgetFilterStatus } from '../generated/graphql/graphql';
+export declare const EMPTY_WIDGET_FILTER_COLUMN_STATES_EXPLANATION = "No information found for the columns in this filter";
+interface WidgetFilterColumnStateLike {
+    status: WidgetFilterStatus;
+    explanationText?: string | null;
+    columnRef?: {
+        columnName?: string | null;
+    } | null;
+}
+interface WidgetFilterStateLike {
+    columnStates?: readonly WidgetFilterColumnStateLike[] | null;
+}
+export declare const getWidgetFilterStatus: (widgetFilterState: WidgetFilterStateLike | null | undefined) => WidgetFilterStatus;
+export declare const getWidgetFilterExplanationText: (widgetFilterState: WidgetFilterStateLike | null | undefined) => string | undefined;
+export {};

package/dist/dashboard/widgetStore.d.ts

@@ -0,0 +1,115 @@
+import { type SdkDashboardWidgetFragmentFragment, type SdkDashboardWidgetWithDataFragmentFragment } from '../generated/graphql/graphql';
+import type { WidgetData } from '../resources/dashboards';
+export type WidgetStatus = 'idle' | 'loading' | 'success' | 'error';
+/**
+ * Single source of truth for one widget. Seeded from `dashboard.widgets`
+ * (metadata only), filled by `getWidgetData` (adds visualization), replaced
+ * wholesale by filter-update subscription events (metadata + visualization).
+ *
+ * The metadata-only fragment is structurally assignable to the with-data
+ * fragment because `visualization` is optional on the latter.
+ */
+export interface WidgetSlot {
+    status: WidgetStatus;
+    widget: SdkDashboardWidgetWithDataFragmentFragment | null;
+    error: string | null;
+    subscribers: number;
+    fetchController: AbortController | null;
+}
+/**
+ * Per-widget reactive store. `useSyncExternalStore` consumers subscribe to a
+ * single widget's slice so unrelated widgets don't re-render. Subscriber
+ * refcounts are tracked separately from the listener registry — the refcount
+ * gates fetch dedup and abort-on-last-unmount.
+ */
+export declare class WidgetStore {
+    private slots;
+    private listeners;
+    private allListeners;
+    private lastRefreshedCache;
+    getEntry(widgetId: string): WidgetSlot;
+    /**
+     * Stable snapshot for `useSyncExternalStore`. The returned object identity
+     * is preserved across calls until either the widgets reference changes or
+     * any slot mutates, so React's bail-out skips downstream renders when
+     * nothing relevant changed.
+     */
+    getLastRefreshedSnapshot(widgets: readonly Pick<SdkDashboardWidgetFragmentFragment, 'id' | 'widgetType'>[]): LastRefreshedState;
+    /**
+     * Refreshes a widget's metadata in the store. If the slot already holds
+     * cached visualization data, the visualization is preserved while the
+     * fresh metadata fields (title, type, etc.) are merged in — so a
+     * `DashboardProvider` refetch never leaves stale metadata next to a
+     * cached chart.
+     */
+    seedWidget(widget: SdkDashboardWidgetFragmentFragment): void;
+    /**
+     * Marks a widget as loading. Used both by the per-widget fetch when it
+     * starts and by `setFilterValue` for all widgets affected by a filter.
+     */
+    markLoading(widgetIds: readonly string[]): void;
+    /**
+     * Writes per-widget query result. Merges visualization + dataError into
+     * the existing seeded metadata; preserves all other fields.
+     */
+    setWidgetFromQuery(widgetId: string, data: WidgetData): void;
+    /**
+     * Writes a subscription-pushed widget payload. Replaces the widget
+     * wholesale because the server-side filter mutation may have changed
+     * arbitrary metadata fields (visualizationType, dataRefreshedAt, etc.).
+     */
+    setWidgetFromSubscription(widgetId: string, widget: SdkDashboardWidgetWithDataFragmentFragment): void;
+    setWidgetError(widgetId: string, error: string): void;
+    /**
+     * Atomic reset + re-seed: drops all visualization data and error state and
+     * re-seeds slots with fresh metadata, emitting once per widget. Equivalent
+     * in net effect to `resetAll()` followed by a `seedWidget(widget)` loop,
+     * but avoids the intermediate empty-state render so the filter-mutation
+     * error path doesn't flicker. Subscriber counts are preserved for ids
+     * that survive the reset so mounted `useDashboardWidget` hooks keep their
+     * accounting.
+     */
+    resetToSeeded(widgets: readonly SdkDashboardWidgetFragmentFragment[]): void;
+    /**
+     * Invalidates cached widget data while preserving subscribers, listeners,
+     * and widget metadata. Used by `DashboardProvider.refetch()` so each
+     * mounted widget re-issues its `getWidgetData` query once the new dashboard
+     * payload lands — `useDashboardWidget` skips the fetch effect when a slot
+     * already has a `visualization`, so clearing it is what re-arms the fetch.
+     * Aborts any in-flight fetch before clearing so a late response cannot
+     * resolve through `setWidgetFromQuery` and overwrite the reset.
+     */
+    invalidateAllData(): void;
+    addSubscriber(widgetId: string): void;
+    /**
+     * Decrements subscriber count. If the slot drops to zero subscribers
+     * while a fetch is in-flight, the fetch is aborted (in-flight requests
+     * are wasted work; completed responses stay cached for the Provider's lifetime).
+     */
+    removeSubscriber(widgetId: string): void;
+    setFetchController(widgetId: string, controller: AbortController | null): void;
+    /**
+     * Aborts any in-flight per-widget fetch and resets the slot status to
+     * idle so the hook can retry once conditions change (e.g., the active
+     * filter mutation completes). Called on filter activation — the
+     * subscription becomes the authoritative writer for affected widgets,
+     * but unaffected widgets need a clean slate to re-fetch from afterward.
+     */
+    abortFetch(widgetId: string): void;
+    subscribe(widgetId: string, listener: () => void): () => void;
+    subscribeAll(listener: () => void): () => void;
+    private emit;
+}
+export interface LastRefreshedState {
+    lastRefreshedAt: Date | null;
+    allWidgetsReady: boolean;
+}
+/**
+ * Pure derivation of last-refreshed state for the header. Mirrors the
+ * frontend's `DashboardRefreshButton` filter (visualization widgets only)
+ * but reads readiness from the widget store's status rather than the
+ * presence of `widget.visualization`, so partial loads and refetches show
+ * "Refreshing…" consistently.
+ */
+export declare function selectLastRefreshedAt(store: WidgetStore, widgets: readonly Pick<SdkDashboardWidgetFragmentFragment, 'id' | 'widgetType'>[]): LastRefreshedState;
+export declare function useWidgetEntry(store: WidgetStore, widgetId: string): WidgetSlot;

package/dist/errors.d.ts

@@ -0,0 +1,16 @@
+export declare class WisdomError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+export declare class WisdomAuthError extends WisdomError {
+    constructor(message: string, cause?: unknown);
+}
+export declare class WisdomDashboardNotFoundError extends WisdomError {
+    readonly dashboardId: string;
+    constructor(dashboardId: string, cause?: unknown);
+}
+export declare class WisdomDashboardWidgetNotFoundError extends WisdomError {
+    readonly dashboardId: string;
+    readonly widgetId: string;
+    constructor(dashboardId: string, widgetId: string, cause?: unknown);
+}