react-semaphor 0.1.372 → 0.1.374

package/dist/types/types.d.ts

@@ -654,6 +654,28 @@ export declare type CancelBriefingRunResponse = {
 export declare type CanonicalFormatSpec = NumericCanonicalFormat | DateCanonicalFormat | DurationCanonicalFormat | StringCanonicalFormat;
 
 export declare interface CardConfig {
+    /**
+     * Matrix table is the shared analytics-spine successor for pivot and
+     * hierarchical aggregate tables. Dashboard cards store the public matrix
+     * intent shape so Data Apps, MCP, and dashboard runtime consume one contract.
+     */
+    matrixIntent?: SemaphorMatrixIntent;
+    /**
+     * Deprecated compatibility fields for older matrix table drafts. New
+     * dashboard-authored matrix cards should use `matrixIntent` so normal
+     * `filters` can remain the explorer/card-level `FilterGroup`.
+     */
+    version?: SemaphorMatrixIntent['version'];
+    source?: SemaphorMatrixIntent['source'];
+    rows?: SemaphorMatrixIntent['rows'];
+    columns?: SemaphorMatrixIntent['columns'];
+    values?: SemaphorMatrixIntent['values'];
+    inputs?: SemaphorMatrixIntent['inputs'];
+    totals?: SemaphorMatrixIntent['totals'];
+    sort?: SemaphorMatrixIntent['sort'];
+    expansion?: SemaphorMatrixIntent['expansion'];
+    layout?: SemaphorMatrixIntent['layout'];
+    displayLimits?: SemaphorMatrixIntent['displayLimits'];
     groupByColumns?: GroupByField[];
     metricColumns?: MetricField[];
     pivotByColumns?: PivotByField[];
@@ -2287,6 +2309,226 @@ export declare type LoadingProps = {
 
 export declare type LogicalOperator = 'AND' | 'OR';
 
+declare type MatrixAxisLevelDescriptor = {
+    instanceId: string;
+    fieldKey: string;
+    label: string;
+    field: SemaphorFieldRef;
+    grain?: SemaphorTimeGrain;
+    subtotal?: SemaphorMatrixSubtotalOptions;
+};
+
+declare type MatrixAxisResultPayload = {
+    id: 'rows' | 'columns';
+    levels: MatrixAxisLevelDescriptor[];
+    nodeIds: string[];
+};
+
+declare type MatrixCalculationDescriptor = {
+    id: string;
+    measureId: string;
+    aggregate?: SemaphorAggregateFunction;
+    label?: string;
+    source: 'measureDefault' | 'rowSubtotal' | 'columnSubtotal' | 'subtotalIntersection' | 'rowGrandTotal' | 'columnGrandTotal' | 'matrixGrandTotal' | 'custom';
+    scope?: {
+        rowLevelId?: string;
+        columnLevelId?: string;
+        rowNodeId?: string;
+        columnNodeId?: string;
+    };
+};
+
+declare type MatrixCapability = 'rowHierarchy' | 'columnHierarchy' | 'rowSubtotals' | 'columnSubtotals' | 'grandTotals' | 'lazyRows' | 'lazyColumns' | 'conditionalFormatting' | 'visualExport' | (string & {});
+
+declare type MatrixCellPresence = 'present' | 'presentNull' | 'missing' | 'densified';
+
+declare type MatrixCellRole = 'value' | 'rowSubtotal' | 'columnSubtotal' | 'subtotalIntersection' | 'rowGrandTotal' | 'columnGrandTotal' | 'matrixGrandTotal';
+
+declare type MatrixExecutionMetadata = {
+    strategy?: MatrixQueryStrategy;
+    dialect?: SemaphorDialect;
+    rowNodeCount?: number;
+    columnNodeCount?: number;
+    cellCount?: number;
+    groupingSetCount?: number;
+    queryDurationMs?: number;
+    budgetRejected?: boolean;
+    cacheStatus?: 'hit' | 'miss' | 'bypass';
+    [key: string]: unknown;
+};
+
+declare type MatrixExpansionRequest = {
+    axis: 'row' | 'column';
+    path: MatrixMemberPathSegment[];
+    depth?: number;
+};
+
+declare type MatrixExpansionResponseHints = {
+    rowLazyLoading?: boolean;
+    columnLazyLoading?: boolean;
+    expandableRowNodeIds?: string[];
+    expandableColumnNodeIds?: string[];
+    nextRequests?: MatrixExpansionRequest[];
+};
+
+declare type MatrixFieldDescriptor = {
+    instanceId: string;
+    fieldKey: string;
+    field: SemaphorFieldRef;
+    role: 'row' | 'column' | 'measure' | 'sort' | 'filter';
+    label?: string;
+};
+
+declare type MatrixFormattingContext = {
+    domains?: Record<string, {
+        min?: number;
+        max?: number;
+    }>;
+    rules?: Array<Record<string, unknown>>;
+};
+
+declare type MatrixGridColumn = {
+    id: string;
+    label: string;
+    columnNodeId?: string;
+    columnPath: MatrixMemberPathSegment[];
+    measureInstanceId: string;
+    role: 'value' | 'columnSubtotal' | 'columnGrandTotal';
+};
+
+declare type MatrixGridHeaderCell = {
+    id: string;
+    label: string;
+    role: 'rowHeader' | 'columnHeader' | 'measureHeader' | 'subtotal' | 'grandTotal';
+    colSpan: number;
+    rowSpan: number;
+    columnPath: MatrixMemberPathSegment[];
+    measureInstanceId?: string;
+};
+
+declare type MatrixGridHeaderRow = {
+    id: string;
+    cells: MatrixGridHeaderCell[];
+};
+
+declare type MatrixGridRowHeaderLevel = {
+    id: string;
+    label: string;
+    fieldInstanceId: string;
+};
+
+declare type MatrixLayoutProjection = {
+    rowHeaderLevels: MatrixGridRowHeaderLevel[];
+    columnHeaderRows: MatrixGridHeaderRow[];
+    columns: MatrixGridColumn[];
+};
+
+declare type MatrixMeasureDescriptor = {
+    instanceId: string;
+    fieldKey: string;
+    label: string;
+    field: SemaphorFieldRef;
+    aggregate?: SemaphorAggregateFunction;
+    format?: SemaphorValueFormat;
+    totalBehavior?: SemaphorMatrixTotalCalculation;
+};
+
+declare type MatrixMeasureResultDescriptor = MatrixMeasureDescriptor & {
+    semantics: MatrixMeasureSemantics;
+};
+
+declare type MatrixMeasureSemantics = {
+    kind: 'additive';
+    aggregate?: SemaphorAggregateFunction;
+} | {
+    kind: 'semiAdditive';
+    aggregate?: SemaphorAggregateFunction;
+    grain?: SemaphorTimeGrain;
+} | {
+    kind: 'nonAdditive';
+    aggregate?: SemaphorAggregateFunction;
+} | {
+    kind: 'ratio';
+    numeratorMeasureInstanceId?: string;
+    denominatorMeasureInstanceId?: string;
+} | {
+    kind: 'custom';
+    expressionId?: string;
+};
+
+declare type MatrixMemberPathSegment = {
+    instanceId: string;
+    fieldKey: string;
+    value: unknown;
+    label: string;
+};
+
+declare type MatrixNode = {
+    id: string;
+    axis: 'row' | 'column';
+    path: MatrixMemberPathSegment[];
+    level: number;
+    label: string;
+    value: unknown;
+    parentId?: string;
+    hasChildren: boolean;
+    isExpanded?: boolean;
+    isSubtotal?: boolean;
+    isGrandTotal?: boolean;
+    subtotalFunction?: SemaphorAggregateFunction;
+    childCount?: number;
+    actions?: MatrixNodeAction[];
+};
+
+declare type MatrixNodeAction = {
+    kind: 'expand' | 'collapse' | 'requestSubgoal' | 'filter' | 'drillThrough' | 'openRelatedRecords' | (string & {});
+    label?: string;
+    payload?: Record<string, unknown>;
+};
+
+declare type MatrixPageInfo = {
+    rowOffset?: number;
+    rowLimit?: number;
+    columnOffset?: number;
+    columnLimit?: number;
+    hasMoreRows?: boolean;
+    hasMoreColumns?: boolean;
+};
+
+declare type MatrixQueryStrategy = 'tall' | 'wide' | 'lazy' | 'export';
+
+declare type MatrixResolvedSort = {
+    id: string;
+    axis: 'row' | 'column';
+    targetInstanceId?: string;
+    direction: 'asc' | 'desc';
+    nulls?: 'warehouseDefault' | 'first' | 'last';
+    scope?: 'global' | 'withinParent';
+    by: SemaphorMatrixSortRule['by'];
+};
+
+declare type MatrixResultCell = {
+    rowId: string;
+    columnId?: string;
+    measureId: string;
+    value: unknown;
+    formattedValue?: string;
+    presence: MatrixCellPresence;
+    role: MatrixCellRole;
+    calculationId?: string;
+};
+
+declare type MatrixShape = 'hierarchical' | 'pivot';
+
+declare type MatrixTotals = {
+    rows?: boolean;
+    columns?: boolean;
+    grandTotal?: boolean | {
+        rows?: boolean;
+        columns?: boolean;
+    };
+};
+
 declare interface MetricColumn extends BaseColumn {
     role: 'metric';
     aggregate: AggregateFunction;
@@ -2529,6 +2771,7 @@ export declare interface QueryExecutionResponse {
     columnKeyMap?: QueryColumnKeyMap;
     tableTotalsByColumnId?: Record<string, string | number | null>;
     documentTableTotalsBaseSql?: string;
+    matrixResult?: SemaphorMatrixResult;
     metadata?: any;
 }
 
@@ -2694,6 +2937,47 @@ declare type SemanticExecutionPayload = {
 
 declare type SemaphorAggregateFunction = 'SUM' | 'COUNT' | 'AVG' | 'MIN' | 'MAX' | 'MEDIAN' | 'DISTINCT';
 
+declare type SemaphorAnalyticsFilter = SemaphorAnalyticsValueFilter | SemaphorAnalyticsNullFilter;
+
+declare type SemaphorAnalyticsFilterBase = {
+    id?: string;
+    field: SemaphorFieldRef;
+    /**
+     * Controls where the filter is applied in an aggregate query.
+     *
+     * `row` means pre-aggregation filtering (`WHERE`).
+     * `aggregate` means post-aggregation filtering (`HAVING`) and is valid only
+     * for measure fields the execution engine can aggregate safely.
+     */
+    scope?: 'row' | 'aggregate';
+};
+
+declare type SemaphorAnalyticsFilterOperator = SemaphorInputOperator | 'not_contains' | 'is_null' | 'is_not_null';
+
+declare type SemaphorAnalyticsNullFilter = SemaphorAnalyticsFilterBase & {
+    operator: SemaphorAnalyticsNullFilterOperator;
+    values?: never;
+};
+
+declare type SemaphorAnalyticsNullFilterOperator = 'is_null' | 'is_not_null';
+
+declare type SemaphorAnalyticsResultBase = {
+    intentId?: string;
+    queryPath: SemaphorQueryPath;
+    warnings?: string[];
+    rowCount?: number;
+    rowLimitExceeded?: boolean;
+    limit?: number;
+    pagination?: SemaphorPaginationMetadata;
+};
+
+declare type SemaphorAnalyticsValueFilter = SemaphorAnalyticsFilterBase & {
+    operator?: SemaphorAnalyticsValueFilterOperator;
+    values: unknown[];
+};
+
+declare type SemaphorAnalyticsValueFilterOperator = Exclude<SemaphorAnalyticsFilterOperator, 'is_null' | 'is_not_null'>;
+
 declare type SemaphorDerivedFieldAggregationBehavior = 'additive' | 'non_additive' | 'ratio_of_sums' | 'weighted' | 'pre_aggregated' | 'snapshot';
 
 declare type SemaphorDerivedFieldAggregationStrategy = 'default' | 'symmetric_aggregate' | 'aggregate_then_join' | 'weighted';
@@ -2714,7 +2998,7 @@ declare type SemaphorDerivedFieldDefinition = {
     defaultAggregate?: SemaphorAggregateFunction;
     aggregationBehavior?: SemaphorDerivedFieldAggregationBehavior;
     aggregationStrategy?: SemaphorDerivedFieldAggregationStrategy;
-    format?: unknown;
+    format?: SemaphorValueFormat;
     tags?: string[];
 };
 
@@ -2734,6 +3018,14 @@ declare type SemaphorDerivedFieldResultRole = 'measure' | 'group' | 'date' | 'id
 
 declare type SemaphorDialect = 'postgres' | 'mysql' | 'mssql' | 'snowflake' | 'clickhouse' | 'bigquery' | 'redshift' | 'duckdb' | 'sqlite' | 'unknown';
 
+/**
+ * Explorer-backed table source. This is intentionally distinct from raw SQL:
+ * matrix planning needs stable source metadata, fields, and dialect context.
+ */
+declare type SemaphorExplorerSourceRef = Extract<SemaphorSourceRef, {
+    kind: 'physical';
+}>;
+
 declare type SemaphorFieldRef = {
     name: string;
     label?: string;
@@ -2743,6 +3035,201 @@ declare type SemaphorFieldRef = {
     aggregate?: SemaphorAggregateFunction;
 };
 
+declare type SemaphorInputBinding = {
+    inputId: string;
+    kind?: 'filter' | 'control';
+    controlRole?: 'grain' | 'metric' | 'dimension' | 'aggregation' | 'sqlParam';
+    operator?: SemaphorInputOperator;
+    field?: SemaphorFieldRef;
+};
+
+declare type SemaphorInputOperator = '=' | '!=' | 'in' | 'not_in' | 'contains' | 'not_contains' | 'between' | 'not_between' | '>' | '>=' | '<' | '<=';
+
+declare type SemaphorMatrixAxisExpansionOptions = {
+    defaultDepth?: number;
+    lazy?: boolean;
+    expandedPaths?: SemaphorMatrixMemberPathSegment[][];
+};
+
+declare type SemaphorMatrixAxisLevel = {
+    id?: string;
+    field: SemaphorFieldRef;
+    grain?: SemaphorTimeGrain;
+    label?: string;
+    subtotal?: boolean | SemaphorMatrixSubtotalOptions;
+    sortBy?: SemaphorMatrixAxisSortRule;
+};
+
+declare type SemaphorMatrixAxisSortRule = {
+    direction: 'asc' | 'desc';
+    by: {
+        kind: 'label';
+    } | {
+        kind: 'field';
+        field: SemaphorFieldRef;
+        aggregate?: SemaphorAggregateFunction;
+    };
+    nulls?: 'warehouseDefault' | 'first' | 'last';
+    scope?: 'global' | 'withinParent';
+};
+
+declare type SemaphorMatrixDisplayLimitOptions = {
+    rows?: SemaphorMatrixDisplayLimitRule;
+    columns?: SemaphorMatrixDisplayLimitRule;
+};
+
+declare type SemaphorMatrixDisplayLimitRule = {
+    limit: number;
+    by?: 'label' | 'value';
+    direction?: 'top' | 'bottom';
+    others?: boolean | {
+        label?: string;
+    };
+};
+
+declare type SemaphorMatrixExpansionOptions = {
+    rows?: SemaphorMatrixAxisExpansionOptions;
+    columns?: SemaphorMatrixAxisExpansionOptions;
+};
+
+declare type SemaphorMatrixIntent = {
+    kind: 'matrix';
+    version?: SemaphorProtocolVersion;
+    id?: string;
+    label?: string;
+    source: SemaphorMatrixSourceRef;
+    rows: SemaphorMatrixAxisLevel[];
+    columns?: SemaphorMatrixAxisLevel[];
+    values: SemaphorMatrixValueField[];
+    filters?: SemaphorAnalyticsFilter[];
+    inputs?: SemaphorInputBinding[];
+    totals?: SemaphorMatrixTotalOptions;
+    sort?: SemaphorMatrixSortRule[];
+    expansion?: SemaphorMatrixExpansionOptions;
+    layout?: SemaphorMatrixLayoutOptions;
+    displayLimits?: SemaphorMatrixDisplayLimitOptions;
+};
+
+declare type SemaphorMatrixLayoutOptions = {
+    hierarchy?: 'compact' | 'tabular' | 'outline';
+    valuesPlacement?: 'columns' | 'rows';
+    stickyRowHeaders?: boolean;
+    stickyColumnHeaders?: boolean;
+};
+
+declare type SemaphorMatrixMemberPathSegment = {
+    levelId: string;
+    value: unknown;
+};
+
+declare type SemaphorMatrixResult = SemaphorAnalyticsResultBase & {
+    kind: 'matrix';
+    schemaVersion: 1;
+    intent?: SemaphorMatrixIntent;
+    shape: MatrixShape;
+    capabilities: MatrixCapability[];
+    executionMetadata: MatrixExecutionMetadata;
+    fieldsById: Record<string, MatrixFieldDescriptor>;
+    measuresById: Record<string, MatrixMeasureResultDescriptor>;
+    calculationsById?: Record<string, MatrixCalculationDescriptor>;
+    axes: {
+        rows: MatrixAxisResultPayload;
+        columns: MatrixAxisResultPayload;
+    };
+    nodesById: Record<string, MatrixNode>;
+    layout: MatrixLayoutProjection;
+    cells: MatrixResultCell[];
+    totals: MatrixTotals;
+    sort: MatrixResolvedSort[];
+    formattingContext: MatrixFormattingContext;
+    pageInfo?: MatrixPageInfo;
+    expansion?: MatrixExpansionResponseHints;
+};
+
+declare type SemaphorMatrixSortRule = {
+    axis: 'row' | 'column';
+    targetId?: string;
+    direction: 'asc' | 'desc';
+    by: {
+        kind: 'label';
+    } | {
+        kind: 'field';
+        field: SemaphorFieldRef;
+        aggregate?: SemaphorAggregateFunction;
+    } | {
+        kind: 'value';
+        valueId: string;
+        rowPath?: SemaphorMatrixMemberPathSegment[];
+        columnPath?: SemaphorMatrixMemberPathSegment[];
+    };
+    nulls?: 'warehouseDefault' | 'first' | 'last';
+    scope?: 'global' | 'withinParent';
+};
+
+declare type SemaphorMatrixSourceRef = SemaphorSemanticSourceRef | SemaphorExplorerSourceRef;
+
+declare type SemaphorMatrixSubtotalOptions = {
+    enabled?: boolean;
+    position?: 'before' | 'after';
+    label?: string;
+};
+
+declare type SemaphorMatrixTotalCalculation = {
+    kind: 'defaultAggregate';
+} | {
+    kind: 'blank';
+} | {
+    kind: 'labelOnly';
+    label?: string;
+} | {
+    kind: 'customAggregate';
+    aggregate: SemaphorAggregateFunction;
+} | {
+    kind: 'percentOfParent';
+} | {
+    kind: 'percentOfGrandTotal';
+} | {
+    kind: 'customExpression';
+    expressionId: string;
+};
+
+declare type SemaphorMatrixTotalOptions = {
+    rows?: boolean | 'perLevel';
+    columns?: boolean | 'perLevel';
+    grandTotal?: boolean | {
+        rows?: boolean;
+        columns?: boolean;
+    };
+    rowPosition?: 'top' | 'bottom';
+    columnPosition?: 'left' | 'right';
+};
+
+declare type SemaphorMatrixValueField = {
+    id?: string;
+    field: SemaphorFieldRef;
+    aggregate?: SemaphorAggregateFunction;
+    label?: string;
+    format?: SemaphorValueFormat;
+    totalBehavior?: SemaphorMatrixTotalCalculation;
+};
+
+declare type SemaphorPaginationMetadata = {
+    page: number;
+    pageSize: number;
+    pageCount: number;
+    totalCount: number;
+    hasNextPage: boolean;
+    hasPrevPage: boolean;
+};
+
+declare type SemaphorProtocolVersion = 1;
+
+declare type SemaphorQueryPath = 'query_spec' | 'sql' | 'sql_python';
+
+declare type SemaphorSemanticSourceRef = Extract<SemaphorSourceRef, {
+    kind: 'semantic';
+}>;
+
 declare type SemaphorSourceRef = {
     kind: 'semantic';
     domainId: string;
@@ -2766,6 +3253,46 @@ declare type SemaphorSourceRef = {
     label?: string;
 };
 
+declare type SemaphorTimeGrain = 'hour' | 'day' | 'week' | 'month' | 'quarter' | 'year';
+
+declare type SemaphorValueFormat = {
+    type: 'number' | 'currency' | 'percent' | 'percentage' | 'scientific';
+    locale?: string;
+    minimumFractionDigits?: number;
+    maximumFractionDigits?: number;
+    useGrouping?: boolean;
+    prefix?: string;
+    suffix?: string;
+    negativeStyle?: 'minus' | 'parentheses';
+    compact?: boolean;
+    scale?: number;
+    currency?: string;
+    percentValueMode?: 'fraction' | 'whole';
+} | {
+    type: 'date' | 'datetime';
+    locale?: string;
+    pattern?: string;
+    relative?: boolean;
+    timezone?: string;
+    sourceTimezone?: string;
+    prefix?: string;
+    suffix?: string;
+} | {
+    type: 'duration';
+    inputUnit?: 'millisecond' | 'second' | 'minute' | 'hour' | 'day';
+    outputStyle?: 'compact' | 'digital' | 'long';
+    largestUnit?: 'millisecond' | 'second' | 'minute' | 'hour' | 'day';
+    smallestUnit?: 'millisecond' | 'second' | 'minute' | 'hour' | 'day';
+    maxUnits?: number;
+    prefix?: string;
+    suffix?: string;
+    negativeStyle?: 'minus' | 'parentheses';
+} | {
+    type: 'string';
+    prefix?: string;
+    suffix?: string;
+};
+
 export declare interface SortByField extends Field {
     role: 'sortby';
     direction: 'asc' | 'desc';
@@ -3345,7 +3872,7 @@ export declare type TChartOptions = {
     treemapColorMode?: 'branch' | 'category';
 };
 
-export declare type TChartType = 'bar' | 'horizontalBar' | 'line' | 'area' | 'stackedArea' | 'combo' | 'pie' | 'doughnut' | 'radar' | 'polarArea' | 'bubble' | 'scatter' | 'stackedBar' | 'stackedLine' | 'table' | 'pivotTable' | 'aggregateTable' | 'detailTable' | 'tableBuilder' | 'kpi' | 'pyramid' | 'tornado' | 'range' | 'text' | 'map' | 'funnel' | 'bullet' | 'heatmap' | 'treemap' | 'custom';
+export declare type TChartType = 'bar' | 'horizontalBar' | 'line' | 'area' | 'stackedArea' | 'combo' | 'pie' | 'doughnut' | 'radar' | 'polarArea' | 'bubble' | 'scatter' | 'stackedBar' | 'stackedLine' | 'table' | 'pivotTable' | 'aggregateTable' | 'matrixTable' | 'detailTable' | 'tableBuilder' | 'kpi' | 'pyramid' | 'tornado' | 'range' | 'text' | 'map' | 'funnel' | 'bullet' | 'heatmap' | 'treemap' | 'custom';
 
 export declare type TColumnSetting<T extends DisplayDataType> = {
     columnIdx: number;

package/package.json

@@ -5,7 +5,7 @@
     "email": "support@semaphor.cloud"
   },
   "license": "MIT",
-  "version": "0.1.372",
+  "version": "0.1.374",
   "description": "Fully interactive and customizable dashboards for your apps.",
   "keywords": [
     "react",