react-semaphor 0.1.506 → 0.1.508

package/dist/types/data-app-sdk/contracts.d.ts

@@ -1,6 +1,6 @@
-import { MatrixSpec, MatrixWindowRequest, MatrixWindow, MatrixOperationRequest, MatrixExecutionResult, SemaphorAnalyticsFilter, SemaphorOptionDependencyOutcome, SemaphorOptionMatchResult, SemaphorAnalyticsExecutionResult, SemaphorAnalyticsExecutionStatus, SemaphorAnalyticsIntent, SemaphorAnalyticsValidationIssue, SemaphorAnalyticsValidationResult, SemaphorDerivedFieldDefinition, SemaphorFieldRef, SemaphorInputBinding, SemaphorInputOptionSource, SemaphorInputOperator, SemaphorMetricIntent, SemaphorRelationshipHint, SemaphorMatrixIntent, SemaphorOptionDependencies, SemaphorOptionPopulation, SemaphorPaginationMetadata, SemaphorPaginationRequest, SemaphorRecordsIntent, SemaphorResultColumn, SemaphorSqlIntent, SemaphorSourceRef, SemaphorTimeGrain, SemaphorTimeWindow } from '../shared/analytics-protocol/index.js';
+import { MatrixSpec, MatrixWindowRequest, MatrixWindow, MatrixOperationRequest, MatrixExecutionResult, AnalyticsSelection, AnalyticsSelectionTuple, SemaphorAnalyticsFilter, SemaphorOptionDependencyOutcome, SemaphorOptionMatchResult, SemaphorAnalyticsExecutionResult, SemaphorAnalyticsExecutionStatus, SemaphorAnalyticsIntent, SemaphorAnalyticsValidationIssue, SemaphorAnalyticsValidationResult, SemaphorDerivedFieldDefinition, SemaphorFieldRef, SemaphorInputBinding, SemaphorInputOptionSource, SemaphorInputOperator, SemaphorMetricIntent, SemaphorRelationshipHint, SemaphorMatrixIntent, SemaphorOptionDependencies, SemaphorOptionPopulation, SemaphorPaginationMetadata, SemaphorPaginationRequest, SemaphorRecordsIntent, SemaphorResultColumn, SemaphorSqlIntent, SemaphorSourceRef, SemaphorTimeGrain, SemaphorTimeWindow } from '../shared/analytics-protocol/index.js';
 import { CalendarContext } from '../lib/types/token-types.js';
-export type { SemaphorAnalyticsFilter, SemaphorDerivedFieldDefinition, SemaphorFieldRef, SemaphorInputBinding, SemaphorInputOptionSource, SemaphorInputOperator, SemaphorPaginationMetadata, SemaphorPaginationRequest, SemaphorOptionDependencies, SemaphorOptionPopulation, SemaphorResultColumn, SemaphorMatrixIntent, SemaphorSourceRef, SemaphorTimeWindow, } from '../shared/analytics-protocol/index.js';
+export type { AnalyticsSelection, AnalyticsSelectionCondition, AnalyticsSelectionTuple, SemaphorAnalyticsFilter, SemaphorDerivedFieldDefinition, SemaphorFieldRef, SemaphorInputBinding, SemaphorInputOptionSource, SemaphorInputOperator, SemaphorPaginationMetadata, SemaphorPaginationRequest, SemaphorOptionDependencies, SemaphorOptionPopulation, SemaphorResultColumn, SemaphorMatrixIntent, SemaphorSourceRef, SemaphorTimeWindow, } from '../shared/analytics-protocol/index.js';
 export type SemaphorScalar = string | number | boolean | null;
 export type SemaphorInputValue = SemaphorScalar | SemaphorScalar[];
 export type SemaphorOptionValue = string | number | boolean;
@@ -64,6 +64,45 @@ export type SemaphorInputHandle<TValue extends SemaphorInputValue = SemaphorInpu
     clear(): void;
     toAnalyticsInput(): SemaphorActiveInput<TValue>;
 };
+export type SemaphorSelectionBase = {
+    id: string;
+    label?: string;
+    multipleSelection?: boolean;
+    tuples?: AnalyticsSelectionTuple[];
+    defaultTuples?: AnalyticsSelectionTuple[];
+    onTuplesChange?: {
+        bivarianceHack(tuples: AnalyticsSelectionTuple[]): void;
+    }['bivarianceHack'];
+};
+export type SemaphorSelectionInputSpec = SemaphorSelectionBase & {
+    kind: 'selection';
+    fields: SemaphorQueryField[];
+};
+export type SemaphorSelectionGesture = {
+    kind: 'replace';
+} | {
+    kind: 'toggle';
+} | {
+    kind: 'range';
+    anchor: AnalyticsSelectionTuple;
+    ordered: AnalyticsSelectionTuple[];
+};
+export type SemaphorSelectionOutcome = 'selected' | 'added' | 'removed' | 'cleared' | 'rangeSelected' | 'limitReached';
+export type SemaphorSelectionHandle = {
+    id: string;
+    kind: 'selection';
+    label?: string;
+    fields: SemaphorQueryField[];
+    tuples: AnalyticsSelectionTuple[];
+    isActive: boolean;
+    select(tuple: AnalyticsSelectionTuple, gesture?: SemaphorSelectionGesture): {
+        tuples: AnalyticsSelectionTuple[];
+        outcome: SemaphorSelectionOutcome;
+    };
+    clear(): void;
+    toAnalyticsSelection(): AnalyticsSelection | undefined;
+};
+export type SemaphorSelectionReference = AnalyticsSelection | SemaphorSelectionHandle;
 export type SemaphorInputBindingReference<TValue extends SemaphorInputValue = SemaphorInputValue> = {
     toAnalyticsInput(): SemaphorActiveInput<TValue>;
 };
@@ -195,6 +234,7 @@ export type SemaphorDataAppDefinition = {
     title?: string;
     description?: string;
     inputs?: Record<string, SemaphorInputSpec> | SemaphorInputSpec[];
+    selections?: Record<string, SemaphorSelectionInputSpec> | SemaphorSelectionInputSpec[];
     queries?: Record<string, SemaphorQueryDefinition>;
     views: SemaphorDataAppViewDefinition[];
 };
@@ -230,6 +270,7 @@ export type SemaphorQueryDebugOptions = {
 };
 export type SemaphorQueryRuntimeOptions = {
     inputs?: SemaphorInputReference[];
+    selections?: SemaphorSelectionReference[];
     debug?: SemaphorQueryDebugOptions;
 };
 export type SemaphorQueryStatus = 'idle' | 'loading' | 'success' | 'error';
@@ -509,6 +550,7 @@ export type SemaphorQueryExecutorContext = {
     token?: string;
     apiBaseUrl?: string;
     activeInputs?: SemaphorActiveInput[];
+    selections?: AnalyticsSelection[];
     debug?: SemaphorDataAppDebugConfig;
 };
 export type SemaphorQueryExecutor = {

package/dist/types/data-app-sdk/index.d.ts

@@ -4,6 +4,7 @@ export type { SemaphorDevtoolsInspectButtonProps, SemaphorDevtoolsProps, } from
 export { createSemaphorQueryExecutor } from './executor.js';
 export { semaphorMetricAggregate, semaphorMetricMeasureBindingKey, } from '../shared/analytics-protocol/index.js';
 export { isSemaphorInputValueValidForOptions, useClearInvalidSemaphorInputValue, useSemaphorInput, useSemaphorInputs, useSemaphorQuery, } from './hooks.js';
+export { useSemaphorSelection } from './selection.js';
 export { SemaphorDataAppProvider } from './provider.js';
 export type * from './contracts.js';
 export type { SemaphorBindInputSpec, SemaphorControlBuilderSpec, SemaphorFieldBuilderSpec, SemaphorSemanticSourceBuilderSpec, SemaphorSqlParamInputSpec, SemaphorSqlSourceBuilderSpec, } from './builders.js';

package/dist/types/data-app-sdk/query-request.d.ts

@@ -1,14 +1,19 @@
-import { SemaphorAnalysisPayload, SemaphorAnalysisQueryOptions, SemaphorAnalysisQuerySpec, SemaphorDataAppQueryError, SemaphorInputOptionsPayload, SemaphorInputOptionsQuerySpec, SemaphorActiveInput, SemaphorMatrixPayload, SemaphorMatrixQuerySpec, SemaphorMetricPayload, SemaphorMetricQuerySpec, SemaphorRecordsQuerySpec, SemaphorRecordsPayload, SemaphorSqlPayload, SemaphorSqlQuerySpec } from './contracts.js';
-import { SemaphorAnalyticsExecutionResult, SemaphorAnalyticsIntent, SemaphorAnalyticsValidationIssue, SemaphorAnalyticsValidationResult, SemaphorMatrixIntent, SemaphorMetricIntent, SemaphorRecordsIntent, SemaphorSqlIntent, MatrixWindowRequest } from '../shared/analytics-protocol/index.js';
+import { SemaphorAnalysisPayload, SemaphorAnalysisQueryOptions, SemaphorAnalysisQuerySpec, SemaphorDataAppQueryError, SemaphorInputOptionsPayload, SemaphorInputOptionsQuerySpec, SemaphorActiveInput, SemaphorMatrixPayload, SemaphorMatrixQuerySpec, SemaphorMetricPayload, SemaphorMetricQuerySpec, SemaphorRecordsQuerySpec, SemaphorRecordsPayload, SemaphorSqlPayload, SemaphorSqlQuerySpec, SemaphorSelectionReference } from './contracts.js';
+import { SemaphorAnalyticsExecutionResult, AnalyticsSelection, SemaphorAnalyticsIntent, SemaphorAnalyticsValidationIssue, SemaphorAnalyticsValidationResult, SemaphorMatrixIntent, SemaphorMetricIntent, SemaphorRecordsIntent, SemaphorSqlIntent, MatrixWindowRequest } from '../shared/analytics-protocol/index.js';
 export type SemaphorQueryRequest<TIntent, TData> = {
     intent?: TIntent;
     error: SemaphorDataAppQueryError | null;
     activeInputs?: SemaphorActiveInput[];
+    selections?: AnalyticsSelection[];
     analysisOptions?: SemaphorAnalysisQueryOptions;
     matrixWindowRequest?: MatrixWindowRequest;
     queryKey: string;
     idleData: TData;
 };
+export declare function attachSemaphorSelectionsToRequest<TRequest extends {
+    queryKey: string;
+    selections?: AnalyticsSelection[];
+}>(request: TRequest, selections: SemaphorSelectionReference[] | undefined): TRequest;
 export declare function buildAnalysisRequest(spec: SemaphorAnalysisQuerySpec): SemaphorQueryRequest<SemaphorMetricIntent, SemaphorAnalysisPayload>;
 export declare function buildMetricRequest(spec: SemaphorMetricQuerySpec): SemaphorQueryRequest<SemaphorMetricIntent, SemaphorMetricPayload>;
 export declare function buildRecordsRequest<TRecord extends Record<string, unknown> = Record<string, unknown>>(spec: SemaphorRecordsQuerySpec): SemaphorQueryRequest<SemaphorRecordsIntent, SemaphorRecordsPayload<TRecord>>;

package/dist/types/data-app-sdk/selection.d.ts

@@ -0,0 +1,2 @@
+import { SemaphorSelectionHandle, SemaphorSelectionInputSpec } from './contracts.js';
+export declare function useSemaphorSelection(spec: SemaphorSelectionInputSpec): SemaphorSelectionHandle;

package/dist/types/index.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const l=require("../chunks/common-types-nBuCd3u2.cjs"),e=require("../chunks/validators-DVYAnnX0.cjs"),t=require("../chunks/field-dependencies-r_U0CGQ-.cjs"),a=require("../chunks/pivot-result-identity-uTiylUNr.cjs"),r=require("../chunks/report-runtime-context-DzvHBPxl.cjs");exports.CONTROL_CARD_DEFAULT_VALUE=l.CONTROL_CARD_DEFAULT_VALUE;exports.EMPTY_SELECTION=l.EMPTY_SELECTION;exports.CALCULATED_FIELD_ENTITY_MARKER=e.CALCULATED_FIELD_ENTITY_MARKER;exports.DATE_FORMAT_VALUES=e.DATE_FORMAT_VALUES;exports.LEGACY_CALCULATED_FIELD_ENTITY_MARKER=e.LEGACY_CALCULATED_FIELD_ENTITY_MARKER;exports.PivotMarkerEnum=e.PivotMarkerEnum;exports.getCalculatedFieldComputeStage=e.getCalculatedFieldComputeStage;exports.getFieldRuntimeColumnName=e.getFieldRuntimeColumnName;exports.hasCalculatedFieldMarker=e.hasCalculatedFieldMarker;exports.hasCalculatedFormulaInputs=e.hasCalculatedFormulaInputs;exports.hasSyntheticCalculatedFieldOwner=e.hasSyntheticCalculatedFieldOwner;exports.inspectCalculatedField=e.inspectCalculatedField;exports.isCalculatedDimension=e.isCalculatedDimension;exports.isCalculatedMetric=e.isCalculatedMetric;exports.isDerivedField=e.isDerivedField;exports.normalizeCalculatedFieldRepresentation=e.normalizeCalculatedFieldRepresentation;exports.shouldDropInheritedCalculationAggregate=e.shouldDropInheritedCalculationAggregate;exports.DEFAULT_SEMANTIC_DOMAIN_ACCESS=t.DEFAULT_SEMANTIC_DOMAIN_ACCESS;exports.collectDatasetNamesFromExplorerField=t.collectDatasetNamesFromExplorerField;exports.collectDatasetNamesFromFilterGroup=t.collectDatasetNamesFromFilterGroup;exports.collectExecutionDatasetNamesFromExplorerField=t.collectExecutionDatasetNamesFromExplorerField;exports.collectPreferredDatasetNamesFromExplorerField=t.collectPreferredDatasetNamesFromExplorerField;exports.collectQualifiedDatasetNamesFromExplorerField=t.collectQualifiedDatasetNamesFromExplorerField;exports.datasetRefFromSource=t.datasetRefFromSource;exports.dependencyDisplayIdentity=t.dependencyDisplayIdentity;exports.humanizeDatasetName=t.humanizeDatasetName;exports.resolveFieldDatasetDependencies=t.resolveFieldDatasetDependencies;exports.resolveQueryColumnKeyMapEntry=a.resolveQueryColumnKeyMapEntry;exports.resolveUniqueQueryColumnKeyMapEntry=a.resolveUniqueQueryColumnKeyMapEntry;exports.DEFAULT_CALENDAR_CONTEXT=r.DEFAULT_CALENDAR_CONTEXT;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const l=require("../chunks/common-types-nBuCd3u2.cjs"),e=require("../chunks/validators-DVYAnnX0.cjs"),t=require("../chunks/field-dependencies-DIab72rQ.cjs"),r=require("../chunks/token-types-Ahh5u4iT.cjs"),a=require("../chunks/pivot-result-identity-uTiylUNr.cjs"),i=require("../chunks/report-runtime-context-DzvHBPxl.cjs");exports.CONTROL_CARD_DEFAULT_VALUE=l.CONTROL_CARD_DEFAULT_VALUE;exports.EMPTY_SELECTION=l.EMPTY_SELECTION;exports.CALCULATED_FIELD_ENTITY_MARKER=e.CALCULATED_FIELD_ENTITY_MARKER;exports.DATE_FORMAT_VALUES=e.DATE_FORMAT_VALUES;exports.LEGACY_CALCULATED_FIELD_ENTITY_MARKER=e.LEGACY_CALCULATED_FIELD_ENTITY_MARKER;exports.PivotMarkerEnum=e.PivotMarkerEnum;exports.getCalculatedFieldComputeStage=e.getCalculatedFieldComputeStage;exports.getFieldRuntimeColumnName=e.getFieldRuntimeColumnName;exports.hasCalculatedFieldMarker=e.hasCalculatedFieldMarker;exports.hasCalculatedFormulaInputs=e.hasCalculatedFormulaInputs;exports.hasSyntheticCalculatedFieldOwner=e.hasSyntheticCalculatedFieldOwner;exports.inspectCalculatedField=e.inspectCalculatedField;exports.isCalculatedDimension=e.isCalculatedDimension;exports.isCalculatedMetric=e.isCalculatedMetric;exports.isDerivedField=e.isDerivedField;exports.normalizeCalculatedFieldRepresentation=e.normalizeCalculatedFieldRepresentation;exports.shouldDropInheritedCalculationAggregate=e.shouldDropInheritedCalculationAggregate;exports.collectDatasetNamesFromExplorerField=t.collectDatasetNamesFromExplorerField;exports.collectDatasetNamesFromFilterGroup=t.collectDatasetNamesFromFilterGroup;exports.collectExecutionDatasetNamesFromExplorerField=t.collectExecutionDatasetNamesFromExplorerField;exports.collectPreferredDatasetNamesFromExplorerField=t.collectPreferredDatasetNamesFromExplorerField;exports.collectQualifiedDatasetNamesFromExplorerField=t.collectQualifiedDatasetNamesFromExplorerField;exports.datasetRefFromSource=t.datasetRefFromSource;exports.dependencyDisplayIdentity=t.dependencyDisplayIdentity;exports.humanizeDatasetName=t.humanizeDatasetName;exports.resolveFieldDatasetDependencies=t.resolveFieldDatasetDependencies;exports.DEFAULT_SEMANTIC_DOMAIN_ACCESS=r.DEFAULT_SEMANTIC_DOMAIN_ACCESS;exports.resolveQueryColumnKeyMapEntry=a.resolveQueryColumnKeyMapEntry;exports.resolveUniqueQueryColumnKeyMapEntry=a.resolveUniqueQueryColumnKeyMapEntry;exports.DEFAULT_CALENDAR_CONTEXT=i.DEFAULT_CALENDAR_CONTEXT;

package/dist/types/index.js

@@ -1,37 +1,38 @@
-import { C as s, E as l } from "../chunks/common-types-C6cAQgyh.js";
-import { C as r, D as o, L as i, P as d, d as E, g as c, e as m, h as C, f as n, c as u, a as D, i as F, b as A, n as p, s as _ } from "../chunks/validators-BDYzZFgs.js";
-import { D as L, c as N, g as M, f as R, b as f, e as x, d as y, a as I, h, r as g } from "../chunks/field-dependencies-DVl2p1Nm.js";
-import { r as U, a as O } from "../chunks/pivot-result-identity-BSudrDLN.js";
-import { D as K } from "../chunks/report-runtime-context-DWvUf1HT.js";
+import { C as s, E as t } from "../chunks/common-types-C6cAQgyh.js";
+import { C as r, D as o, L as i, P as d, d as E, g as m, e as c, h as C, f as n, c as u, a as D, i as F, b as p, n as A, s as _ } from "../chunks/validators-BDYzZFgs.js";
+import { c as L, g as N, f, b as x, e as M, d as R, a as y, h as I, r as h } from "../chunks/field-dependencies-Cl97kkHy.js";
+import { D as S } from "../chunks/token-types-CPde8_LG.js";
+import { r as O, a as v } from "../chunks/pivot-result-identity-BSudrDLN.js";
+import { D as P } from "../chunks/report-runtime-context-DWvUf1HT.js";
 export {
   r as CALCULATED_FIELD_ENTITY_MARKER,
   s as CONTROL_CARD_DEFAULT_VALUE,
   o as DATE_FORMAT_VALUES,
-  K as DEFAULT_CALENDAR_CONTEXT,
-  L as DEFAULT_SEMANTIC_DOMAIN_ACCESS,
-  l as EMPTY_SELECTION,
+  P as DEFAULT_CALENDAR_CONTEXT,
+  S as DEFAULT_SEMANTIC_DOMAIN_ACCESS,
+  t as EMPTY_SELECTION,
   i as LEGACY_CALCULATED_FIELD_ENTITY_MARKER,
   d as PivotMarkerEnum,
-  N as collectDatasetNamesFromExplorerField,
-  M as collectDatasetNamesFromFilterGroup,
-  R as collectExecutionDatasetNamesFromExplorerField,
-  f as collectPreferredDatasetNamesFromExplorerField,
-  x as collectQualifiedDatasetNamesFromExplorerField,
-  y as datasetRefFromSource,
-  I as dependencyDisplayIdentity,
+  L as collectDatasetNamesFromExplorerField,
+  N as collectDatasetNamesFromFilterGroup,
+  f as collectExecutionDatasetNamesFromExplorerField,
+  x as collectPreferredDatasetNamesFromExplorerField,
+  M as collectQualifiedDatasetNamesFromExplorerField,
+  R as datasetRefFromSource,
+  y as dependencyDisplayIdentity,
   E as getCalculatedFieldComputeStage,
-  c as getFieldRuntimeColumnName,
-  m as hasCalculatedFieldMarker,
+  m as getFieldRuntimeColumnName,
+  c as hasCalculatedFieldMarker,
   C as hasCalculatedFormulaInputs,
   n as hasSyntheticCalculatedFieldOwner,
-  h as humanizeDatasetName,
+  I as humanizeDatasetName,
   u as inspectCalculatedField,
   D as isCalculatedDimension,
   F as isCalculatedMetric,
-  A as isDerivedField,
-  p as normalizeCalculatedFieldRepresentation,
-  g as resolveFieldDatasetDependencies,
-  U as resolveQueryColumnKeyMapEntry,
-  O as resolveUniqueQueryColumnKeyMapEntry,
+  p as isDerivedField,
+  A as normalizeCalculatedFieldRepresentation,
+  h as resolveFieldDatasetDependencies,
+  O as resolveQueryColumnKeyMapEntry,
+  v as resolveUniqueQueryColumnKeyMapEntry,
   _ as shouldDropInheritedCalculationAggregate
 };

package/dist/types/lib/appearance/types.d.ts

@@ -2,7 +2,9 @@ export declare const APPEARANCE_SPEC_VERSION: 1;
 export type AppearanceMode = 'light' | 'dark' | 'system';
 export type ResolvedAppearanceMode = 'light' | 'dark';
 export type AppearanceDensity = 'compact' | 'comfortable' | 'spacious';
-export type AppearanceColorToken = 'background' | 'foreground' | 'muted' | 'mutedForeground' | 'border' | 'input' | 'primary' | 'primaryForeground' | 'accent' | 'accentForeground' | 'card' | 'cardForeground' | 'positive' | 'negative' | 'warning' | 'info' | 'destructive' | 'destructiveForeground';
+export type AppearanceColorToken = 'background' | 'foreground' | 'muted' | 'mutedForeground' | 'border' | 'input' | 'primary' | 'primaryForeground' | 'accent' | 'accentForeground'
+/** What a viewer selected to filter by: table rows, matrix cells. */
+ | 'selection' | 'card' | 'cardForeground' | 'positive' | 'negative' | 'warning' | 'info' | 'destructive' | 'destructiveForeground';
 export type AppearanceColorTokens = Partial<Record<AppearanceColorToken, string>>;
 export type AppearanceTokens = {
     color?: AppearanceColorTokens;

package/dist/types/lib/briefings/briefing-attachment-model.d.ts

@@ -2,7 +2,6 @@ import { BriefingAttachment, BriefingAttachmentFormat, BriefingAttachmentSetting
 import { ControlBinding, ControlDefinition, DashboardInputValues, TDashboard } from '../types/common-types.js';
 import { TFilter, TFilterValue } from '../../components/surfboard/filter/types.js';
 import { SemanticExecutionPayload } from '../types/semantic-runtime-types.js';
-import { InteractionStateMap } from '../query-context/build-card-query-context.js';
 import { MatrixConfig } from '../../shared/analytics-protocol/index.js';
 import { MatrixCardCatalog } from '../matrix-table/matrix-card-adapter.js';
 export type BriefingAttachmentOptionKind = 'dashboard' | 'dashboard_sheet' | 'document_sheet' | 'card';
@@ -39,7 +38,6 @@ export type BriefingAttachmentRuntimeInput = {
     dashboardControls?: ControlDefinition[];
     dashboardInputValues?: DashboardInputValues;
     semanticExecutionPayload?: SemanticExecutionPayload;
-    interactionStates?: InteractionStateMap;
     timezone?: string;
 };
 export type BriefingAttachmentBuildResult = {

package/dist/types/lib/contexts/interactions-popover-context.d.ts

@@ -3,14 +3,7 @@ type InteractionsPopoverContextType = {
     open: boolean;
     frameId: string | null;
     cardId: string | null;
-    triggerElement: HTMLElement | null;
-    anchorPosition: {
-        left: number;
-        top: number;
-        width: number;
-        height: number;
-    } | null;
-    openPopover: (frameId: string, cardId: string, triggerElement: HTMLElement) => void;
+    openPopover: (frameId: string, cardId: string) => void;
     closePopover: () => void;
 };
 declare const InteractionsPopoverContext: import('react').Context<InteractionsPopoverContextType>;

package/dist/types/lib/dashboard/click-to-filter-card-references.d.ts

@@ -0,0 +1,23 @@
+import { DashboardInputValues, TCard, TDashboard } from '../types/common-types.js';
+type Target = {
+    dashboard: Pick<TDashboard, 'sheets' | 'defaultInputValues'>;
+    dashboardInputValues: DashboardInputValues;
+};
+/**
+ * Rewrites every click-to-filter reference a card holds. Mutates the card, so
+ * it works on a store draft and on a fresh clone alike. The walkers are the
+ * shared ones; this only says which members of a card carry card ids.
+ */
+export declare function remapCardClickToFilterReferences(card: TCard, cardIds: Map<string, string>): void;
+/**
+ * A card's id changed (renamed, or a document section's card replaced). Every
+ * other card that names it keeps reaching it, and a live selection it holds
+ * moves with it. Without this the save succeeds and filtering silently stops.
+ */
+export declare function retargetClickToFilterCardId(target: Target, previousCardId: string, nextCardId: string): void;
+/**
+ * Cards were deleted. The cards that remain stop naming them, and a selection
+ * a deleted card held goes with it, so no dangling id is ever saved from here.
+ */
+export declare function removeClickToFilterCardReferences(target: Target, removedCardIds: Set<string>): void;
+export {};

package/dist/types/lib/dashboard-inputs/build-normalized-dashboard-inputs.d.ts

@@ -1,20 +1,34 @@
 import { DashboardInputValues, NormalizedDashboardInput, TCard, TDashboard } from '../types/common-types.js';
+import { TransientInputContext } from './transient-input-context.js';
 export type BuildNormalizedDashboardInputsInput = {
     dashboard: Pick<TDashboard, 'inputs' | 'filters' | 'controls' | 'sheets'>;
     card?: TCard | null;
     availableSheetIds?: string[];
     availableCardIds?: string[];
+    /**
+     * Carried definitions for a runtime resolution. Authoring callers leave it
+     * out: a carried definition is never part of the dashboard being edited.
+     */
+    transientContexts?: readonly TransientInputContext[];
 };
 export type BuildNormalizedDashboardInputsOutput = {
     authoredInputs: NormalizedDashboardInput[];
     compatibilityInputs: NormalizedDashboardInput[];
+    /** Carried definitions, already normalized and self-contained. */
+    transientInputs: NormalizedDashboardInput[];
     allInputs: NormalizedDashboardInput[];
 };
-export declare function requiresDashboardInputResolution({ dashboard, dashboardInputValues, }: {
+export declare function requiresDashboardInputResolution({ dashboard, dashboardInputValues, transientContexts, }: {
     dashboard: Pick<TDashboard, 'inputs' | 'filters' | 'controls' | 'defaultInputValues'>;
     dashboardInputValues?: DashboardInputValues;
+    /**
+     * Carried definitions are inputs of this resolution too, so a dashboard with
+     * no inputs of its own still has to resolve them. Required so that every
+     * caller decides.
+     */
+    transientContexts: readonly TransientInputContext[] | undefined;
 }): boolean;
-export declare function buildNormalizedDashboardInputs({ dashboard, card, availableSheetIds, availableCardIds, }: BuildNormalizedDashboardInputsInput): BuildNormalizedDashboardInputsOutput;
+export declare function buildNormalizedDashboardInputs({ dashboard, card, availableSheetIds, availableCardIds, transientContexts, }: BuildNormalizedDashboardInputsInput): BuildNormalizedDashboardInputsOutput;
 /** An Input the tolerant normalization rejected, kept identifiable. */
 export type RejectedDashboardInput = {
     inputId: string;

package/dist/types/lib/dashboard-inputs/build-selection-dashboard-inputs.d.ts

@@ -0,0 +1,31 @@
+import { SelectionInputValue } from '../../shared/analytics-protocol/selection-contract.js';
+import { DashboardInputValues, SelectionDashboardInput, TCard, TDashboard } from '../types/common-types.js';
+type SelectionDashboard = Pick<TDashboard, 'sheets' | 'interactionDefaults'>;
+/** Every selection lives in the shared slot map: it is dashboard-wide and survives sheet switches. */
+export declare const SELECTION_RUNTIME_TARGET: {};
+/** The slot address of a source card's selection. */
+export declare function selectionSlotAddress(sourceCardId: string): Pick<SelectionDashboardInput, 'id' | 'runtimeScope'>;
+/**
+ * The selection input of one source card, or undefined when click to filter is
+ * off for it. Settings come from the normalizer, so a legacy cross-filter
+ * interaction yields the same input an authored `clickToFilter` would.
+ */
+export declare function buildSelectionDashboardInput(card: TCard, dashboard: Pick<TDashboard, 'interactionDefaults' | 'sheets'>): SelectionDashboardInput | undefined;
+/** A set, schema-valid selection value, or undefined. A malformed slot is ignored, never thrown on. */
+export declare function readSelectionValue(values: DashboardInputValues | undefined, sourceCardId: string): SelectionInputValue | undefined;
+export type ActiveSelection = {
+    input: SelectionDashboardInput;
+    value: SelectionInputValue;
+    sourceCard: TCard;
+};
+/**
+ * The selections currently in effect, in slot order. Driven by the values, not
+ * by the cards: a dashboard pays nothing for cards nobody has clicked. A slot
+ * whose source card is gone, or whose card no longer has click to filter on,
+ * is not in effect.
+ */
+export declare function listActiveSelections(params: {
+    dashboard: SelectionDashboard;
+    dashboardInputValues: DashboardInputValues | undefined;
+}): ActiveSelection[];
+export {};

package/dist/types/lib/dashboard-inputs/click-to-filter-emitted-fields.d.ts

@@ -0,0 +1,17 @@
+import { SelectionField } from '../../shared/analytics-protocol/selection-contract.js';
+import { ClickToFilterFieldsRule, DashboardCardFilterSourceInventory } from '../../shared/dashboard-authoring/index.js';
+import { Field } from '../types/explorer-types.js';
+export type ClickToFilterDimension = {
+    key: string;
+    field: SelectionField;
+    /** The authored field, for its label. */
+    authored: Field;
+};
+/**
+ * The dimension fields of a card that a click can carry, grounded the same way
+ * a click grounds them. A calculated field or one with no data type is left
+ * out here exactly as it is left out of a tuple.
+ */
+export declare function clickToFilterDimensions(dimensions: Field[], sourceIndex: DashboardCardFilterSourceInventory): ClickToFilterDimension[];
+/** The fields the rule lets a click carry. Whole row and clicked cell can carry any dimension. */
+export declare function clickToFilterEmittedFields(dimensions: ClickToFilterDimension[], rule: ClickToFilterFieldsRule): SelectionField[];

package/dist/types/lib/dashboard-inputs/click-to-filter-mapping-draft.d.ts

@@ -0,0 +1,99 @@
+import { SelectionField } from '../../shared/analytics-protocol/selection-contract.js';
+import { ClickToFilterCardMapping, ClickToFilterSettings } from '../../shared/dashboard-authoring/index.js';
+import { NormalizedFilterDashboardInput, TCard, TDashboard } from '../types/common-types.js';
+import { DashboardFilterMappingCandidateCatalog, DashboardFilterMappingDraftRow } from './dashboard-filter-mapping-authoring.js';
+/** Why a card gets nothing from this source, decided before any field is looked at. */
+export type ClickToFilterDraftCardState = 'listening'
+/** An 'excluded' card mapping: the author chose "Don't apply to this card". */
+ | 'excluded'
+/** `card.respondsToSelections === false`, set on the target card itself. */
+ | 'receiverOptedOut'
+/** `settings.targets` does not reach the card. */
+ | 'outsideTargets'
+/** SQL and unconfigured cards: a selection compiles to card filter conditions, which only config cards execute. */
+ | 'notSupported';
+export type ClickToFilterMappingDraftRow = {
+    /** Target card. */
+    cardId: string;
+    clickedFieldKey: string;
+    clickedField: SelectionField;
+    /** The toolbar filter's row type, unchanged, so `MappingRow` renders it. */
+    row: DashboardFilterMappingDraftRow;
+    /**
+     * Set when the card has fields to choose from but none the click matches.
+     * The click drops this field here, which is ordinary and needs no decision;
+     * `row.status` is 'excluded' so the row reads "Not applied" and stays choosable.
+     */
+    unmapped?: true;
+    /** Shows "Same as <filter> filter". A borrowed binding is never persisted here. */
+    provenanceHint?: 'borrowedFromFilter';
+    borrowedFromInputId?: string;
+};
+export type ClickToFilterMappingDraftCard = {
+    cardId: string;
+    cardTitle: string;
+    cardType: TCard['type'];
+    sheetId: string;
+    state: ClickToFilterDraftCardState;
+    /** One per emitted field. Empty unless the card is listening or excluded. */
+    rows: ClickToFilterMappingDraftRow[];
+    /** A suggestion to accept, an ambiguous match, or a mapping that went stale. */
+    needsReview: boolean;
+};
+export type ClickToFilterMappingDraft = {
+    sourceCardId: string;
+    /** Cards that need review first, then dashboard order. */
+    cards: ClickToFilterMappingDraftCard[];
+    rows: ClickToFilterMappingDraftRow[];
+    /** Per target card. */
+    counts: {
+        /** At least one clicked field applies. */
+        covered: number;
+        toReview: number;
+        /** Listening, but no clicked field applies. */
+        skipped: number;
+        /** Excluded by the author, opted out, outside the targets, or not supported. */
+        notApplied: number;
+    };
+};
+/**
+ * What one source card's clicks do on every other card, as review rows. It
+ * reads the same settings the runtime resolver reads, in the same order, so
+ * the dialog never promises a match a click will not make.
+ */
+export declare function buildClickToFilterMappingDraft(params: {
+    sourceCard: Pick<TCard, 'id'>;
+    settings: ClickToFilterSettings;
+    dashboard: Pick<TDashboard, 'sheets'>;
+    /** Fields a click on the source card can carry under its fields rule. */
+    emittedFields: SelectionField[];
+    candidatesByCardId: Record<string, DashboardFilterMappingCandidateCatalog | undefined>;
+    /** Toolbar filters, for borrowed bindings. */
+    filterInputs: NormalizedFilterDashboardInput[];
+}): ClickToFilterMappingDraft;
+export type ClickToFilterMappingDraftIssue = {
+    cardId: string;
+    clickedFieldKey: string;
+    message: string;
+};
+/**
+ * Mirrors `acceptDashboardFilterMappingDraft`: fails while any row of a
+ * listening card is ambiguous, has no metadata, or holds a stale mapping. The
+ * result is sparse: automatic, suggested and borrowed rows write nothing.
+ */
+export declare function acceptClickToFilterMappingDraft(params: {
+    draft: ClickToFilterMappingDraft;
+    settings: ClickToFilterSettings;
+}): {
+    ok: true;
+    cardMappings: ClickToFilterCardMapping[];
+} | {
+    ok: false;
+    issues: ClickToFilterMappingDraftIssue[];
+};
+/** Binds one clicked field on one card. Choosing a field re-includes an excluded card. */
+export declare function bindClickToFilterField(settings: ClickToFilterSettings, binding: Extract<ClickToFilterCardMapping, {
+    kind: 'bound';
+}>): ClickToFilterSettings;
+/** "Don't apply to this card". Bindings are kept, so re-including restores them. */
+export declare function setClickToFilterCardExcluded(settings: ClickToFilterSettings, cardId: string, excluded: boolean): ClickToFilterSettings;

package/dist/types/lib/dashboard-inputs/click-to-filter-sheet-reach.d.ts

@@ -0,0 +1,12 @@
+import { DashboardInputScope, TDashboard } from '../types/common-types.js';
+/**
+ * A click filters cards on its own sheet, and only those. This is a product
+ * rule, not a saved setting: `settings.targets` keeps whatever the author or a
+ * legacy entry stored, and is narrowed here on the way to every reader (the
+ * runtime input and the authoring draft), so lifting the rule later is a change
+ * to this one function.
+ *
+ * A source card that is not on the dashboard (an editor preview) has no sheet
+ * to narrow to, and its targets are returned as they are.
+ */
+export declare function restrictClickToFilterTargetsToSourceSheet(targets: DashboardInputScope, sourceCardId: string, dashboard: Pick<TDashboard, 'sheets'>): DashboardInputScope;

package/dist/types/lib/dashboard-inputs/dashboard-filter-mapping-authoring.d.ts

@@ -1,6 +1,6 @@
 import { TFilter } from '../../components/surfboard/filter/types.js';
 import { DashboardInputScope, ReferencedFilterDashboardInput, TDashboard } from '../types/common-types.js';
-import { DashboardFilterCardApplication, DashboardFilterOptionSource, DashboardFilterTarget, DashboardFilterTargetField } from '../../shared/dashboard-authoring/index.js';
+import { buildDashboardCardSourceIndex, DashboardFilterCardApplication, DashboardFilterOptionSource, DashboardFilterTarget, DashboardFilterTargetField } from '../../shared/dashboard-authoring/index.js';
 import { DashboardFilterOptionPolicy } from './dashboard-filter-mapping-storage-transition.js';
 export type DashboardFilterMappingCandidateCatalog = {
     status: 'ready';
@@ -116,6 +116,23 @@ export declare function buildDashboardFilterMappingOuterScope(params: {
     filter: Pick<TFilter, 'sheetId' | 'applyToSheetIds' | 'excludeSheetIds'>;
     dashboard: Pick<TDashboard, 'sheets'>;
 }): DashboardFilterMappingDraft['outerScope'];
+/**
+ * One Cards row for a source-qualified value field that is not a toolbar
+ * filter, such as a field a click carries. It is the same decision chain the
+ * toolbar filter's rows go through (`rowFromCandidates`), so automatic,
+ * suggested, mapped, excluded and needs-mapping mean the same thing on every
+ * authoring surface. Equality is the only operation a click applies.
+ */
+export declare function buildDashboardFilterMappingDraftRowForValueField(params: {
+    card: Parameters<typeof buildDashboardCardSourceIndex>[0];
+    sheetId: string;
+    valueField: DashboardFilterTargetField;
+    catalog: DashboardFilterMappingCandidateCatalog | undefined;
+    decision?: DashboardFilterMappingDraftDecision;
+    persistedApplication?: DashboardFilterCardApplication;
+    /** Bindings already accepted elsewhere for this value field, offered as inherited matches. */
+    acceptedTargets?: DashboardFilterTarget[];
+}): DashboardFilterMappingDraftRow;
 /** The reference-backed Input for a dashboard filter, mapped or not. */
 export declare function findReferencedDashboardFilterInput(dashboard: Pick<TDashboard, 'inputs'>, filterId: string): ReferencedFilterDashboardInput | undefined;
 export declare function acceptDashboardFilterInputDraft(params: {

package/dist/types/lib/dashboard-inputs/dashboard-filter-mapping-candidate-metadata.d.ts

@@ -58,7 +58,9 @@ type DashboardFilterMappingOuterScope = Extract<DashboardInputScope, {
  */
 export declare function dashboardFilterMappingSourceRequestKey(source: DashboardFilterTargetSource): string;
 export declare function resolveDashboardFilterMappingColumnsRequest(source: DashboardFilterTargetSource, capabilities?: Pick<SemaphorConnectionCapabilities, 'prefixLevels'>): DashboardFilterMappingColumnsRequestResolution;
-export declare function collectDashboardFilterMappingSourceRequests(dashboard: Pick<TDashboard, 'sheets'>, outerScope?: DashboardFilterMappingOuterScope, capabilitiesByConnectionId?: ReadonlyMap<string, Pick<SemaphorConnectionCapabilities, 'prefixLevels'>>): DashboardFilterMappingSourceRequest[];
+export declare function collectDashboardFilterMappingSourceRequests(dashboard: Pick<TDashboard, 'sheets'>, outerScope?: DashboardFilterMappingOuterScope, capabilitiesByConnectionId?: ReadonlyMap<string, Pick<SemaphorConnectionCapabilities, 'prefixLevels'>>, options?: {
+    includeDocumentSections?: boolean;
+}): DashboardFilterMappingSourceRequest[];
 /**
  * Builds the label lookup from live column metadata. A field label is
  * recorded only when it differs from the column name. Semantic columns also
@@ -99,6 +101,7 @@ export declare function toMappingDisplayField(labels: DashboardFilterMappingFiel
 export declare function buildDashboardFilterMappingCandidateCatalogs(params: {
     dashboard: Pick<TDashboard, 'sheets'>;
     outerScope?: DashboardFilterMappingOuterScope;
+    includeDocumentSections?: boolean;
     metadataBySourceKey: ReadonlyMap<string, DashboardFilterMappingSourceMetadata>;
 }): Record<string, DashboardFilterMappingCandidateCatalog | undefined>;
 export {};

package/dist/types/lib/dashboard-inputs/dashboard-input-scope.d.ts

@@ -0,0 +1,10 @@
+import { DashboardInputBase } from '../types/common-types.js';
+import { DashboardInputRuntimeTarget } from './dashboard-input-values.js';
+export type ScopedDashboardInputTarget = DashboardInputRuntimeTarget & {
+    sheetKind?: 'dashboard' | 'document';
+};
+/**
+ * The one interpreter of `DashboardInputScope`. Filters, controls, and
+ * click-to-filter targets all decide "does this reach that card" here.
+ */
+export declare function doesDashboardInputApplyToTarget(input: Pick<DashboardInputBase, 'scope' | 'compatibility'>, target: ScopedDashboardInputTarget): boolean;

package/dist/types/lib/dashboard-inputs/dashboard-input-snapshot.d.ts

@@ -1,6 +1,7 @@
 import { DashboardInputExecutionSnapshot, DashboardInputValues, NormalizedDashboardInput, ResolvedDashboardInputContext, TCard, TDashboard } from '../types/common-types.js';
 import { TFilterValue } from '../../components/surfboard/filter/types.js';
 import { DashboardInputRuntimeValues } from './resolve-dashboard-input-context.js';
+import { TransientInputContext } from './transient-input-context.js';
 /**
  * Converts replacement snapshot semantics into self-describing slots at the
  * ingestion seam. Consumers can then resolve every slot with one precedence
@@ -20,6 +21,12 @@ export type BuildDashboardInputExecutionSnapshotParams = {
     sheetKind?: 'dashboard' | 'document';
     mode: DashboardInputExecutionSnapshot['mode'];
     runtimeValues: DashboardInputRuntimeValues;
+    /**
+     * The carried contexts in effect on the dashboard being captured. Required
+     * so that every caller decides: an export of a dashboard a viewer drilled
+     * through to has to replay what was carried there.
+     */
+    transientContexts: readonly TransientInputContext[] | undefined;
     generatedAt?: string;
     timezone?: string;
 };
@@ -45,7 +52,7 @@ export type BuildDashboardSheetsInputExecutionSnapshotParams = Omit<BuildDashboa
     sheetIds: string[];
     sheetKind?: 'dashboard' | 'document';
 };
-export declare function buildDashboardInputExecutionSnapshot({ dashboard, sheetId, card, sectionId, sheetKind, mode, runtimeValues, generatedAt, timezone, }: BuildDashboardInputExecutionSnapshotParams): BuildDashboardInputExecutionSnapshotResult;
+export declare function buildDashboardInputExecutionSnapshot({ dashboard, sheetId, card, sectionId, sheetKind, mode, runtimeValues, transientContexts, generatedAt, timezone, }: BuildDashboardInputExecutionSnapshotParams): BuildDashboardInputExecutionSnapshotResult;
 export declare function getDocumentDashboardInputMissingRequiredLabels({ sectionIds, ...params }: BuildDocumentDashboardInputExecutionSnapshotParams): string[];
 export declare function buildDashboardSheetsInputExecutionSnapshot({ sheetIds, sheetKind, ...params }: BuildDashboardSheetsInputExecutionSnapshotParams): BuildDashboardInputExecutionSnapshotResult;
 export declare function buildDocumentDashboardInputExecutionSnapshot({ sectionIds, ...params }: BuildDocumentDashboardInputExecutionSnapshotParams): BuildDashboardInputExecutionSnapshotResult;

package/dist/types/lib/dashboard-inputs/index.d.ts

@@ -9,3 +9,4 @@ export * from './dashboard-input-text.js';
 export * from './dashboard-input-values.js';
 export * from './document-input-prototype-normalizer.js';
 export * from './resolve-dashboard-input-context.js';
+export * from './transient-input-context.js';

package/dist/types/lib/dashboard-inputs/resolve-dashboard-input-context.d.ts

@@ -1,6 +1,10 @@
+import { CardViewStateMap } from '../dashboard-view-state/index.js';
 import { TFilterValue } from '../../components/surfboard/filter/types.js';
-import { DashboardInputBase, DashboardInputValues, NormalizedDashboardInput, ResolvedDashboardInput, ResolvedDashboardInputContext, TCard, TDashboard } from '../types/common-types.js';
+import { DashboardInputValues, NormalizedDashboardInput, ResolvedDashboardInput, ResolvedDashboardInputContext, TCard, TDashboard } from '../types/common-types.js';
 import { DashboardInputRuntimeTarget } from './dashboard-input-values.js';
+import { doesDashboardInputApplyToTarget } from './dashboard-input-scope.js';
+import { TransientInputContext } from './transient-input-context.js';
+export { doesDashboardInputApplyToTarget };
 export type DashboardInputResolveMode = 'interactive' | 'editor' | 'print' | 'schedule' | 'export';
 export type DashboardInputRuntimeValues = {
     dashboardInputValues?: DashboardInputValues;
@@ -8,6 +12,11 @@ export type DashboardInputRuntimeValues = {
     controlValues?: Record<string, unknown>;
     inlineFilterValuesMap?: Record<string, TFilterValue[] | undefined>;
     cardControlValuesMap?: Record<string, Record<string, unknown>>;
+    /**
+     * Drill paths by card. Input resolution never reads them; an execution
+     * snapshot built from these runtime values carries them.
+     */
+    cardViewState?: CardViewStateMap;
 };
 export type ResolveDashboardInputContextInput = {
     dashboard: TDashboard;
@@ -16,20 +25,23 @@ export type ResolveDashboardInputContextInput = {
     sectionId?: string | null;
     sheetKind?: 'dashboard' | 'document';
     runtimeValues: DashboardInputRuntimeValues;
+    /**
+     * State carried into this dashboard by a drill-through, or into an insight:
+     * definitions and values together, resolved like authored inputs. Required
+     * so that every caller decides; a caller that leaves carried state out
+     * would show or query the destination without what the viewer drilled on.
+     */
+    transientContexts: readonly TransientInputContext[] | undefined;
     mode?: DashboardInputResolveMode;
     timezone?: string;
 };
-type ScopedDashboardInputTarget = DashboardInputRuntimeTarget & {
-    sheetKind?: 'dashboard' | 'document';
-};
-export declare function resolveDashboardInputContext({ dashboard, sheetId, card, sectionId, sheetKind, runtimeValues, mode, timezone, }: ResolveDashboardInputContextInput): ResolvedDashboardInputContext;
+export declare function resolveDashboardInputContext({ dashboard, sheetId, card, sectionId, sheetKind, runtimeValues: authoredRuntimeValues, transientContexts, mode, timezone, }: ResolveDashboardInputContextInput): ResolvedDashboardInputContext;
 /**
  * The Global Date rule: exactly one Global Date input may exist. Returns every
  * Global Date input after the first, in order. The strict resolver fails on
  * any conflict; the tolerant option context excludes the conflicts.
  */
 export declare function findGlobalDateInputConflicts(inputs: NormalizedDashboardInput[]): NormalizedDashboardInput[];
-export declare function doesDashboardInputApplyToTarget(input: Pick<DashboardInputBase, 'scope' | 'compatibility'>, target: ScopedDashboardInputTarget): boolean;
 export declare function removeShadowedCompatibilityInputs(inputs: NormalizedDashboardInput[]): NormalizedDashboardInput[];
 export declare function resolveDashboardInput(params: {
     dashboard: TDashboard;
@@ -54,4 +66,3 @@ export declare function findScopedAuthoredAliasConflicts(inputs: NormalizedDashb
     input: NormalizedDashboardInput;
     previousInputId: string;
 }>;
-export {};