Pivot Charts

Module Extensions

`HTMLRevoGridElement` (Extended from `global`)

1
interface HTMLRevoGridElement {
2
  /**
3
       * Renderer, complete-data provider, defaults, and safety limits for
4
       * renderer-neutral Pivot Charts.
5
       */
6
      pivotCharts?: PivotChartsConfig;
7
  /**
8
       * Optional modeless-dialog and context-menu integration for Pivot Charts.
9
       */
10
      pivotChartsUi?: PivotChartsUiConfig
11
}

`HTMLRevoGridElementEventMap` (Extended from `global`)

1
interface HTMLRevoGridElementEventMap {
2
  'pivot-chart-created': PivotChartCreatedEventDetail;
3
  'pivot-chart-updated': PivotChartUpdatedEventDetail;
4
  'pivot-chart-destroyed': PivotChartDestroyedEventDetail;
5
  'pivot-chart-node-click': PivotChartNodeClickEventDetail;
6
  'pivot-chart-error': PivotChartErrorEventDetail;
7
  'pivot-chart-before-drill': PivotChartDrillEventDetail;
8
  'pivot-chart-drill-start': PivotChartDrillEventDetail;
9
  'pivot-chart-drilled': PivotChartDrilledEventDetail;
10
  'pivot-chart-drill-error': PivotChartDrillErrorEventDetail;
11
  'pivot-chart-drill-reset': PivotChartDrilledEventDetail;
12
  'pivot-chart-drill-sync': PivotChartDrillSyncEventDetail
13
}

Plugin API

`toPivotChartError`

1
export function toPivotChartError(
2
  error: unknown,
3
  fallbackCode: PivotChartErrorCode = 'CHART_UPDATE_FAILED',
4
);

`PivotChartErrorCode`

1
export type PivotChartErrorCode =
2
  | 'PIVOT_NOT_ACTIVE'
3
  | 'RENDERER_REQUIRED'
4
  | 'UNSUPPORTED_CHART_TYPE'
5
  | 'INVALID_DATA_SHAPE'
6
  | 'INVALID_SERIES_SELECTION'
7
  | 'LIMIT_EXCEEDED'
8
  | 'SERVER_PROVIDER_REQUIRED'
9
  | 'SERVER_RESPONSE_INCOMPLETE'
10
  | 'CAPABILITY_UNAVAILABLE'
11
  | 'CHART_ID_CONFLICT'
12
  | 'CHART_UPDATE_FAILED';

`PivotChartError`

1
class PivotChartError {}

`PIVOT_CHART_CREATED_EVENT`

1
PIVOT_CHART_CREATED_EVENT: string;

`PIVOT_CHART_UPDATED_EVENT`

1
PIVOT_CHART_UPDATED_EVENT: string;

`PIVOT_CHART_DESTROYED_EVENT`

1
PIVOT_CHART_DESTROYED_EVENT: string;

`PIVOT_CHART_NODE_CLICK_EVENT`

1
PIVOT_CHART_NODE_CLICK_EVENT: string;

`PIVOT_CHART_ERROR_EVENT`

1
PIVOT_CHART_ERROR_EVENT: string;

`PIVOT_CHART_BEFORE_DRILL_EVENT`

1
PIVOT_CHART_BEFORE_DRILL_EVENT: string;

`PIVOT_CHART_DRILL_START_EVENT`

1
PIVOT_CHART_DRILL_START_EVENT: string;

`PIVOT_CHART_DRILLED_EVENT`

1
PIVOT_CHART_DRILLED_EVENT: string;

`PIVOT_CHART_DRILL_ERROR_EVENT`

1
PIVOT_CHART_DRILL_ERROR_EVENT: string;

`PIVOT_CHART_DRILL_RESET_EVENT`

1
PIVOT_CHART_DRILL_RESET_EVENT: string;

`PIVOT_CHART_DRILL_SYNC_EVENT`

1
PIVOT_CHART_DRILL_SYNC_EVENT: string;

`createPivotChartAnalyticalFrame`

Produces the renderer-neutral, tidy analytical frame for a projected Pivot dataset. Each matrix cell becomes one observation with stable category, series, and measure field IDs.

1
export function createPivotChartAnalyticalFrame(
2
  dataset: Pick<
3
    PivotChartDataset,
4
    'categories' | 'series' | 'values' | 'displayValues' | 'hierarchies'
5
  >,
6
  labels: {
7
    category: string;
8
    series: string;
9
  } = {
10
    category: PIVOT_CHART_CATEGORY_FIELD_ID,
11
    series: PIVOT_CHART_SERIES_FIELD_ID,
12
  },
13
): PivotChartAnalyticalFrame;

`ensurePivotChartAnalyticalFrame`

1
export function ensurePivotChartAnalyticalFrame(
2
  dataset: PivotChartDataset,
3
): PivotChartDataset;

`PIVOT_CHART_CATEGORY_FIELD_ID`

1
PIVOT_CHART_CATEGORY_FIELD_ID: string;

`PIVOT_CHART_SERIES_FIELD_ID`

1
PIVOT_CHART_SERIES_FIELD_ID: string;

`getPivotChartDefinition`

1
export function getPivotChartDefinition(
2
  chartType: PivotChartType,
3
): PivotChartDefinition<PivotChartType>;

`PivotChartFamily`

1
export type PivotChartFamily =
2
  | 'column'
3
  | 'bar'
4
  | 'line'
5
  | 'area'
6
  | 'partToWhole'
7
  | 'relationship'
8
  | 'hierarchical'
9
  | 'combination'
10
  | 'statistical'
11
  | 'specialized'
12
  | 'kpi'
13
  | 'polar'
14
  | 'distribution'
15
  | 'matrix'
16
  | 'process'
17
  | 'flow'
18
  | 'financial';

`PivotChartDataChannel`

1
export type PivotChartDataChannel =
2
  | 'category'
3
  | 'series'
4
  | 'value'
5
  | 'x'
6
  | 'y'
7
  | 'size'
8
  | 'hierarchy'
9
  | 'weight'
10
  | 'source'
11
  | 'target'
12
  | 'start'
13
  | 'end'
14
  | 'low'
15
  | 'high'
16
  | 'open'
17
  | 'close'
18
  | 'volume'
19
  | 'actual'
20
  | 'target'
21
  | 'variance'
22
  | 'color'
23
  | 'shape'
24
  | 'angle'
25
  | 'radius'
26
  | 'parent'
27
  | 'child'
28
  | 'facetRow'
29
  | 'facetColumn'
30
  | 'label'
31
  | 'tooltip';

`PivotChartChannelRequirement`

1
interface PivotChartChannelRequirement {
2
  channel: PivotChartDataChannel;
3
  min: number;
4
  max?: number
5
}

`PivotChartDefinition`

1
interface PivotChartDefinition {
2
  type: TType;
3
  localization: {
4
      labelKey: TType;
5
      descriptionKey: TType;
6
    };
7
  family: PivotChartFamily;
8
  order: number;
9
  dataView:
10
      | 'matrix'
11
      | 'xy'
12
      | 'hierarchy'
13
      | 'binned'
14
      | 'distribution'
15
      | 'statistical'
16
      | 'range'
17
      | 'flow'
18
      | 'financial'
19
      | 'kpi'
20
      | 'calendar';
21
  channels: readonly PivotChartChannelRequirement[];
22
  constraints: {
23
      nonNegative: boolean;
24
      rowHierarchy: boolean;
25
      seriesSelection: 'all' | 'firstAvailable';
26
    };
27
  interactions: {
28
      drill: boolean;
29
      selection: boolean;
30
      zoom: boolean;
31
      pan: boolean;
32
      labels: boolean;
33
      stacking: boolean;
34
    };
35
  presentation: {
36
      axes: boolean;
37
      legend: 'series' | 'category' | 'none';
38
    };
39
  preview: {
40
      dataset: PivotChartDataset;
41
      bindings: PivotChartBindings;
42
      presentation: PivotChartPresentation;
43
      aspectRatio: number;
44
    };
45
  options: PivotChartOptionsSchema;
46
  renderer: PivotChartRenderFunction;
47
  documentationSlug: string
48
}

`PIVOT_CHART_DEFINITIONS`

1
PIVOT_CHART_DEFINITIONS: readonly [PivotChartDefinition<"groupedColumn">, PivotChartDefinition<"stackedColumn">, PivotChartDefinition<"normalizedColumn">, PivotChartDefinition<"groupedBar">, PivotChartDefinition<"stackedBar">, PivotChartDefinition<"normalizedBar">, PivotChartDefinition<"line">, PivotChartDefinition<"smoothLine">, PivotChartDefinition<"steppedLine">, PivotChartDefinition<"area">, PivotChartDefinition<"steppedArea">, PivotChartDefinition<"stackedArea">, PivotChartDefinition<"normalizedArea">, PivotChartDefinition<"pie">, PivotChartDefinition<"donut">, PivotChartDefinition<"treemap">, PivotChartDefinition<"sunburst">, PivotChartDefinition<"scatter">, PivotChartDefinition<"bubble">, PivotChartDefinition<"columnLine">, PivotChartDefinition<"areaLine">, PivotChartDefinition<"rangeColumn">, PivotChartDefinition<"rangeBar">, PivotChartDefinition<"rangeArea">, PivotChartDefinition<"confidenceBand">, PivotChartDefinition<"errorInterval">, PivotChartDefinition<"waterfall">, PivotChartDefinition<"lollipop">, PivotChartDefinition<"bullet">, PivotChartDefinition<"semiDonut">, PivotChartDefinition<"rose">, PivotChartDefinition<"radarLine">, PivotChartDefinition<"radarArea">, PivotChartDefinition<"polarColumn">, PivotChartDefinition<"stackedPolarColumn">, PivotChartDefinition<"normalizedPolarColumn">, PivotChartDefinition<"radialBar">, PivotChartDefinition<"multiRingRadialBar">, PivotChartDefinition<"histogram">, PivotChartDefinition<"stripDot">, PivotChartDefinition<"heatmap">, PivotChartDefinition<"calendarHeatmap">, PivotChartDefinition<"densityScatter">, PivotChartDefinition<"icicle">, PivotChartDefinition<"circlePacking">, PivotChartDefinition<"funnel">, PivotChartDefinition<"pyramid">, PivotChartDefinition<"boxPlot">, PivotChartDefinition<"violin">, PivotChartDefinition<"rangeInterval">, PivotChartDefinition<"sankey">, PivotChartDefinition<"chord">, PivotChartDefinition<"candlestick">, PivotChartDefinition<"ohlc">, PivotChartDefinition<"volumePrice">, PivotChartDefinition<"gauge">, PivotChartDefinition<"kpi">, PivotChartDefinition<"progressGauge">, PivotChartDefinition<"connectedScatter">, PivotChartDefinition<"waffle">, PivotChartDefinition<"smallMultiples">, PivotChartDefinition<"annotatedTimeSeries">, PivotChartDefinition<"timelineRange">];

`PivotChartType`

1
export type PivotChartType =
2
  typeof PIVOT_CHART_DEFINITIONS[number]['type'];

`PIVOT_CHART_TYPES`

1
PIVOT_CHART_TYPES: readonly ("line" | "area" | "kpi" | "groupedColumn" | "stackedColumn" | "normalizedColumn" | "groupedBar" | "stackedBar" | "normalizedBar" | "smoothLine" | "steppedLine" | "steppedArea" | "stackedArea" | "normalizedArea" | "pie" | "donut" | "treemap" | "sunburst" | "scatter" | "bubble" | "densityScatter" | "connectedScatter" | "columnLine" | "areaLine" | "rangeColumn" | "rangeBar" | "rangeArea" | "confidenceBand" | "errorInterval" | "waterfall" | "lollipop" | "bullet" | "semiDonut" | "rose" | "radarLine" | "radarArea" | "polarColumn" | "stackedPolarColumn" | "normalizedPolarColumn" | "radialBar" | "multiRingRadialBar" | "histogram" | "stripDot" | "heatmap" | "calendarHeatmap" | "icicle" | "circlePacking" | "funnel" | "pyramid" | "boxPlot" | "violin" | "rangeInterval" | "sankey" | "chord" | "candlestick" | "ohlc" | "volumePrice" | "gauge" | "progressGauge" | "waffle" | "smallMultiples" | "annotatedTimeSeries" | "timelineRange")[];

`getPivotChartCatalogExtensionDefinitions`

Resolves definitions for a standalone geographic capability host.

Geographic types are intentionally not accepted by PivotChartModel or the built-in Pivot Charts gallery/renderer. Applications render them explicitly through pack.render(...), which keeps provider assets and asynchronous map projection outside the core plugin lifecycle.

1
export function getPivotChartCatalogExtensionDefinitions(
2
  pack?: PivotChartGeographicCapabilityPack,
3
): readonly PivotChartCatalogExtensionDefinition[];

`PivotChartCatalogExtensionDefinition`

1
export type PivotChartCatalogExtensionDefinition =
2
  PivotChartGeographicDefinition;

`evaluatePivotChartCatalog`

1
export function evaluatePivotChartCatalog(
2
  context: PivotChartCompatibilityContext,
3
): PivotChartCompatibility[];

`evaluatePivotChartCompatibility`

1
export function evaluatePivotChartCompatibility(
2
  chartType: PivotChartType,
3
  context: PivotChartCompatibilityContext,
4
): PivotChartCompatibility;

`resolveRelationshipBindings`

1
export function resolveRelationshipBindings(
2
  channels: readonly Extract<PivotChartBindingChannel, 'x' | 'y' | 'size'>[],
3
  dataset: PivotChartDataset,
4
  current: PivotChartBindings,
5
  rebindWhenIncomplete = false,
6
): PivotChartBindings | undefined;

`PivotChartCompatibilityStatus`

1
export type PivotChartCompatibilityStatus =
2
  | 'recommended'
3
  | 'compatible'
4
  | 'needsFields'
5
  | 'unsupported';

`PivotChartCompatibilityReason`

1
export type PivotChartCompatibilityReason =
2
  | { code: 'rendererUnsupported' }
3
  | { code: 'categoriesRequired'; minimum: number }
4
  | { code: 'seriesRequired'; minimum: number }
5
  | { code: 'seriesLimit'; maximum: number }
6
  | { code: 'singleSeriesRequired' }
7
  | { code: 'rowHierarchyRequired' }
8
  | { code: 'dateCategoriesRequired' }
9
  | { code: 'distributionViewRequired' }
10
  | { code: 'nonNegativeValuesRequired' }
11
  | {
12
      code: 'channelRequired';
13
      channel: Extract<
14
        PivotChartBindingChannel,
15
        | 'x'
16
        | 'y'
17
        | 'size'
18
        | SpecializedSeriesChannel
19
        | 'source'
20
        | 'target'
21
        | 'weight'
22
      >;
23
    }
24
  | { code: 'noCompletePoints' }
25
  | { code: 'nonNegativeSizeRequired' };

`PivotChartCompatibility`

1
interface PivotChartCompatibility {
2
  chartType: PivotChartType;
3
  status: PivotChartCompatibilityStatus;
4
  reasons: readonly PivotChartCompatibilityReason[];
5
  score: number;
6
  inferredPatch?: PivotChartUpdatePatch
7
}

`PivotChartCompatibilityContext`

1
interface PivotChartCompatibilityContext {
2
  dataset?: PivotChartDataset;
3
  model: PivotChartModel;
4
  supportedTypes: readonly PivotChartType[]
5
}

`createInitialRowDrillState`

1
export function createInitialRowDrillState(
2
  scope: PivotChartInitialScope,
3
  revision: number | null = null,
4
): PivotChartDrillState;

`canDrillIntoCategory`

1
export function canDrillIntoCategory(category: PivotChartCategory);

`canDrillIntoSeries`

1
export function canDrillIntoSeries(series: PivotChartSeries);

`canDrillIntoTarget`

1
export function canDrillIntoTarget(target: PivotChartDrillTarget);

`createRowDrillFrame`

1
export function createRowDrillFrame(
2
  category: PivotChartCategory,
3
): PivotChartDrillFrame;

`appendRowDrillFrame`

1
export function appendRowDrillFrame(
2
  state: PivotChartDrillState,
3
  category: PivotChartCategory,
4
  revision: number,
5
): PivotChartDrillState;

`appendDrillFrame`

1
export function appendDrillFrame(
2
  state: PivotChartDrillState,
3
  target: PivotChartDrillTarget,
4
  revision: number,
5
): PivotChartDrillState;

`drillToFrame`

1
export function drillToFrame(
2
  state: PivotChartDrillState,
3
  frameIndex: number,
4
  revision: number,
5
): PivotChartDrillState;

`getParentDrillState`

1
export function getParentDrillState(
2
  state: PivotChartDrillState,
3
  revision: number,
4
);

`reconcileDrillState`

1
export function reconcileDrillState(
2
  state: PivotChartDrillState,
3
  pathDepth: number,
4
  revision: number,
5
);

`createRootPivotChartDrillState`

1
export function createRootPivotChartDrillState(
2
  revision: number | null = null,
3
): PivotChartDrillState;

`parsePivotChartModel`

Parses untrusted JSON into a validated, deeply owned V2 model.

1
export function parsePivotChartModel(input: unknown): PivotChartModel;

`clonePivotChartModel`

1
export function clonePivotChartModel(model: PivotChartModel): PivotChartModel;

`mountPivotChart`

Mounts a Pivot Chart into an application-owned container.

Call this after the container exists (for example, in Vue onMounted) and call destroy() on the returned ref during application cleanup. The built-in renderer observes the existing container, so a container that is initially hidden can become visible later.

Example:

1
const chart = await mountPivotChart(grid, {
2
  container: document.querySelector('#sales-chart')!,
3
  presentation: { title: 'Sales by region' },
4
});
5

6
// Or embed the built-in configuration UI:
7
const configurableChart = await mountPivotChart(grid, {
8
  container: document.querySelector('#chart-editor')!,
9
  controls: 'standard',
10
});

1
export async function mountPivotChart(
2
  grid: HTMLRevoGridElement,
3
  {
4
    controls = 'none',
5
    ...params
6
  }: PivotChartMountParams,
7
): Promise<PivotChartRef>;

`PivotChartMountControls`

1
export type PivotChartMountControls = 'none' | 'standard';

`PivotChartMountParams` (Extended from `index.ts`)

1
interface PivotChartMountParams {
2
  /**
3
     * `none` renders only the chart. `standard` embeds the built-in gallery,
4
     * data, customization, drill, table, and export controls.
5
     *
6
     * @defaultValue `'none'`
7
     */
8
    controls?: PivotChartMountControls
9
}

`createPivotChartOptionsSchema`

1
export function createPivotChartOptionsSchema({
2
  family,
3
  axes,
4
  chartType,
5
}: PivotChartOptionSchemaContext): PivotChartOptionsSchema;

`parsePivotChartOptions`

1
export function parsePivotChartOptions(
2
  value: unknown,
3
  schema: PivotChartOptionsSchema,
4
): PivotChartOptions;

`resolvePivotChartOption`

1
export function resolvePivotChartOption(
2
  options: PivotChartOptions | undefined,
3
  schema: PivotChartOptionsSchema,
4
  key: PivotChartOptionKey,
5
): PivotChartJsonValue | undefined;

`PivotChartOptionKey`

1
export type PivotChartOptionKey =
2
  | 'showGridLines'
3
  | 'markOpacity'
4
  | 'strokeWidth'
5
  | 'fillOpacity';

`PivotChartBooleanOptionDefinition`

1
interface PivotChartBooleanOptionDefinition {
2
  key: PivotChartOptionKey;
3
  control: 'boolean';
4
  defaultValue: boolean
5
}

`PivotChartRangeOptionDefinition`

1
interface PivotChartRangeOptionDefinition {
2
  key: PivotChartOptionKey;
3
  control: 'range';
4
  defaultValue: number;
5
  min: number;
6
  max: number;
7
  step: number
8
}

`PivotChartOptionDefinition`

1
export type PivotChartOptionDefinition =
2
  | PivotChartBooleanOptionDefinition
3
  | PivotChartRangeOptionDefinition;

`PivotChartOptionsSchema`

1
interface PivotChartOptionsSchema {
2
  fields: readonly PivotChartOptionDefinition[];
3
  defaults: Readonly<PivotChartOptions>
4
}

`projectPivotChartDataset`

1
export function projectPivotChartDataset(
2
  snapshot: PivotRuntimeSnapshot,
3
  context: PivotChartProjectorContext,
4
  options: PivotChartDataOptions = {},
5
): PivotChartDataset;

`projectPivotChartSemanticSlice`

Projects one already-aggregated semantic child slice through the same matrix adapter as the root chart. The Pivot query owns hierarchy navigation; this adapter only maps its committed rows into renderer data.

1
export function projectPivotChartSemanticSlice(
2
  snapshot: PivotRuntimeSnapshot,
3
  slice: PivotSemanticSlice,
4
  context: Omit<PivotChartProjectorContext, 'visibleRows'>,
5
  options: PivotChartDataOptions = {},
6
): PivotChartDataset;

`PIVOT_CHART_MODEL_VERSION`

1
PIVOT_CHART_MODEL_VERSION: 2;

`PivotChartTotalsMode`

1
export type PivotChartTotalsMode = 'none' | 'grand' | 'subtotals' | 'all';

`PivotChartTheme`

1
export type PivotChartTheme = 'auto' | string;

`PivotChartUpdateReason`

1
export type PivotChartUpdateReason =
2
  | 'data'
3
  | 'options'
4
  | 'theme'
5
  | 'relink'
6
  | 'drill';

`PivotChartLegendPosition`

1
export type PivotChartLegendPosition = 'top' | 'right' | 'bottom' | 'left' | 'none';

`PivotChartAxis`

1
export type PivotChartAxis = 'row' | 'column';

`PivotChartDrillSyncMode`

1
export type PivotChartDrillSyncMode = 'chart' | 'pivot' | 'both' | 'event';

`PivotChartLimits`

1
interface PivotChartLimits {
2
  maxCategories: number;
3
  maxSeries: number;
4
  maxDataPoints: number
5
}

`DEFAULT_PIVOT_CHART_LIMITS`

1
DEFAULT_PIVOT_CHART_LIMITS: Readonly<PivotChartLimits>;

`PivotChartMeasure`

1
interface PivotChartMeasure {
2
  prop: ColumnProp;
3
  aggregator: string;
4
  label: string
5
}

`PivotChartMeasureSelection`

1
export type PivotChartMeasureSelection = Pick<
2
  PivotChartMeasure,
3
  'prop' | 'aggregator'
4
>;

`PivotChartMemberKind`

1
export type PivotChartMemberKind =
2
  | 'leaf'
3
  | 'group'
4
  | 'subtotal'
5
  | 'grandTotal'
6
  | 'collapsed';

`PivotChartHierarchyLevel`

1
interface PivotChartHierarchyLevel {
2
  id: string;
3
  field: ColumnProp;
4
  label: string;
5
  index: number
6
}

`PivotChartHierarchyDefinition`

1
interface PivotChartHierarchyDefinition {
2
  id: string;
3
  axis: PivotChartAxis;
4
  levels: PivotChartHierarchyLevel[]
5
}

`PivotChartMemberHierarchy`

1
interface PivotChartMemberHierarchy {
2
  axis: PivotChartAxis;
3
  hierarchyId: string;
4
  levelId: string;
5
  levelIndex: number;
6
  maxLevelIndex: number;
7
  hasChildren: boolean;
8
  childCount?: number
9
}

`PivotChartCategory`

1
interface PivotChartCategory {
2
  id: string;
3
  label: string;
4
  path: PivotPath;
5
  labels: string[];
6
  depth: number;
7
  kind: PivotChartMemberKind;
8
  measure?: PivotChartMeasure;
9
  /** Optional row-axis hierarchy metadata used by drill-aware datasets. */
10
    hierarchy?: PivotChartMemberHierarchy
11
}

`PivotChartSeries`

1
interface PivotChartSeries {
2
  id: string;
3
  label: string;
4
  columnPath: PivotPath;
5
  labels: string[];
6
  kind: PivotChartMemberKind;
7
  prop: ColumnProp;
8
  /** Fixed measure for values-on-columns layouts; the category owns it for values-on-rows. */
9
    measure?: PivotChartMeasure;
10
  /** Optional column-axis hierarchy metadata used by drill-aware datasets. */
11
    hierarchy?: PivotChartMemberHierarchy
12
}

`PivotChartDataset`

1
interface PivotChartDataset {
2
  revision: number;
3
  source: 'client' | 'server';
4
  categories: PivotChartCategory[];
5
  series: PivotChartSeries[];
6
  /** Row-major matrix: values[categoryIndex][seriesIndex]. */
7
    values: Array<Array<number | null>>;
8
  /** Optional row-major strings for labels and tooltips. */
9
    displayValues?: Array<Array<string | null>>;
10
  /** Ordered hierarchy definitions supplied by drill-aware data providers. */
11
    hierarchies?: {
12
      row?: PivotChartHierarchyDefinition;
13
      column?: PivotChartHierarchyDefinition;
14
    };
15
  /**
16
     * Canonical long-form analytical frame. The matrix above is a renderer view
17
     * retained for efficient Cartesian drawing, while every semantic channel
18
     * resolves against stable field IDs in this frame.
19
     */
20
    analyticalFrame?: PivotChartAnalyticalFrame
21
}

`PivotChartSemanticType`

1
export type PivotChartSemanticType =
2
  | 'category'
3
  | 'number'
4
  | 'date'
5
  | 'geographic'
6
  | 'identifier';

`PivotChartFieldDescriptor`

1
interface PivotChartFieldDescriptor {
2
  id: string;
3
  label: string;
4
  role: 'dimension' | 'measure';
5
  semanticType: PivotChartSemanticType;
6
  sourceField?: ColumnProp;
7
  aggregator?: string;
8
  format?: string
9
}

`PivotChartDimensionValue`

1
interface PivotChartDimensionValue {
2
  value: string | number | boolean | null;
3
  label: string;
4
  path?: PivotPath;
5
  labels?: string[]
6
}

`PivotChartObservation`

1
interface PivotChartObservation {
2
  id: string;
3
  dimensions: Record<string, PivotChartDimensionValue>;
4
  measures: Record<string, number | null>;
5
  displayMeasures?: Record<string, string | null>
6
}

`PivotChartDerivedViews`

1
interface PivotChartDerivedViews {
2
  bins?: PivotChartJsonValue[];
3
  quantiles?: PivotChartJsonValue[];
4
  ranges?: PivotChartJsonValue[];
5
  flowEdges?: PivotChartJsonValue[];
6
  financial?: PivotChartJsonValue[];
7
  geographicFeatures?: PivotChartJsonValue[]
8
}

`PivotChartAnalyticalFrame`

1
interface PivotChartAnalyticalFrame {
2
  fields: PivotChartFieldDescriptor[];
3
  observations: PivotChartObservation[];
4
  hierarchies?: PivotChartDataset['hierarchies'];
5
  derived?: PivotChartDerivedViews
6
}

`PivotChartPresentation`

1
interface PivotChartPresentation {
2
  title?: string;
3
  subtitle?: string;
4
  legendPosition?: PivotChartLegendPosition;
5
  dataLabels?: boolean;
6
  xAxisTitle?: string;
7
  yAxisTitle?: string
8
}

`PivotChartDataOptions`

1
interface PivotChartDataOptions {
2
  chartType?: PivotChartType;
3
  seriesIds?: string[];
4
  /** Measure carried by categories when Pivot values are placed on rows. */
5
    categoryMeasure?: PivotChartMeasureSelection;
6
  totals?: PivotChartTotalsMode;
7
  limits?: Partial<PivotChartLimits>;
8
  bindings?: PivotChartBindings
9
}

`PivotChartDataScope`

1
interface PivotChartDataScope {
2
  rowPath: PivotPath;
3
  columnPath?: PivotPath
4
}

`PivotChartDataQueryOptions` (Extended from `index.ts`)

1
interface PivotChartDataQueryOptions {
2
  /** Optional committed semantic scope used for an initial or explicit slice. */
3
    scope?: PivotChartDataScope
4
}

`PivotChartInitialScope`

1
interface PivotChartInitialScope {
2
  /** Parent row member whose immediate children form the initial categories. */
3
    rowPath: PivotPath;
4
  /** Display labels aligned one-to-one with `rowPath` for breadcrumbs. */
5
    rowLabels: string[];
6
  /** Parent column member whose immediate children form the initial series. */
7
    columnPath?: PivotPath;
8
  /** Display labels aligned one-to-one with `columnPath` for breadcrumbs. */
9
    columnLabels?: string[]
10
}

`PivotChartCreateParams` (Extended from `index.ts`)

1
interface PivotChartCreateParams {
2
  container: HTMLElement;
3
  linked?: boolean;
4
  /** Creation-only semantic scope, persisted as the chart's drill state. */
5
    initialScope?: PivotChartInitialScope;
6
  presentation?: PivotChartPresentation;
7
  theme?: PivotChartTheme;
8
  chartOptions?: PivotChartOptions;
9
  /** Controls whether drill navigation is local, Pivot-owned, synchronized, or application-owned. */
10
    drillSyncMode?: PivotChartDrillSyncMode
11
}

`PivotChartUpdatePatch` (Extended from `index.ts`)

1
interface PivotChartUpdatePatch {
2
  linked?: boolean;
3
  presentation?: Partial<PivotChartPresentation>;
4
  theme?: PivotChartTheme;
5
  chartOptions?: PivotChartOptions;
6
  drillSyncMode?: PivotChartDrillSyncMode
7
}

`PivotChartJsonValue`

1
export type PivotChartJsonValue =
2
  | null
3
  | boolean
4
  | number
5
  | string
6
  | PivotChartJsonValue[]
7
  | { [key: string]: PivotChartJsonValue };

`PivotChartBindingChannel`

1
export type PivotChartBindingChannel =
2
  | 'category'
3
  | 'geographic'
4
  | 'series'
5
  | 'value'
6
  | 'x'
7
  | 'y'
8
  | 'size'
9
  | 'color'
10
  | 'shape'
11
  | 'angle'
12
  | 'radius'
13
  | 'hierarchy'
14
  | 'parent'
15
  | 'child'
16
  | 'weight'
17
  | 'source'
18
  | 'target'
19
  | 'start'
20
  | 'end'
21
  | 'low'
22
  | 'high'
23
  | 'open'
24
  | 'close'
25
  | 'volume'
26
  | 'actual'
27
  | 'target'
28
  | 'variance'
29
  | 'facetRow'
30
  | 'facetColumn'
31
  | 'label'
32
  | 'tooltip';

`PivotChartBindings`

Stable analytical field IDs assigned to semantic renderer channels. Empty and omitted channels are equivalent.

1
/**
2
 * Stable analytical field IDs assigned to semantic renderer channels.
3
 * Empty and omitted channels are equivalent.
4
 */
5
export type PivotChartBindings = Partial<
6
  Record<PivotChartBindingChannel, string[]>
7
>;

`PivotChartOptions`

1
export type PivotChartOptions = Record<string, PivotChartJsonValue>;

`PivotChartDrillAxisState`

1
interface PivotChartDrillAxisState {
2
  path: PivotPath;
3
  /** Selected hierarchy level, or `-1` at the hierarchy root. */
4
    levelIndex: number
5
}

`PivotChartDrillScope`

1
interface PivotChartDrillScope {
2
  row: PivotChartDrillAxisState;
3
  column: PivotChartDrillAxisState
4
}

`PivotChartDrillFrame` (Extended from `index.ts`)

1
interface PivotChartDrillFrame {
2
  rowLabels: string[];
3
  columnLabels: string[]
4
}

`PivotChartDrillState`

1
interface PivotChartDrillState {
2
  active: PivotChartDrillScope;
3
  /** Ordered root-to-current breadcrumb frames. */
4
    frames: PivotChartDrillFrame[];
5
  /** Dataset revision that produced the active frame; null until rebound. */
6
    revision: number | null
7
}

`PivotChartModel`

1
interface PivotChartModel {
2
  version: typeof PIVOT_CHART_MODEL_VERSION;
3
  chartId: string;
4
  chartType: PivotChartType;
5
  linked: boolean;
6
  totals: PivotChartTotalsMode;
7
  seriesIds?: string[];
8
  categoryMeasure?: PivotChartMeasureSelection;
9
  presentation: PivotChartPresentation;
10
  theme: PivotChartTheme;
11
  /** Captured only for an unlinked chart. */
12
    dataset?: PivotChartDataset;
13
  bindings: PivotChartBindings;
14
  chartOptions: PivotChartOptions;
15
  drill: PivotChartDrillState;
16
  drillSyncMode: PivotChartDrillSyncMode
17
}

`PivotChartRestoreOptions`

1
interface PivotChartRestoreOptions {
2
  container: HTMLElement;
3
  chartId?: string
4
}

`PivotChartDownloadFormat`

1
export type PivotChartDownloadFormat = 'png' | 'pdf';

`PivotChartDownloadOptions`

1
interface PivotChartDownloadOptions {
2
  fileName?: string;
3
  width?: number;
4
  height?: number;
5
  fileFormat?: PivotChartDownloadFormat
6
}

`PivotChartImageOptions`

1
interface PivotChartImageOptions {
2
  width?: number;
3
  height?: number;
4
  fileFormat?: 'png'
5
}

`PivotChartNodeClick`

1
interface PivotChartNodeClick {
2
  category: PivotChartCategory;
3
  series: PivotChartSeries;
4
  value: number | null;
5
  /** Bound relationship-channel values for scatter/bubble points. */
6
    channelValues?: Partial<Record<'x' | 'y' | 'size', number>>;
7
  /** Series descriptors that own relationship-channel values. */
8
    channelSeries?: Partial<Record<'x' | 'y' | 'size', PivotChartSeries>>;
9
  originalEvent?: Event
10
}

`PivotChartTooltipChannel`

1
export type PivotChartTooltipChannel = 'x' | 'y' | 'size';

`PivotChartTooltipContext`

1
interface PivotChartTooltipContext {
2
  chartId: string;
3
  chartType: PivotChartType;
4
  category: PivotChartCategory;
5
  series: PivotChartSeries;
6
  value: number | null;
7
  displayValue: string;
8
  color: string;
9
  drillable: boolean;
10
  channelValues?: Partial<Record<PivotChartTooltipChannel, number>>;
11
  channelSeries?: Partial<
12
      Record<PivotChartTooltipChannel, PivotChartSeries>
13
    >;
14
  channelDisplayValues?: Partial<
15
      Record<PivotChartTooltipChannel, string>
16
    >
17
}

`PivotChartTooltipRow`

1
interface PivotChartTooltipRow {
2
  label: string;
3
  value: string;
4
  color?: string
5
}

`PivotChartTooltipContent`

1
interface PivotChartTooltipContent {
2
  title?: string;
3
  rows?: readonly PivotChartTooltipRow[];
4
  footer?: string;
5
  ariaLabel?: string
6
}

`PivotChartTooltipResult`

1
export type PivotChartTooltipResult =
2
  | PivotChartTooltipContent
3
  | string
4
  | HTMLElement
5
  | null
6
  | undefined;

`PivotChartTooltipFormatter`

1
export type PivotChartTooltipFormatter = (
2
  context: PivotChartTooltipContext,
3
  defaultContent: PivotChartTooltipContent,
4
) => PivotChartTooltipResult;

`PivotChartRenderInput`

1
interface PivotChartRenderInput {
2
  chartId: string;
3
  container: HTMLElement;
4
  chartType: PivotChartType;
5
  dataset: PivotChartDataset;
6
  bindings: PivotChartBindings;
7
  presentation: PivotChartPresentation;
8
  /** Validated chart-specific overrides; omitted keys use catalog defaults. */
9
    chartOptions?: PivotChartOptions;
10
  theme: PivotChartTheme;
11
  localeText: PivotChartsLocaleText;
12
  /** Preview mode renders decorative, non-interactive compact chart marks. */
13
    renderMode?: 'chart' | 'preview';
14
  onNodeClick: (detail: PivotChartNodeClick) => void
15
}

`PivotChartRendererCapabilities`

1
interface PivotChartRendererCapabilities {
2
  supportedTypes: readonly PivotChartType[];
3
  download?: boolean;
4
  downloadFormats?: readonly PivotChartDownloadFormat[];
5
  imageDataUrl?: boolean
6
}

`PivotChartRenderer`

1
interface PivotChartRenderer {
2
  readonly capabilities: PivotChartRendererCapabilities;
3
  create(
4
      input: PivotChartRenderInput,
5
    ): PivotChartRendererInstance | Promise<PivotChartRendererInstance>
6
}

`PivotChartRendererInstance`

1
interface PivotChartRendererInstance {
2
  update(input: PivotChartRenderInput): void | Promise<void>;
3
  destroy(): void;
4
  focus?(): void;
5
  download?(options?: PivotChartDownloadOptions): Promise<void>;
6
  getImageDataURL?(options?: PivotChartImageOptions): Promise<string>
7
}

`PivotChartDataRequest`

1
interface PivotChartDataRequest {
2
  requestId: string;
3
  viewId: string;
4
  fieldsVersion: string;
5
  loadOptions: PivotLoadOptions;
6
  uiState?: PivotUiStateHints;
7
  axisState: {
8
      rowExpandedPaths?: PivotPath[];
9
      columnExpandedPaths?: PivotPath[];
10
    };
11
  chart: {
12
      seriesIds?: string[];
13
      categoryMeasure?: PivotChartMeasureSelection;
14
      totals: PivotChartTotalsMode;
15
      limits: PivotChartLimits;
16
      bindings: PivotChartBindings;
17
      scope: PivotChartSemanticScope;
18
    }
19
}

`PivotChartSemanticScope`

1
interface PivotChartSemanticScope {
2
  /** Committed Pivot revision the provider must echo in its response. */
3
    revision: number;
4
  /** Active parent row member. The response contains its immediate children. */
5
    rowPath: PivotPath;
6
  /** Active parent column member. Reserved for column-axis drill navigation. */
7
    columnPath: PivotPath;
8
  /** Absolute immediate-child row depth requested for this frame. */
9
    rowDepth: number;
10
  /** Absolute immediate-child column depth requested for this frame. */
11
    columnDepth: number
12
}

`PivotChartDataResponse`

1
interface PivotChartDataResponse {
2
  requestId: string;
3
  scope: PivotChartSemanticScope;
4
  categories: PivotChartCategory[];
5
  series: PivotChartSeries[];
6
  values: Array<Array<number | null>>;
7
  displayValues?: Array<Array<string | null>>;
8
  hierarchies: {
9
      row?: PivotChartHierarchyDefinition;
10
      column?: PivotChartHierarchyDefinition;
11
    };
12
  totalCategoryCount: number;
13
  totalSeriesCount: number
14
}

`PivotChartDataProvider`

1
interface PivotChartDataProvider {
2
  load(
3
      request: PivotChartDataRequest,
4
      context: { signal: AbortSignal },
5
    ): Promise<PivotChartDataResponse>
6
}

`PivotChartsConfig`

1
interface PivotChartsConfig {
2
  renderer?: PivotChartRenderer;
3
  dataProvider?: PivotChartDataProvider;
4
  defaultChartType?: PivotChartType;
5
  defaultTotals?: PivotChartTotalsMode;
6
  limits?: Partial<PivotChartLimits>;
7
  localeText?: PivotChartsLocaleTextOptions;
8
  defaultDrillSyncMode?: PivotChartDrillSyncMode;
9
  /**
10
     * Optional application adapter for Pivot synchronization. When omitted,
11
     * the active Pivot plugin applies the semantic frontier directly.
12
     */
13
    synchronizeDrill?: (
14
      detail: PivotChartDrillSyncEventDetail,
15
      context: { signal: AbortSignal },
16
    ) => void | Promise<void>
17
}

`PivotChartsUiConfig`

1
interface PivotChartsUiConfig {
2
  contextMenu?: boolean;
3
  dialogParent?: HTMLElement
4
}

`PivotChartRef`

1
interface PivotChartRef {
2
  readonly id: string;
3
  readonly container: HTMLElement;
4
  readonly model: PivotChartModel;
5
  update(patch: PivotChartUpdatePatch): Promise<void>;
6
  canDrillDown(target: PivotChartDrillTarget | PivotChartCategory): boolean;
7
  drillDown(target: PivotChartDrillTarget | PivotChartCategory): Promise<void>;
8
  drillUp(): Promise<void>;
9
  drillTo(frameIndex: number): Promise<void>;
10
  resetDrill(): Promise<void>;
11
  retryDrill(): Promise<void>;
12
  getDrillState(): PivotChartDrillState;
13
  focus(): void;
14
  destroy(): void
15
}

`PivotChartDrillTarget`

1
export type PivotChartDrillTarget =
2
  | { axis: 'row'; category: PivotChartCategory }
3
  | { axis: 'column'; series: PivotChartSeries }
4
  | {
5
      axis: 'both';
6
      category: PivotChartCategory;
7
      series: PivotChartSeries;
8
    };

`PivotChartDrillAction`

1
export type PivotChartDrillAction = 'down' | 'up' | 'to' | 'reset' | 'retry';

`PivotChartDrillEventDetail`

1
interface PivotChartDrillEventDetail {
2
  chartId: string;
3
  action: PivotChartDrillAction;
4
  from: PivotChartDrillState;
5
  to: PivotChartDrillState
6
}

`PivotChartDrilledEventDetail` (Extended from `index.ts`)

1
interface PivotChartDrilledEventDetail {
2
  model: PivotChartModel;
3
  dataset: PivotChartDataset
4
}

`PivotChartDrillErrorEventDetail` (Extended from `index.ts`)

1
interface PivotChartDrillErrorEventDetail {
2
  error: Error
3
}

`PivotChartDrillSyncEventDetail` (Extended from `index.ts`)

1
interface PivotChartDrillSyncEventDetail {
2
  mode: Exclude<PivotChartDrillSyncMode, 'chart'>
3
}

`PivotChartCreatedEventDetail`

1
interface PivotChartCreatedEventDetail {
2
  chartId: string;
3
  ref: PivotChartRef
4
}

`PivotChartUpdatedEventDetail`

1
interface PivotChartUpdatedEventDetail {
2
  chartId: string;
3
  reason: PivotChartUpdateReason;
4
  model: PivotChartModel
5
}

`PivotChartDestroyedEventDetail`

1
interface PivotChartDestroyedEventDetail {
2
  chartId: string
3
}

`PivotChartNodeClickEventDetail` (Extended from `index.ts`)

1
interface PivotChartNodeClickEventDetail {
2
  chartId: string;
3
  categoryPath: PivotPath;
4
  columnPath: PivotPath;
5
  measure?: ColumnProp;
6
  aggregator?: string
7
}

`PivotChartErrorEventDetail`

1
interface PivotChartErrorEventDetail {
2
  chartId?: string;
3
  error: Error
4
}

`PivotChartProjectorContext`

1
interface PivotChartProjectorContext {
2
  /** Visible logical body rows after grouping, filtering, and sorting. */
3
    visibleRows: DataType[];
4
  /** Grid column types used to preserve measure display formatting. */
5
    columnTypes?: ColumnTypes;
6
  localeText?: PivotChartsLocaleText
7
}

`isPivotChartType`

1
export function isPivotChartType(value: unknown): value is PivotChartType;

`resolvePivotChartLimits`

1
export function resolvePivotChartLimits(
2
  limits?: Partial<PivotChartLimits>,
3
): PivotChartLimits;

`assertPivotChartLimits`

1
export function assertPivotChartLimits(
2
  dataset: Pick<PivotChartDataset, 'categories' | 'series'>,
3
  limits: PivotChartLimits,
4
);

`selectPivotChartSeries`

1
export function selectPivotChartSeries(
2
  series: PivotChartSeries[],
3
  seriesIds?: readonly string[],
4
);

`assertPivotChartTypeShape`

1
export function assertPivotChartTypeShape(
2
  chartType: PivotChartType,
3
  dataset: PivotChartDataset,
4
  localeText?: PivotChartsLocaleText,
5
  bindings: PivotChartBindings = {},
6
);

`assertRelationshipChartBindings`

1
export function assertRelationshipChartBindings(
2
  chartType: PivotChartType,
3
  dataset: PivotChartDataset,
4
  bindings: PivotChartBindings,
5
  localeText?: PivotChartsLocaleText,
6
);

`validatePivotChartDataResponse`

1
export function validatePivotChartDataResponse(
2
  response: PivotChartDataResponse,
3
  request: PivotChartDataRequest,
4
  limits: PivotChartLimits,
5
): PivotChartDataset;

`assertPivotChartDataset`

1
export function assertPivotChartDataset(dataset: PivotChartDataset);

`validatePivotChartModel`

1
export function validatePivotChartModel(model: unknown): PivotChartModel;

`createPivotChartGeographicCapabilityPack`

Creates an opt-in geographic capability. Merely importing Pivot Charts does not install geographic types or load projection/map data.

1
export function createPivotChartGeographicCapabilityPack(
2
  provider: PivotChartGeographicProvider,
3
): PivotChartGeographicCapabilityPack;

`getAvailablePivotChartGeographicTypes`

1
export function getAvailablePivotChartGeographicTypes(
2
  pack?: PivotChartGeographicCapabilityPack,
3
): readonly PivotChartGeographicType[];

`getPivotChartGeographicDefinitions`

Catalog-extension hook used by gallery hosts. The base catalog remains unchanged; a host receives no geographic entries until a pack is installed.

1
export function getPivotChartGeographicDefinitions(
2
  pack?: PivotChartGeographicCapabilityPack,
3
): readonly PivotChartGeographicDefinition[];

`isPivotChartGeographicType`

1
export function isPivotChartGeographicType(
2
  value: unknown,
3
): value is PivotChartGeographicType;

`assertGeographicRequest`

1
export function assertGeographicRequest(
2
  request: PivotChartGeographicRequest,
3
): void;

`assertGeographicData`

1
export function assertGeographicData(
2
  data: PivotChartGeographicData,
3
  request: Pick<PivotChartGeographicRequest, 'chartType' | 'dataset'>,
4
): void;

`PIVOT_CHART_GEOGRAPHIC_DEFINITIONS`

1
PIVOT_CHART_GEOGRAPHIC_DEFINITIONS: readonly PivotChartGeographicDefinition[];

`PivotChartGeographicDataError`

1
class PivotChartGeographicDataError {}

`PivotChartGeographicType`

Geographic charts are intentionally not part of the base chart catalog. Import and install a geographic capability pack to make these types available.

1
/**
2
 * Geographic charts are intentionally not part of the base chart catalog.
3
 * Import and install a geographic capability pack to make these types
4
 * available.
5
 */
6
export type PivotChartGeographicType =
7
  | 'choropleth'
8
  | 'proportionalSymbolMap'
9
  | 'geographicHeatmap';

`PivotChartGeographicPosition`

1
export type PivotChartGeographicPosition = readonly [
2
  longitude: number,
3
  latitude: number,
4
];

`PivotChartGeographicViewport`

1
interface PivotChartGeographicViewport {
2
  width: number;
3
  height: number;
4
  pixelRatio?: number
5
}

`PivotChartGeographicRequest`

1
interface PivotChartGeographicRequest {
2
  chartId: string;
3
  chartType: PivotChartGeographicType;
4
  dataset: PivotChartDataset;
5
  bindings: PivotChartBindings;
6
  theme: PivotChartTheme;
7
  viewport: PivotChartGeographicViewport
8
}

`PivotChartGeographicRegion`

1
interface PivotChartGeographicRegion {
2
  id: string;
3
  label: string;
4
  /**
5
     * Provider-projected SVG path. Projection and map assets remain owned by the
6
     * provider, keeping them out of the Pivot bundle.
7
     */
8
    path: string;
9
  categoryId: string;
10
  seriesId: string;
11
  value: number | null;
12
  properties?: Record<string, PivotChartJsonValue>
13
}

`PivotChartGeographicSymbol`

1
interface PivotChartGeographicSymbol {
2
  id: string;
3
  label: string;
4
  position: PivotChartGeographicPosition;
5
  /** Provider-projected viewport coordinate used by the optional renderer. */
6
    projectedPosition: readonly [x: number, y: number];
7
  categoryId: string;
8
  seriesId: string;
9
  value: number | null;
10
  size: number | null;
11
  properties?: Record<string, PivotChartJsonValue>
12
}

`PivotChartGeographicHeatPoint`

1
interface PivotChartGeographicHeatPoint {
2
  id: string;
3
  position: PivotChartGeographicPosition;
4
  /** Provider-projected viewport coordinate used by the optional renderer. */
5
    projectedPosition: readonly [x: number, y: number];
6
  categoryId?: string;
7
  seriesId?: string;
8
  value: number;
9
  radius?: number;
10
  properties?: Record<string, PivotChartJsonValue>
11
}

`PivotChartChoroplethData` (Extended from `index.ts`)

1
interface PivotChartChoroplethData {
2
  chartType: 'choropleth';
3
  regions: PivotChartGeographicRegion[]
4
}

`PivotChartProportionalSymbolData` (Extended from `index.ts`)

1
interface PivotChartProportionalSymbolData {
2
  chartType: 'proportionalSymbolMap';
3
  symbols: PivotChartGeographicSymbol[]
4
}

`PivotChartGeographicHeatmapData` (Extended from `index.ts`)

1
interface PivotChartGeographicHeatmapData {
2
  chartType: 'geographicHeatmap';
3
  points: PivotChartGeographicHeatPoint[]
4
}

`PivotChartGeographicData`

1
export type PivotChartGeographicData =
2
  | PivotChartChoroplethData
3
  | PivotChartProportionalSymbolData
4
  | PivotChartGeographicHeatmapData;

`PivotChartGeographicProvider`

1
interface PivotChartGeographicProvider {
2
  readonly id: string;
3
  readonly supportedTypes: readonly PivotChartGeographicType[];
4
  /**
5
     * Loads map data and applies the provider-owned projection. The operation
6
     * must observe the supplied signal and avoid mutating the request.
7
     */
8
    load(
9
      request: Readonly<PivotChartGeographicRequest>,
10
      context: { signal: AbortSignal },
11
    ): Promise<PivotChartGeographicData>
12
}

`PivotChartGeographicDefinition`

1
interface PivotChartGeographicDefinition {
2
  type: PivotChartGeographicType;
3
  family: 'geographic';
4
  localization: {
5
      labelKey: PivotChartGeographicType;
6
      descriptionKey: PivotChartGeographicType;
7
    };
8
  channels: readonly {
9
      channel: 'geographic' | 'value' | 'size';
10
      min: number;
11
      max?: number;
12
    }[];
13
  documentationSlug: string
14
}

`PivotChartGeographicCapabilityPack`

1
interface PivotChartGeographicCapabilityPack {
2
  readonly id: string;
3
  readonly provider: PivotChartGeographicProvider;
4
  readonly definitions: readonly PivotChartGeographicDefinition[];
5
  readonly supportedTypes: readonly PivotChartGeographicType[];
6
  load(
7
      request: PivotChartGeographicRequest,
8
      context: { signal: AbortSignal },
9
    ): Promise<PivotChartGeographicData>;
10
  /**
11
     * Starts an asset-free SVG render lifecycle backed by this pack's provider.
12
     * Provider loads are cancelled when superseded or destroyed.
13
     */
14
    render(
15
      input: PivotChartGeographicRenderInput,
16
    ): PivotChartGeographicRendererInstance
17
}

`PivotChartGeographicLocaleText`

1
interface PivotChartGeographicLocaleText {
2
  chartAriaLabel(type: PivotChartGeographicType): string;
3
  loading: string;
4
  loadError(error: Error): string;
5
  regionAriaLabel(label: string, value: string): string;
6
  symbolAriaLabel(label: string, value: string, size: string): string;
7
  heatPointAriaLabel(value: string): string;
8
  formatValue(value: number | null): string
9
}

`PivotChartGeographicDatum`

1
export type PivotChartGeographicDatum =
2
  | PivotChartGeographicRegion
3
  | PivotChartGeographicSymbol
4
  | PivotChartGeographicHeatPoint;

`PivotChartGeographicRenderInput`

1
interface PivotChartGeographicRenderInput {
2
  container: HTMLElement;
3
  request: PivotChartGeographicRequest;
4
  localeText: PivotChartGeographicLocaleText;
5
  onNodeClick?: (
6
      detail: {
7
        chartType: PivotChartGeographicType;
8
        datum: PivotChartGeographicDatum;
9
        originalEvent: Event;
10
      },
11
    ) => void;
12
  onError?: (error: Error) => void
13
}

`PivotChartGeographicRendererInstance`

1
interface PivotChartGeographicRendererInstance {
2
  readonly ready: Promise<void>;
3
  update(input: PivotChartGeographicRenderInput): Promise<void>;
4
  focus(): void;
5
  destroy(): void
6
}

`PivotChartsPlugin`

Headless Pivot plugin for creating and managing charts from the active Pivot result.

The plugin owns chart data projection, renderer lifecycle, linked refreshes, semantic drill-down, persistence, and export. It does not create the chart dialog; add PivotChartsUiPlugin when the standard modeless chart UI and Pivot context-menu action are required.

Configure the renderer through grid.pivotCharts before creating a chart. Public methods can be called on the installed plugin instance returned by grid.getPlugins(). A PivotChartRef offers the same common lifecycle operations scoped to one chart.

PivotPlugin is required. Linked charts read committed Pivot snapshots and refresh after Pivot data, filter, sorting, grouping, source, and grid-theme changes. Unlinked charts retain a serializable dataset in their model and do not follow later Pivot changes.

Example: Create a linked chart with the built-in renderer.

1
import {
2
  PivotChartsPlugin,
3
  PivotPlugin,
4
  createPivotChartsRenderer,
5
  mountPivotChart,
6
} from '@revolist/pivot';
7

8
const grid = document.querySelector('revo-grid')!;
9
grid.plugins = [PivotPlugin, PivotChartsPlugin];
10
grid.pivotCharts = {
11
  renderer: createPivotChartsRenderer(),
12
  defaultChartType: 'groupedColumn',
13
};
14

15
const chart = await mountPivotChart(grid, {
16
  container: document.querySelector<HTMLElement>('#sales-chart')!,
17
  presentation: { title: 'Sales by region' },
18
});
19

20
await chart.update({ chartType: 'stackedColumn' });

Dependencies

Required PivotPlugin: Consumes committed Pivot runtime snapshots and semantic result metadata.
Event integration PIVOT_MODEL_CHANGED_EVENT, afterfilterapply, aftersortingapply, groupexpandclick, aftersourceset, afterthemechanged: Keeps linked charts synchronized with the logical Pivot view.
Config integration grid.pivotCharts: Reads the renderer, complete-data provider, defaults, and safety limits.

1
class PivotChartsPlugin {
2
  /**
3
     * Projects the current committed Pivot result into a renderer-neutral chart
4
     * dataset.
5
     *
6
     * Use this method for custom chart pickers, data previews, compatibility
7
     * checks, or application renderers. The returned dataset is an immutable
8
     * cached snapshot; request a new dataset after the Pivot revision changes.
9
     * `scope` selects a semantic row/column parent and returns its immediate
10
     * children, which is useful for opening a chart around a Pivot cell.
11
     *
12
     * @param options - Series, totals, bindings, limits, chart compatibility, and
13
     * optional semantic scope for the projection.
14
     * @returns A validated chart dataset for the active Pivot revision.
15
     * @throws {@link PivotChartError} When Pivot data is unavailable, a provider
16
     * response is invalid, safety limits are exceeded, or `chartType` is
17
     * incompatible with the projected fields.
18
     *
19
     * @example Read a scoped dataset before presenting chart choices.
20
     * ```ts
21
     * const dataset = await charts.getChartData({
22
     *   chartType: 'groupedColumn',
23
     *   totals: 'none',
24
     *   scope: {
25
     *     rowPath: ['Canada'],
26
     *     columnPath: [2024],
27
     *   },
28
     * });
29
     *
30
     * console.log(dataset.categories, dataset.series, dataset.values);
31
     * ```
32
     */
33
  async getChartData(
34
    options: PivotChartDataQueryOptions = {},
35
  ): Promise<PivotChartDataset>;
36

37
  /**
38
     * Creates a chart in an application-owned container.
39
     *
40
     * By default the chart is linked to the active Pivot, excludes totals, and
41
     * uses the configured default chart type. Set `linked: false` to capture the
42
     * initial projected dataset as a standalone chart that ignores later Pivot
43
     * changes. Use `initialScope` to start at a semantic hierarchy level while
44
     * preserving breadcrumb and drill state.
45
     *
46
     * @param params - Container, chart type, data selection, presentation,
47
     * bindings, theme, drill mode, and chart-specific options.
48
     * @returns A chart reference for updates, drill navigation, focus, and
49
     * destruction.
50
     * @throws {TypeError} When `params.container` is not an `HTMLElement`.
51
     * @throws {@link PivotChartError} When no renderer is configured, the chart
52
     * type is unsupported, the data is incompatible, or the requested chart ID
53
     * conflicts with an active or pending chart.
54
     *
55
     * @example Create a linked chart at a row hierarchy scope.
56
     * ```ts
57
     * const chart = await charts.createChart({
58
     *   container: document.querySelector<HTMLElement>('#chart')!,
59
     *   chartType: 'line',
60
     *   initialScope: {
61
     *     rowPath: ['Europe'],
62
     *     rowLabels: ['Europe'],
63
     *   },
64
     *   presentation: {
65
     *     title: 'European performance',
66
     *     legendPosition: 'bottom',
67
     *   },
68
     * });
69
     * ```
70
     */
71
  async createChart(params: PivotChartCreateParams): Promise<PivotChartRef>;
72

73
  /**
74
     * Applies a validated partial update to an existing chart.
75
     *
76
     * Renderer updates are serialized so overlapping calls cannot overwrite one
77
     * another. Changes to totals, series, bindings, or linked state reload chart
78
     * data; presentation, theme, and chart options update the existing renderer
79
     * instance when possible.
80
     *
81
     * @param chartId - ID returned by {@link createChart} or {@link restoreChart}.
82
     * @param patch - Chart type, data selection, presentation, theme, bindings,
83
     * drill mode, or chart-specific options to change.
84
     * @returns A promise that resolves after the renderer and stored model agree.
85
     * @throws {@link PivotChartError} When the chart does not exist, the patch is
86
     * invalid, relinking fails, or the resulting data is incompatible.
87
     *
88
     * @example Change the visualization without recreating its container.
89
     * ```ts
90
     * await charts.updateChart(chart.id, {
91
     *   chartType: 'stackedBar',
92
     *   presentation: {
93
     *     title: 'Sales contribution',
94
     *     dataLabels: true,
95
     *   },
96
     * });
97
     * ```
98
     */
99
  async updateChart(
100
    chartId: string,
101
    patch: PivotChartUpdatePatch,
102
  ): Promise<void>;
103

104
  /**
105
     * Retries the current chart data/render operation without changing options.
106
     * UI integrations use this after a transient provider or renderer failure.
107
     *
108
     * @param chartId - ID of the chart to reload.
109
     * @returns A promise that resolves after data and rendering are current.
110
     * @throws {@link PivotChartError} When the chart does not exist or the retry
111
     * fails. Aborted superseded refreshes resolve without changing the chart.
112
     *
113
     * @example Retry after showing an application-level error state.
114
     * ```ts
115
     * try {
116
     *   await charts.refreshChart(chart.id);
117
     * } catch (error) {
118
     *   console.error('Chart refresh failed', error);
119
     * }
120
     * ```
121
     */
122
  async refreshChart(chartId: string): Promise<void>;
123

124
  /**
125
     * Reports whether a category or explicit semantic target can navigate to a
126
     * deeper hierarchy level in the current chart frame.
127
     *
128
     * The result is `false` for unlinked charts, non-drillable chart types,
129
     * targets outside the current dataset, and leaf members.
130
     *
131
     * @param chartId - ID of the chart to inspect.
132
     * @param input - A category for row drill-down or an explicit row, column, or
133
     * two-axis drill target.
134
     * @returns `true` when {@link drillDownChart} can navigate the target.
135
     * @throws {@link PivotChartError} When the chart does not exist.
136
     *
137
     * @example Enable a custom drill action only for expandable marks.
138
     * ```ts
139
     * const category = dataset.categories[0];
140
     * if (category && charts.canDrillDown(chart.id, category)) {
141
     *   await charts.drillDownChart(chart.id, category);
142
     * }
143
     * ```
144
     */
145
  canDrillDown(
146
    chartId: string,
147
    input: PivotChartDrillTarget | PivotChartCategory,
148
  ): boolean;
149

150
  /**
151
     * Navigates a linked chart into the children of a row, column, or combined
152
     * hierarchy target.
153
     *
154
     * Drill behavior follows the chart's `drillSyncMode`: chart-local, Pivot-only,
155
     * synchronized chart and Pivot, or application-event mode. The operation is
156
     * cancellable through `pivot-chart-before-drill`.
157
     *
158
     * @param chartId - ID of the chart to navigate.
159
     * @param input - Category or explicit semantic target selected by the user.
160
     * @returns A promise that resolves after synchronization, data loading, and
161
     * rendering complete.
162
     * @throws {@link PivotChartError} When the chart is missing, the target is not
163
     * drillable, synchronization is unavailable, or scoped data loading fails.
164
     *
165
     * @example Drill both chart axes from a relationship-chart point.
166
     * ```ts
167
     * await charts.drillDownChart(chart.id, {
168
     *   axis: 'both',
169
     *   category: selectedCategory,
170
     *   series: selectedSeries,
171
     * });
172
     * ```
173
     */
174
  async drillDownChart(
175
    chartId: string,
176
    input: PivotChartDrillTarget | PivotChartCategory,
177
  ): Promise<void>;
178

179
  /**
180
     * Navigates a chart to the parent of its current drill frame.
181
     *
182
     * Calling this method at the root is a no-op and cancels pending drill work.
183
     *
184
     * @param chartId - ID of the chart to navigate.
185
     * @returns A promise that resolves after the parent frame is rendered.
186
     * @throws {@link PivotChartError} When the chart does not exist or parent
187
     * synchronization/data loading fails.
188
     *
189
     * @example
190
     * ```ts
191
     * await charts.drillUpChart(chart.id);
192
     * ```
193
     */
194
  async drillUpChart(chartId: string): Promise<void>;
195

196
  /**
197
     * Navigates directly to an existing breadcrumb frame.
198
     *
199
     * Frame indexes use the root-to-current order returned by
200
     * `chart.getDrillState().frames`; index `0` is the root. Selecting the current
201
     * frame is a no-op.
202
     *
203
     * @param chartId - ID of the chart to navigate.
204
     * @param frameIndex - Zero-based breadcrumb frame index.
205
     * @returns A promise that resolves after the selected frame is rendered.
206
     * @throws {@link PivotChartError} When the chart is missing, the frame index
207
     * is invalid, or synchronization/data loading fails.
208
     *
209
     * @example Return to the first drilled level.
210
     * ```ts
211
     * await charts.drillToChart(chart.id, 1);
212
     * ```
213
     */
214
  async drillToChart(chartId: string, frameIndex: number): Promise<void>;
215

216
  /**
217
     * Returns a drilled chart to its root semantic scope.
218
     *
219
     * Calling this method at the root is a no-op and cancels pending drill work.
220
     *
221
     * @param chartId - ID of the chart to reset.
222
     * @returns A promise that resolves after the root frame is rendered.
223
     * @throws {@link PivotChartError} When the chart does not exist or reset
224
     * synchronization/data loading fails.
225
     *
226
     * @example
227
     * ```ts
228
     * await charts.resetChartDrill(chart.id);
229
     * ```
230
     */
231
  async resetChartDrill(chartId: string): Promise<void>;
232

233
  /**
234
     * Retries the last failed drill operation for a chart.
235
     *
236
     * If no failed drill state exists, this method falls back to
237
     * {@link refreshChart} without changing the current frame.
238
     *
239
     * @param chartId - ID of the chart whose drill should be retried.
240
     * @returns A promise that resolves after retry or refresh completes.
241
     * @throws {@link PivotChartError} When the chart does not exist or the retry
242
     * fails again.
243
     *
244
     * @example
245
     * ```ts
246
     * grid.addEventListener('pivot-chart-drill-error', async event => {
247
     *   await charts.retryChartDrill(event.detail.chartId);
248
     * });
249
     * ```
250
     */
251
  async retryChartDrill(chartId: string): Promise<void>;
252

253
  /**
254
     * Destroys one chart and releases its renderer and pending drill resources.
255
     *
256
     * Unknown chart IDs are ignored. The chart's application-owned container is
257
     * not removed.
258
     *
259
     * @param chartId - ID of the chart to destroy.
260
     *
261
     * @example
262
     * ```ts
263
     * charts.destroyChart(chart.id);
264
     * ```
265
     */
266
  destroyChart(chartId: string): void;
267

268
  /**
269
     * Destroys every chart owned by this plugin instance.
270
     *
271
     * Pending creations are invalidated before and after destruction so
272
     * re-entrant lifecycle handlers cannot leave an untracked chart behind.
273
     *
274
     * @example
275
     * ```ts
276
     * charts.destroyAllCharts();
277
     * ```
278
     */
279
  destroyAllCharts(): void;
280

281
  /**
282
     * Returns defensive copies of all active chart models.
283
     *
284
     * Persist these models to restore linked chart configuration or complete
285
     * unlinked chart snapshots later. Mutating the returned objects does not
286
     * change active charts.
287
     *
288
     * @returns Serializable chart models in creation order.
289
     *
290
     * @example Save chart state.
291
     * ```ts
292
     * localStorage.setItem(
293
     *   'pivot-charts',
294
     *   JSON.stringify(charts.getChartModels()),
295
     * );
296
     * ```
297
     */
298
  getChartModels(): PivotChartModel[];
299

300
  /**
301
     * Restores a validated chart model into a new container.
302
     *
303
     * Linked models reload the current Pivot data and retain the deepest valid
304
     * drill ancestor. Unlinked models render their captured dataset. Pass
305
     * `options.chartId` to override the persisted ID when restoring multiple
306
     * copies of the same model.
307
     *
308
     * @param model - Previously persisted chart model.
309
     * @param options - Destination container and optional replacement chart ID.
310
     * @returns A new chart reference managed by this plugin.
311
     * @throws {@link PivotChartError} When the model is invalid, its chart ID is
312
     * already active or pending, or current data cannot satisfy the model.
313
     *
314
     * @example Restore persisted charts into application containers.
315
     * ```ts
316
     * const [saved] = JSON.parse(
317
     *   localStorage.getItem('pivot-charts') ?? '[]',
318
     * );
319
     *
320
     * if (saved) {
321
     *   await charts.restoreChart(saved, {
322
     *     container: document.querySelector<HTMLElement>('#restored-chart')!,
323
     *   });
324
     * }
325
     * ```
326
     */
327
  async restoreChart(
328
    model: PivotChartModel,
329
    options: PivotChartRestoreOptions,
330
  ): Promise<PivotChartRef>;
331

332
  /**
333
     * Downloads a rendered chart through the configured renderer.
334
     *
335
     * The built-in renderer supports PNG and PDF. Custom renderers advertise
336
     * their formats through `capabilities.downloadFormats`.
337
     *
338
     * @param chartId - ID of the chart to export.
339
     * @param options - File name, dimensions, and output format.
340
     * @returns A promise that resolves after the renderer starts or completes the
341
     * download.
342
     * @throws {@link PivotChartError} When the chart is missing or the renderer
343
     * does not support downloads or the requested format.
344
     *
345
     * @example Export the current chart as PDF.
346
     * ```ts
347
     * await charts.downloadChart(chart.id, {
348
     *   fileName: 'quarterly-sales',
349
     *   fileFormat: 'pdf',
350
     *   width: 1600,
351
     *   height: 900,
352
     * });
353
     * ```
354
     */
355
  async downloadChart(
356
    chartId: string,
357
    options?: PivotChartDownloadOptions,
358
  ): Promise<void>;
359

360
  /**
361
     * Encodes a chart as an image data URL without triggering a download.
362
     *
363
     * Use this for application previews, reports, clipboard workflows, or custom
364
     * persistence. Renderer support is optional and declared by
365
     * `capabilities.imageDataUrl`.
366
     *
367
     * @param chartId - ID of the chart to encode.
368
     * @param options - Optional output width, height, and PNG format.
369
     * @returns A PNG data URL generated by the renderer.
370
     * @throws {@link PivotChartError} When the chart is missing or its renderer
371
     * cannot create image data URLs.
372
     *
373
     * @example Show a chart image in an application-owned preview.
374
     * ```ts
375
     * const image = document.querySelector<HTMLImageElement>('#chart-preview')!;
376
     * image.src = await charts.getChartImageDataURL(chart.id, {
377
     *   width: 1200,
378
     *   height: 675,
379
     * });
380
     * ```
381
     */
382
  async getChartImageDataURL(
383
    chartId: string,
384
    options?: PivotChartImageOptions,
385
  ): Promise<string>;
386
}

`createPivotChartsLocaleText`

1
export function createPivotChartsLocaleText(
2
  localeText?: PivotChartsLocaleTextOptions,
3
): PivotChartsLocaleText;

`PivotChartDatumLocaleContext`

1
interface PivotChartDatumLocaleContext {
2
  category: PivotChartCategory;
3
  series: PivotChartSeries;
4
  value: number | null;
5
  displayValue: string
6
}

`PivotChartRelationshipDatumLocaleContext`

1
interface PivotChartRelationshipDatumLocaleContext {
2
  category: PivotChartCategory;
3
  x: { series: PivotChartSeries; value: number; displayValue: string };
4
  y: { series: PivotChartSeries; value: number; displayValue: string };
5
  size?: { series: PivotChartSeries; value: number; displayValue: string }
6
}

`PivotChartsLocaleText`

1
interface PivotChartsLocaleText {
2
  dialog: {
3
      kicker: string;
4
      untitledChart: string;
5
      chartAriaLabel: (title: string | undefined) => string;
6
      settingsAriaLabel: string;
7
    };
8
  actions: {
9
      exportChart: string;
10
      downloadPng: string;
11
      downloadPdf: string;
12
      close: string;
13
      closeButtonText: string;
14
      retry: string;
15
      viewData: string;
16
      viewChart: string;
17
    };
18
  status: {
19
      loading: string;
20
      empty: string;
21
      formatError: (error: Error) => string;
22
    };
23
  drill: {
24
      toolbarAriaLabel: string;
25
      breadcrumbAriaLabel: string;
26
      root: string;
27
      currentLevel: (label: string) => string;
28
      loading: (label: string) => string;
29
      loaded: (label: string) => string;
30
      retry: string;
31
      formatError: (error: Error) => string;
32
      drillableDatum: (context: PivotChartDatumLocaleContext) => string;
33
      relationshipDrillableDatum:
34
        (context: PivotChartRelationshipDatumLocaleContext) => string;
35
    };
36
  controls: {
37
      chartType: string;
38
      valueSeries: string;
39
      xMeasure: string;
40
      yMeasure: string;
41
      sizeMeasure: string;
42
      title: string;
43
      subtitle: string;
44
      legend: string;
45
      dataLabels: string;
46
      xAxisTitle: string;
47
      yAxisTitle: string;
48
      totals: string;
49
      drillSyncMode: string;
50
      theme: string;
51
      keepLinked: string;
52
    };
53
  chartOptions: {
54
      heading: string;
55
      description: string;
56
      resetAll: string;
57
      resetOption: (label: string) => string;
58
      valueLabel: (label: string, value: number) => string;
59
      labels: Record<PivotChartOptionKey, string>;
60
      descriptions: Record<PivotChartOptionKey, string>;
61
    };
62
  gallery: {
63
      tabs: {
64
        chart: string;
65
        data: string;
66
        customize: string;
67
      };
68
      searchPlaceholder: string;
69
      searchAriaLabel: string;
70
      recommended: string;
71
      families: Record<PivotChartFamily, string>;
72
      noResults: string;
73
      compatibilityReason: (reason: PivotChartCompatibilityReason) => string;
74
    };
75
  chartTypes: Record<PivotChartType, string>;
76
  chartDescriptions: Record<PivotChartType, string>;
77
  legendPositions: {
78
      automatic: string;
79
      top: string;
80
      right: string;
81
      bottom: string;
82
      left: string;
83
      none: string;
84
    };
85
  totals: Record<PivotChartTotalsMode, string>;
86
  drillSyncModes: Record<PivotChartDrillSyncMode, string>;
87
  themes: {
88
      auto: string;
89
      default: string;
90
      material: string;
91
      compact: string;
92
      darkMaterial: string;
93
      darkCompact: string;
94
      custom: (theme: string) => string;
95
    };
96
  contextMenu: {
97
      createChart: string;
98
      pluginRequired: string;
99
      rendererRequired: string;
100
      serverProviderRequired: string;
101
    };
102
  uiErrors: {
103
      destroyed: string;
104
      containerMissing: string;
105
      mountContainerRequired: string;
106
      creationClosed: string;
107
      pluginRequired: string;
108
      uiPluginRequired: string;
109
    };
110
  data: {
111
      total: string;
112
      hierarchySeparator: string;
113
    };
114
  dataTable: {
115
      regionAriaLabel: string;
116
      tableCaption: string;
117
      categoryHeader: string;
118
      emptyValue: string;
119
      sortAscending: (columnLabel: string) => string;
120
      sortDescending: (columnLabel: string) => string;
121
      sortedAscending: (columnLabel: string) => string;
122
      sortedDescending: (columnLabel: string) => string;
123
    };
124
  renderer: {
125
      chartAriaLabel: (title: string | undefined) => string;
126
      legendAriaLabel: string;
127
      legendItemAriaLabel: (series: PivotChartSeries) => string;
128
      legendCategoryItemAriaLabel: (category: PivotChartCategory) => string;
129
      legendOverflow: (hiddenCount: number) => string;
130
      datumAriaLabel: (context: PivotChartDatumLocaleContext) => string;
131
      datumTitle: (context: PivotChartDatumLocaleContext) => string;
132
      relationshipDatumAriaLabel:
133
        (context: PivotChartRelationshipDatumLocaleContext) => string;
134
      relationshipDatumTitle:
135
        (context: PivotChartRelationshipDatumLocaleContext) => string;
136
      tooltipDrillHint: string;
137
      missingValue: string;
138
      formatNumber: (value: number) => string;
139
      formatPercent: (value: number) => string;
140
      downloadFileName: string;
141
      pngUnavailable: string;
142
      pdfUnavailable: string;
143
      pdfEncodeError: string;
144
      rasterizeError: string;
145
      canvasRequired: string;
146
      destroyedRenderer: string;
147
      unsupportedChartType: (chartType: string) => string;
148
      valueSeriesRequired: (chartType: string) => string;
149
      singleSeriesRequired: (chartType: string) => string;
150
      rowHierarchyRequired: string;
151
      dateCategoriesRequired: string;
152
      distributionViewRequired: string;
153
      nonNegativeValuesRequired: string;
154
      relationshipBindingsRequired: (chartType: string) => string;
155
      relationshipDataRequired: (chartType: string) => string;
156
      nonNegativeSizeRequired: string;
157
      minimumSeriesRequired: (chartType: string, minimum: number) => string;
158
      maximumSeriesRequired: (chartType: string, maximum: number) => string;
159
    }
160
}

`PivotChartsLocaleTextOptions`

1
interface PivotChartsLocaleTextOptions {
2
  dialog?: Partial<PivotChartsLocaleText['dialog']>;
3
  actions?: Partial<PivotChartsLocaleText['actions']>;
4
  status?: Partial<PivotChartsLocaleText['status']>;
5
  drill?: Partial<PivotChartsLocaleText['drill']>;
6
  controls?: Partial<PivotChartsLocaleText['controls']>;
7
  chartOptions?: {
8
      heading?: string;
9
      description?: string;
10
      resetAll?: string;
11
      resetOption?: PivotChartsLocaleText['chartOptions']['resetOption'];
12
      valueLabel?: PivotChartsLocaleText['chartOptions']['valueLabel'];
13
      labels?: Partial<PivotChartsLocaleText['chartOptions']['labels']>;
14
      descriptions?: Partial<
15
        PivotChartsLocaleText['chartOptions']['descriptions']
16
      >;
17
    };
18
  gallery?: {
19
      tabs?: Partial<PivotChartsLocaleText['gallery']['tabs']>;
20
      searchPlaceholder?: string;
21
      searchAriaLabel?: string;
22
      recommended?: string;
23
      families?: Partial<PivotChartsLocaleText['gallery']['families']>;
24
      noResults?: string;
25
      compatibilityReason?: PivotChartsLocaleText['gallery']['compatibilityReason'];
26
    };
27
  chartTypes?: Partial<PivotChartsLocaleText['chartTypes']>;
28
  chartDescriptions?: Partial<PivotChartsLocaleText['chartDescriptions']>;
29
  legendPositions?: Partial<PivotChartsLocaleText['legendPositions']>;
30
  totals?: Partial<PivotChartsLocaleText['totals']>;
31
  drillSyncModes?: Partial<PivotChartsLocaleText['drillSyncModes']>;
32
  themes?: Partial<PivotChartsLocaleText['themes']>;
33
  contextMenu?: Partial<PivotChartsLocaleText['contextMenu']>;
34
  uiErrors?: Partial<PivotChartsLocaleText['uiErrors']>;
35
  data?: Partial<PivotChartsLocaleText['data']>;
36
  dataTable?: Partial<PivotChartsLocaleText['dataTable']>;
37
  renderer?: Partial<PivotChartsLocaleText['renderer']>
38
}

`DEFAULT_PIVOT_CHARTS_LOCALE_TEXT`

1
DEFAULT_PIVOT_CHARTS_LOCALE_TEXT: {
2
  dialog: { kicker: string; untitledChart: string; chartAriaLabel: (title: string | undefined) => string; settingsAriaLabel: string; };
3
  actions: { exportChart: string; downloadPng: string; downloadPdf: string; close: string; closeButtonText: string; retry: string; viewData: string; viewChart: string; };
4
  status: { loading: string; empty: string; formatError: (error: Error) => string; };
5
  drill: { toolbarAriaLabel: string; breadcrumbAriaLabel: string; root: string; currentLevel: (label: string) => string; loading: (label: string) => string; loaded: (label: string) => string; retry: string; formatError: (error: Error) => string; drillableDatum: ({ category, series, displayValue }: PivotChartDatumLocaleContext) => string; relationshipDrillableDatum: ({ category, x, y, size }: PivotChartRelationshipDatumLocaleContext) => string; };
6
  controls: { chartType: string; valueSeries: string; xMeasure: string; yMeasure: string; sizeMeasure: string; title: string; subtitle: string; legend: string; dataLabels: string; xAxisTitle: string; yAxisTitle: string; totals: string; drillSyncMode: string; theme: string; keepLinked: string; };
7
  chartOptions: { heading: string; description: string; resetAll: string; resetOption: (label: string) => string; valueLabel: (label: string, value: number) => string; labels: { showGridLines: string; markOpacity: string; strokeWidth: string; fillOpacity: string; }; descriptions: { showGridLines: string; markOpacity: string; strokeWidth: string; fillOpacity: string; }; };
8
  gallery: { tabs: { chart: string; data: string; customize: string; }; searchPlaceholder: string; searchAriaLabel: string; recommended: string; families: { column: string; bar: string; line: string; area: string; partToWhole: string; relationship: string; hierarchical: string; combination: string; statistical: string; specialized: string; kpi: string; polar: string; distribution: string; matrix: string; process: string; flow: string; financial: string; }; noResults: string; compatibilityReason: (reason: PivotChartCompatibilityReason) => string; };
9
  chartTypes: { groupedColumn: string; stackedColumn: string; normalizedColumn: string; groupedBar: string; stackedBar: string; normalizedBar: string; line: string; smoothLine: string; steppedLine: string; area: string; steppedArea: string; stackedArea: string; normalizedArea: string; pie: string; donut: string; treemap: string; sunburst: string; scatter: string; bubble: string; columnLine: string; areaLine: string; rangeColumn: string; rangeBar: string; rangeArea: string; confidenceBand: string; errorInterval: string; waterfall: string; lollipop: string; bullet: string; semiDonut: string; rose: string; radarLine: string; radarArea: string; polarColumn: string; stackedPolarColumn: string; normalizedPolarColumn: string; radialBar: string; multiRingRadialBar: string; histogram: string; stripDot: string; heatmap: string; calendarHeatmap: string; densityScatter: string; icicle: string; circlePacking: string; funnel: string; pyramid: string; boxPlot: string; violin: string; rangeInterval: string; sankey: string; chord: string; candlestick: string; ohlc: string; volumePrice: string; gauge: string; kpi: string; progressGauge: string; connectedScatter: string; waffle: string; smallMultiples: string; annotatedTimeSeries: string; timelineRange: string; };
10
  chartDescriptions: { groupedColumn: string; stackedColumn: string; normalizedColumn: string; groupedBar: string; stackedBar: string; normalizedBar: string; line: string; smoothLine: string; steppedLine: string; area: string; steppedArea: string; stackedArea: string; normalizedArea: string; pie: string; donut: string; treemap: string; sunburst: string; scatter: string; bubble: string; columnLine: string; areaLine: string; rangeColumn: string; rangeBar: string; rangeArea: string; confidenceBand: string; errorInterval: string; waterfall: string; lollipop: string; bullet: string; semiDonut: string; rose: string; radarLine: string; radarArea: string; polarColumn: string; stackedPolarColumn: string; normalizedPolarColumn: string; radialBar: string; multiRingRadialBar: string; histogram: string; stripDot: string; heatmap: string; calendarHeatmap: string; densityScatter: string; icicle: string; circlePacking: string; funnel: string; pyramid: string; boxPlot: string; violin: string; rangeInterval: string; sankey: string; chord: string; candlestick: string; ohlc: string; volumePrice: string; gauge: string; kpi: string; progressGauge: string; connectedScatter: string; waffle: string; smallMultiples: string; annotatedTimeSeries: string; timelineRange: string; };
11
  legendPositions: { automatic: string; top: string; right: string; bottom: string; left: string; none: string; };
12
  totals: { none: string; grand: string; subtotals: string; all: string; };
13
  drillSyncModes: { chart: string; pivot: string; both: string; event: string; };
14
  themes: { auto: string; default: string; material: string; compact: string; darkMaterial: string; darkCompact: string; custom: (theme: string) => string; };
15
  contextMenu: { createChart: string; pluginRequired: string; rendererRequired: string; serverProviderRequired: string; };
16
  uiErrors: { destroyed: string; containerMissing: string; mountContainerRequired: string; creationClosed: string; pluginRequired: string; uiPluginRequired: string; };
17
  data: { total: string; hierarchySeparator: string; };
18
  dataTable: { regionAriaLabel: string; tableCaption: string; categoryHeader: string; emptyValue: string; sortAscending: (columnLabel: string) => string; sortDescending: (columnLabel: string) => string; sortedAscending: (columnLabel: string) => string; sortedDescending: (columnLabel: string) => string; };
19
  renderer: { chartAriaLabel: (title: string | undefined) => string; legendAriaLabel: string; legendItemAriaLabel: (series: PivotChartSeries) => string; legendCategoryItemAriaLabel: (category: PivotChartCategory) => string; legendOverflow: (hiddenCount: number) => string; datumAriaLabel: ({ category, series, displayValue }: PivotChartDatumLocaleContext) => string; datumTitle: ({ category, series, displayValue }: PivotChartDatumLocaleContext) => string; relationshipDatumAriaLabel: ({ category, x, y, size }: PivotChartRelationshipDatumLocaleContext) => string; relationshipDatumTitle: ({ category, x, y, size }: PivotChartRelationshipDatumLocaleContext) => string; tooltipDrillHint: string; missingValue: string; formatNumber: (value: number) => string; formatPercent: (value: number) => string; downloadFileName: string; pngUnavailable: string; pdfUnavailable: string; pdfEncodeError: string; rasterizeError: string; canvasRequired: string; destroyedRenderer: string; unsupportedChartType: (chartType: string) => string; valueSeriesRequired: (chartType: string) => string; singleSeriesRequired: (chartType: string) => string; rowHierarchyRequired: string; dateCategoriesRequired: string; distributionViewRequired: string; nonNegativeValuesRequired: string; relationshipBindingsRequired: (chartType: string) => string; relationshipDataRequired: (chartType: string) => string; nonNegativeSizeRequired: string; minimumSeriesRequired: (chartType: string, minimum: number) => string; maximumSeriesRequired: (chartType: string, maximum: number) => string; };
20
};

`createPivotChartsRenderer`

Creates the built-in RevoGrid Pivot Charts SVG renderer.

1
export function createPivotChartsRenderer(
2
  options: PivotChartsRendererOptions = {},
3
): PivotChartRenderer;

`ChartTheme`

1
interface ChartTheme {
2
  background: string;
3
  foreground: string;
4
  muted: string;
5
  grid: string
6
}

`PivotChartLabelContext`

1
interface PivotChartLabelContext {
2
  chartId: string;
3
  chartType: PivotChartType;
4
  kind: PivotChartLabelKind;
5
  defaultText: string;
6
  renderMode: 'chart' | 'preview';
7
  axis?: 'x' | 'y';
8
  category?: PivotChartCategory;
9
  series?: PivotChartSeries;
10
  categoryIndex?: number;
11
  seriesIndex?: number;
12
  value?: number | null;
13
  formattedValue?: string
14
}

`PivotChartLabelFormatter`

1
export type PivotChartLabelFormatter = (
2
  context: PivotChartLabelContext,
3
) => string | PivotChartLabelResult | null | undefined;

`PivotChartLabelKind`

1
export type PivotChartLabelKind =
2
  | 'title'
3
  | 'subtitle'
4
  | 'axisTitle'
5
  | 'axisTick'
6
  | 'category'
7
  | 'legend'
8
  | 'data'
9
  | 'annotation'
10
  | 'summary'
11
  | 'specialized';

`PivotChartLabelResult`

1
interface PivotChartLabelResult {
2
  text?: string;
3
  ariaLabel?: string;
4
  className?: string;
5
  style?: PivotChartLabelStyle;
6
  hidden?: boolean
7
}

`PivotChartLabelsOptions`

1
interface PivotChartLabelsOptions {
2
  /** Refines, replaces, or suppresses any visible SVG chart label. */
3
    formatter?: PivotChartLabelFormatter;
4
  /** Reusable typography overrides applied before formatter-specific styles. */
5
    styles?: Partial<Record<PivotChartLabelKind, PivotChartLabelStyle>>
6
}

`PivotChartLabelStyle`

1
interface PivotChartLabelStyle {
2
  fill?: string;
3
  fontFamily?: string;
4
  fontSize?: number | string;
5
  fontWeight?: number | string;
6
  fontStyle?: string;
7
  letterSpacing?: number | string;
8
  textDecoration?: string;
9
  opacity?: number;
10
  textAnchor?: 'start' | 'middle' | 'end'
11
}

`PivotChartRendererTheme`

1
export type PivotChartRendererTheme =
2
  | Partial<ChartTheme>
3
  | ((context: PivotChartRendererThemeContext) => Partial<ChartTheme>);

`PivotChartRendererThemeContext`

1
interface PivotChartRendererThemeContext {
2
  input: PivotChartRenderInput;
3
  theme: ChartTheme
4
}

`PivotChartsRendererOptions`

1
interface PivotChartsRendererOptions {
2
  /** Additional application class names applied to the chart SVG. */
3
    className?: string;
4
  palette?: readonly string[];
5
  categorySeparator?: string;
6
  fontFamily?: string;
7
  /** Overrides the resolved light or dark chart theme. */
8
    theme?: PivotChartRendererTheme;
9
  /** Customizes all chart text through one semantic label pipeline. */
10
    labels?: PivotChartLabelsOptions;
11
  imageEncoder?: (
12
      svg: SVGSVGElement,
13
      options: Required<Pick<PivotChartImageOptions, 'width' | 'height'>>,
14
    ) => Promise<string>;
15
  pdfEncoder?: (
16
      svg: SVGSVGElement,
17
      options: Required<Pick<PivotChartDownloadOptions, 'width' | 'height'>>,
18
    ) => Promise<string>;
19
  /** Disable tooltips or customize the built-in semantic tooltip renderer. */
20
    tooltip?: false | PivotChartTooltipOptions
21
}

`PivotChartUiOpenParams`

1
export type PivotChartUiOpenParams = Omit<PivotChartCreateParams, 'container'>;

`PivotChartUiMountParams`

1
export type PivotChartUiMountParams = PivotChartCreateParams;

`PivotChartsUiPlugin`

Dependencies

Required PivotChartsPlugin: Uses the headless Pivot Charts lifecycle and data APIs.
Optional ContextMenuPlugin: Contributes the optional Pivot Chart row-menu action.
Config integration grid.pivotChartsUi: Reads UI mounting and context-menu behavior from grid.pivotChartsUi.

1
class PivotChartsUiPlugin {
2
  /**
3
     * Opens a UI-owned modeless Pivot chart. The returned chart ref remains
4
     * managed by the headless plugin; closing the dialog destroys that ref.
5
     * If this grid already has an open chart dialog, it is focused and its
6
     * existing chart ref is returned.
7
     */
8
  async openChart(
9
    params: PivotChartUiOpenParams = {},
10
  ): Promise<PivotChartRef>;
11

12
  /**
13
     * Mounts the standard Pivot Chart controls inside an application-owned
14
     * container. Multiple embedded charts may coexist with the modeless dialog.
15
     * Destroying the returned chart ref removes the embedded UI.
16
     */
17
  async mountChart({
18
    container,
19
    ...params
20
  }: PivotChartUiMountParams): Promise<PivotChartRef>;
21
}

`PivotChartDialog`

1
export function PivotChartDialog({
2
  mode = 'dialog',
3
  model,
4
  series,
5
  dataset,
6
  renderer,
7
  supportedTypes,
8
  loading,
9
  empty,
10
  error,
11
  drillLoading = false,
12
  drillError,
13
  drillPendingLabel,
14
  drillCompletedLabel,
15
  downloadFormats,
16
  localeText,
17
  onUpdate,
18
  onRetry,
19
  onDrillBack = () => {},
20
  onDrillHome = () => {},
21
  onDrillNavigate = () => {},
22
  onDrillRetry = () => {},
23
  onDownload,
24
  onClose,
25
}: PivotChartDialogProps);

`PivotChartDialogProps`

1
interface PivotChartDialogProps {
2
  readonly mode?: 'dialog' | 'embedded';
3
  readonly model: PivotChartModel;
4
  readonly series: readonly PivotChartSeries[];
5
  readonly dataset?: PivotChartDataset;
6
  readonly renderer?: PivotChartRenderer;
7
  readonly supportedTypes: readonly PivotChartType[];
8
  readonly loading: boolean;
9
  readonly empty: boolean;
10
  readonly error?: Error;
11
  readonly drillLoading?: boolean;
12
  readonly drillError?: Error;
13
  readonly drillPendingLabel?: string;
14
  readonly drillCompletedLabel?: string;
15
  readonly downloadFormats: readonly PivotChartDownloadFormat[];
16
  readonly localeText: PivotChartsLocaleText;
17
  readonly onUpdate: (patch: PivotChartUpdatePatch) => void;
18
  readonly onRetry: () => void;
19
  readonly onDrillBack?: () => void;
20
  readonly onDrillHome?: () => void;
21
  readonly onDrillNavigate?: (frameIndex: number) => void;
22
  readonly onDrillRetry?: () => void;
23
  readonly onDownload: (format: PivotChartDownloadFormat) => void;
24
  readonly onClose?: () => void
25
}

`chartRenderers`

1
chartRenderers: Record<"line" | "area" | "kpi" | "groupedColumn" | "stackedColumn" | "normalizedColumn" | "groupedBar" | "stackedBar" | "normalizedBar" | "smoothLine" | "steppedLine" | "steppedArea" | "stackedArea" | "normalizedArea" | "pie" | "donut" | "treemap" | "sunburst" | "scatter" | "bubble" | "densityScatter" | "connectedScatter" | "columnLine" | "areaLine" | "rangeColumn" | "rangeBar" | "rangeArea" | "confidenceBand" | "errorInterval" | "waterfall" | "lollipop" | "bullet" | "semiDonut" | "rose" | "radarLine" | "radarArea" | "polarColumn" | "stackedPolarColumn" | "normalizedPolarColumn" | "radialBar" | "multiRingRadialBar" | "histogram" | "stripDot" | "heatmap" | "calendarHeatmap" | "icicle" | "circlePacking" | "funnel" | "pyramid" | "boxPlot" | "violin" | "rangeInterval" | "sankey" | "chord" | "candlestick" | "ohlc" | "volumePrice" | "gauge" | "progressGauge" | "waffle" | "smallMultiples" | "annotatedTimeSeries" | "timelineRange", PivotChartRenderFunction>;

`renderWaffle`

1
renderWaffle: PivotChartRenderFunction;

`renderHistogram`

1
renderHistogram: PivotChartRenderFunction;

`renderDotPlot`

1
renderDotPlot: PivotChartRenderFunction;

`renderStripDot`

1
renderStripDot: PivotChartRenderFunction;

`renderStripPlot`

1
renderStripPlot: PivotChartRenderFunction;

`renderSmallMultiples`

1
renderSmallMultiples: PivotChartRenderFunction;

`renderCandlestick`

1
renderCandlestick: PivotChartRenderFunction;

`renderOhlc`

1
renderOhlc: PivotChartRenderFunction;

`renderVolumePrice`

1
renderVolumePrice: PivotChartRenderFunction;

`renderChord`

1
renderChord: PivotChartRenderFunction;

`createFlowGraph`

The current Pivot dataset is a category-by-series matrix rather than an explicit edge list. Until a provider supplies the normalized flow view, this deterministic projection treats those two matrix axes as adjacent graph partitions: each positive finite cell becomes one directed edge from its category to its series. Aggregate categories and unconnected nodes are omitted, while original matrix indexes are retained for exact interaction.

1
export function createFlowGraph(
2
  dataset: PivotChartDataset,
3
  bindings: PivotChartBindings,
4
): PivotChartFlowGraph;

`PivotChartFlowEdge`

1
interface PivotChartFlowEdge {
2
  readonly id: string;
3
  readonly sourceId: string;
4
  readonly targetId: string;
5
  readonly value: number;
6
  readonly category: PivotChartCategory;
7
  readonly categoryIndex: number;
8
  readonly series: PivotChartSeries;
9
  readonly seriesIndex: number
10
}

`PivotChartFlowGraph`

1
interface PivotChartFlowGraph {
2
  readonly nodes: readonly PivotChartFlowNode[];
3
  readonly edges: readonly PivotChartFlowEdge[];
4
  readonly total: number
5
}

`PivotChartFlowNode`

1
interface PivotChartFlowNode {
2
  readonly id: string;
3
  readonly label: string;
4
  readonly kind: 'category' | 'series';
5
  readonly value: number;
6
  readonly category?: PivotChartCategory;
7
  readonly categoryIndex?: number;
8
  readonly series?: PivotChartSeries;
9
  readonly seriesIndex?: number
10
}

`renderSankey`

1
renderSankey: PivotChartRenderFunction;

`renderCirclePacking`

1
renderCirclePacking: PivotChartRenderFunction;

`renderIcicle`

1
renderIcicle: PivotChartRenderFunction;

`renderSunburst`

1
export function renderSunburst(context: RenderContext);

`renderTreemap`

1
export function renderTreemap(context: RenderContext);

`renderGauge`

1
renderGauge: PivotChartRenderFunction;

`renderKpi`

1
renderKpi: PivotChartRenderFunction;

`renderProgressGauge`

1
renderProgressGauge: PivotChartRenderFunction;

`renderCalendarHeatmap`

1
renderCalendarHeatmap: PivotChartRenderFunction;

`renderHeatmap`

1
renderHeatmap: PivotChartRenderFunction;

`renderMultiRingRadialBar`

1
renderMultiRingRadialBar: PivotChartRenderFunction;

`renderNormalizedPolarColumn`

1
renderNormalizedPolarColumn: PivotChartRenderFunction;

`renderPolarColumn`

1
renderPolarColumn: PivotChartRenderFunction;

`renderRadarArea`

1
renderRadarArea: PivotChartRenderFunction;

`renderRadarLine`

1
renderRadarLine: PivotChartRenderFunction;

`renderRadialBar`

1
renderRadialBar: PivotChartRenderFunction;

`renderRose`

1
renderRose: PivotChartRenderFunction;

`renderStackedPolarColumn`

1
renderStackedPolarColumn: PivotChartRenderFunction;

`renderFunnel`

1
renderFunnel: PivotChartRenderFunction;

`renderPyramid`

1
renderPyramid: PivotChartRenderFunction;

`renderBullet`

1
renderBullet: PivotChartRenderFunction;

`renderConfidenceBand`

1
renderConfidenceBand: PivotChartRenderFunction;

`renderErrorInterval`

1
renderErrorInterval: PivotChartRenderFunction;

`renderLollipop`

1
renderLollipop: PivotChartRenderFunction;

`renderRangeArea`

1
renderRangeArea: PivotChartRenderFunction;

`renderRangeBar`

1
renderRangeBar: PivotChartRenderFunction;

`renderRangeColumn`

1
renderRangeColumn: PivotChartRenderFunction;

`renderWaterfall`

1
renderWaterfall: PivotChartRenderFunction;

`renderBubble`

1
export function renderBubble(context: RenderContext);

`renderConnectedScatter`

1
renderConnectedScatter: PivotChartRenderFunction;

`renderDensityScatter`

1
renderDensityScatter: PivotChartRenderFunction;

`renderHexbin`

1
renderHexbin: PivotChartRenderFunction;

`renderScatter`

1
export function renderScatter(context: RenderContext);

`renderBoxPlot`

1
renderBoxPlot: PivotChartRenderFunction;

`renderRangeInterval`

1
renderRangeInterval: PivotChartRenderFunction;

`renderViolin`

1
renderViolin: PivotChartRenderFunction;

`collectStatisticalData`

1
export function collectStatisticalData(
2
  dataset: PivotChartDataset,
3
  seriesIds?: readonly string[],
4
): StatisticalDatum[];

`createDensitySamples`

1
export function createDensitySamples(
2
  observations: readonly StatisticalObservation[],
3
  requestedSampleCount = 33,
4
): DensitySample[];

`DensitySample`

1
interface DensitySample {
2
  readonly value: number;
3
  readonly density: number
4
}

`StatisticalDatum`

1
interface StatisticalDatum {
2
  readonly category: PivotChartCategory;
3
  readonly categoryIndex: number;
4
  readonly observations: readonly StatisticalObservation[];
5
  readonly count: number;
6
  readonly minimum: number;
7
  readonly lowerQuartile: number;
8
  readonly median: number;
9
  readonly upperQuartile: number;
10
  readonly maximum: number;
11
  readonly mean: number;
12
  readonly lowerWhisker: number;
13
  readonly upperWhisker: number;
14
  readonly outliers: readonly StatisticalObservation[];
15
  readonly representativeSeriesIndex: number
16
}

`StatisticalObservation`

1
interface StatisticalObservation {
2
  readonly value: number;
3
  readonly seriesIndex: number
4
}

`renderTimelineRange`

1
renderTimelineRange: PivotChartRenderFunction;

`renderAnnotatedTimeSeries`

1
renderAnnotatedTimeSeries: PivotChartRenderFunction;

`resolvePivotChartCellContext`

1
export function resolvePivotChartCellContext(
2
  cell?: ContextMenuCellContext,
3
): PivotChartCellContext | undefined;

`PivotChartCellContext`

1
interface PivotChartCellContext {
2
  initialScope: PivotChartInitialScope;
3
  seriesIds: string[];
4
  columnPath: PivotPath;
5
  measure: PivotChartMeasure;
6
  totals?: PivotChartTotalsMode;
7
  categoryMeasure?: Pick<PivotChartMeasure, 'prop' | 'aggregator'>
8
}

`resolveSpecializedSeriesBindings`

Resolves specialized measure channels only from explicit stable IDs or unambiguous semantic labels. Series position is deliberately never used.

1
export function resolveSpecializedSeriesBindings(
2
  dataset: PivotChartDataset,
3
  current: PivotChartBindings,
4
  requirements: readonly SpecializedBindingRequirement[],
5
): SpecializedBindingResolution;

`resolveMatrixFlowBindings`

1
export function resolveMatrixFlowBindings(
2
  dataset: PivotChartDataset,
3
  current: PivotChartBindings,
4
): {
5
  bindings: PivotChartBindings;
6
  missing: Array<'source' | 'target' | 'weight'>;
7
};

`boundSeriesIndex`

1
export function boundSeriesIndex(
2
  dataset: PivotChartDataset,
3
  bindings: PivotChartBindings,
4
  channel: PivotChartBindingChannel,
5
): number | undefined;

`SpecializedSeriesChannel`

1
export type SpecializedSeriesChannel =
2
  | 'low'
3
  | 'high'
4
  | 'open'
5
  | 'close'
6
  | 'volume'
7
  | 'actual'
8
  | 'target'
9
  | 'variance'
10
  | 'start'
11
  | 'end';

`SpecializedBindingRequirement`

1
interface SpecializedBindingRequirement {
2
  channel: SpecializedSeriesChannel;
3
  required: boolean
4
}

`SpecializedBindingResolution`

1
interface SpecializedBindingResolution {
2
  bindings: PivotChartBindings;
3
  missing: SpecializedSeriesChannel[]
4
}

`createPivotChartGeographicRendererInstance`

1
export function createPivotChartGeographicRendererInstance(
2
  pack: Pick<PivotChartGeographicCapabilityPack, 'load'>,
3
  initialInput: PivotChartGeographicRenderInput,
4
): PivotChartGeographicRendererInstance;

`PivotChartDataControls`

1
export function PivotChartDataControls({
2
  model,
3
  localeText,
4
  onUpdate,
5
}: PivotChartDataControlsProps);

`PivotChartDataTable`

1
export function PivotChartDataTable({
2
  dataset,
3
  labels,
4
}: PivotChartDataTableProps);

`PivotChartDataTableLabels`

1
interface PivotChartDataTableLabels {
2
  readonly regionAriaLabel: string;
3
  readonly tableCaption: string;
4
  readonly categoryHeader: string;
5
  readonly hierarchySeparator: string;
6
  readonly emptyValue: string;
7
  readonly formatNumber: (value: number) => string;
8
  readonly sortAscending: (columnLabel: string) => string;
9
  readonly sortDescending: (columnLabel: string) => string;
10
  readonly sortedAscending: (columnLabel: string) => string;
11
  readonly sortedDescending: (columnLabel: string) => string
12
}

`PivotChartDataTableProps`

1
interface PivotChartDataTableProps {
2
  readonly dataset: PivotChartDataset;
3
  readonly labels: PivotChartDataTableLabels
4
}

`PivotChartDialogHeader`

1
export function PivotChartDialogHeader({
2
  headerRef,
3
  closable = true,
4
  title,
5
  loading,
6
  downloadFormats,
7
  showingData,
8
  localeText,
9
  onToggleData,
10
  onDownload,
11
  onClose,
12
}: PivotChartDialogHeaderProps);

`PivotChartDialogSettings`

1
export function PivotChartDialogSettings({
2
  model,
3
  series,
4
  dataset,
5
  renderer,
6
  theme,
7
  visibleChartTypes,
8
  presentation,
9
  themeOptions,
10
  disabled,
11
  localeText,
12
  onPresentationChange,
13
  onPresentationCommit,
14
  onUpdate,
15
}: PivotChartDialogSettingsProps);

`PivotChartDialogTabs`

1
export function PivotChartDialogTabs({
2
  active,
3
  chartId,
4
  localeText,
5
  onChange,
6
}: PivotChartDialogTabsProps);

`PivotChartDialogTab`

1
export type PivotChartDialogTab = 'chart' | 'data' | 'customize';

`PivotChartDialogVisual`

1
export function PivotChartDialogVisual({
2
  loading,
3
  empty,
4
  error,
5
  dataset,
6
  showingData,
7
  drillState,
8
  drillLoading,
9
  drillError,
10
  drillPendingLabel,
11
  drillCompletedLabel,
12
  localeText,
13
  onRetry,
14
  onDrillNavigate,
15
  onDrillRetry,
16
}: PivotChartDialogVisualProps);

`PIVOT_CHART_THEME_VALUES`

1
PIVOT_CHART_THEME_VALUES: readonly ["auto", "default", "material", "compact", "darkMaterial", "darkCompact"];

`PivotChartPresentationChangeHandler`

1
export type PivotChartPresentationChangeHandler = <
2
  K extends keyof PivotChartPresentation,
3
>(
4
  key: K,
5
  value: PivotChartPresentation[K],
6
) => void;

`PivotChartThemeOption`

1
export type PivotChartThemeOption = readonly [value: string, label: string];

`PivotChartDrillToolbar`

1
export function PivotChartDrillToolbar({
2
  state,
3
  loading,
4
  error,
5
  pendingLabel,
6
  completedLabel,
7
  localeText,
8
  onNavigate,
9
  onRetry,
10
}: PivotChartDrillToolbarProps);

`PivotChartExportMenu`

1
export function PivotChartExportMenu({
2
  formats,
3
  disabled,
4
  localeText,
5
  onDownload,
6
}: PivotChartExportMenuProps);

`PivotChartGallery`

1
export function PivotChartGallery({
2
  model,
3
  dataset,
4
  series,
5
  renderer,
6
  supportedTypes,
7
  theme,
8
  localeText,
9
  onUpdate,
10
}: PivotChartGalleryProps);

`PivotChartOptionsControls`

1
export function PivotChartOptionsControls({
2
  model,
3
  localeText,
4
  onUpdate,
5
}: PivotChartOptionsControlsProps);

`PivotChartPresentationControls`

1
export function PivotChartPresentationControls({
2
  chartType,
3
  presentation,
4
  localeText,
5
  onChange,
6
  onCommit,
7
}: PivotChartPresentationControlsProps);

`PivotChartPreview`

1
export function PivotChartPreview({
2
  definition,
3
  renderer,
4
  theme,
5
  localeText,
6
}: PivotChartPreviewProps);

`clearPivotChartPreviewCache`

1
export function clearPivotChartPreviewCache();

`PivotChartRelationshipControls`

1
export function PivotChartRelationshipControls({
2
  model,
3
  series,
4
  localeText,
5
  onUpdate,
6
}: PivotChartRelationshipControlsProps);

`PivotChartSeriesControl`

1
export function PivotChartSeriesControl({
2
  model,
3
  series,
4
  localeText,
5
  onUpdate,
6
}: PivotChartSeriesControlProps);

`PivotChartThemeControl`

1
export function PivotChartThemeControl({
2
  model,
3
  themeOptions,
4
  localeText,
5
  onUpdate,
6
}: PivotChartThemeControlProps);

`PivotChartTypeControl`

1
export function PivotChartTypeControl({
2
  model,
3
  dataset,
4
  series,
5
  renderer,
6
  theme,
7
  visibleChartTypes,
8
  localeText,
9
  onUpdate,
10
}: PivotChartTypeControlProps);

`renderAxes`

1
export function renderAxes(
2
  context: RenderContext,
3
  scale: Scale,
4
  horizontal: boolean,
5
  percentage = false,
6
);

`renderXYAxes`

1
export function renderXYAxes(
2
  context: RenderContext,
3
  xScale: Scale,
4
  yScale: Scale,
5
  defaultTitles?: { x: string; y: string },
6
);

`appendCategoryLabel`

1
export function appendCategoryLabel(
2
  context: RenderContext,
3
  category: PivotChartCategory,
4
  categoryIndex: number,
5
  categorySize: number,
6
  horizontal: boolean,
7
  origin?: number,
8
);

`DEFAULT_WIDTH`

1
DEFAULT_WIDTH: 960;

`DEFAULT_HEIGHT`

1
DEFAULT_HEIGHT: 540;

`DEFAULT_PALETTE`

1
DEFAULT_PALETTE: readonly ["#4f8fdc", "#f59e42", "#49a35a", "#38b6d4", "#e7c900", "#8b6fc0", "#e66b77", "#5aa69a"];

`shouldRenderCategoryLabel`

1
export function shouldRenderCategoryLabel(
2
  categoryIndex: number,
3
  categoryCount: number,
4
  categorySize: number,
5
  horizontal: boolean,
6
): boolean;

`shouldRenderDataLabel`

1
export function shouldRenderDataLabel(
2
  categoryIndex: number,
3
  seriesIndex: number,
4
  categoryCount: number,
5
  seriesCount: number,
6
): boolean;

`encodeChartImage`

1
export async function encodeChartImage(
2
  svg: SVGSVGElement,
3
  options: ChartExportSizeOptions,
4
  rendererOptions: PivotChartsRendererOptions,
5
  localeText: PivotChartsLocaleText,
6
);

`encodeChartPdf`

1
export async function encodeChartPdf(
2
  svg: SVGSVGElement,
3
  options: ChartExportSizeOptions,
4
  rendererOptions: PivotChartsRendererOptions,
5
  localeText: PivotChartsLocaleText,
6
);

`normalizeFileName`

1
export function normalizeFileName(
2
  fileName: string | undefined,
3
  fallback: string,
4
  format: PivotChartDownloadFormat,
5
);

`initializeDatumInteractions`

Starts a fresh delegated interaction scope for one SVG render.

Dense charts use a roving tab stop so the chart remains reachable without placing hundreds or thousands of marks in the document tab order.

1
export function initializeDatumInteractions(
2
  svg: SVGSVGElement,
3
  input: PivotChartRenderInput,
4
);

`makeDatumInteractive`

1
export function makeDatumInteractive(
2
  element: SVGElement,
3
  input: PivotChartRenderInput,
4
  category: PivotChartCategory,
5
  series: PivotChartSeries,
6
  value: number | null,
7
  label: string,
8
  description?: {
9
    ariaLabel: string;
10
    title: string;
11
    channelValues?: PivotChartNodeClick['channelValues'];
12
    channelSeries?: PivotChartNodeClick['channelSeries'];
13
    channelDisplayValues?: DatumDescription['channelDisplayValues'];
14
  },
15
);

`getDatumDescription`

1
export function getDatumDescription(element: SVGElement);

`DatumDescription`

1
interface DatumDescription {
2
  readonly category: PivotChartCategory;
3
  readonly series: PivotChartSeries;
4
  readonly value: number | null;
5
  readonly displayValue: string;
6
  readonly title: string;
7
  readonly categoryIndex?: number;
8
  readonly seriesIndex?: number;
9
  readonly channelValues?: PivotChartNodeClick['channelValues'];
10
  readonly channelSeries?: PivotChartNodeClick['channelSeries'];
11
  readonly channelDisplayValues?: Partial<
12
      Record<'x' | 'y' | 'size', string>
13
    >
14
}

`applyChartLabelCustomization`

1
export function applyChartLabelCustomization(
2
  svg: SVGSVGElement,
3
  input: PivotChartRenderInput,
4
  options: PivotChartsRendererOptions,
5
  legendKind: 'series' | 'category' | 'none',
6
);

`resolveLegendLayout`

1
export function resolveLegendLayout(
2
  width: number,
3
  height: number,
4
  itemCount: number,
5
  position: LegendLayout['position'],
6
): LegendLayout;

`renderLegend`

1
export function renderLegend(
2
  context: RenderContext,
3
  width: number,
4
  height: number,
5
  layout: LegendLayout,
6
  kind: 'series' | 'category',
7
);

`LegendLayout`

1
interface LegendLayout {
2
  readonly position: 'top' | 'right' | 'bottom' | 'left';
3
  readonly columns: number;
4
  readonly itemWidth: number;
5
  readonly visibleItemCount: number;
6
  readonly reservedHeight: number;
7
  readonly reservedWidth: number
8
}

`arcPath`

1
export function arcPath(
2
  centerX: number,
3
  centerY: number,
4
  innerRadius: number,
5
  outerRadius: number,
6
  startAngle: number,
7
  endAngle: number,
8
): string;

`polarPoint`

1
export function polarPoint(
2
  centerX: number,
3
  centerY: number,
4
  radius: number,
5
  angle: number,
6
);

`polarAngle`

1
export function polarAngle(
2
  index: number,
3
  count: number,
4
  offset = -Math.PI / 2,
5
): number;

`renderChart`

1
export function renderChart(
2
  svg: SVGSVGElement,
3
  input: PivotChartRenderInput,
4
  options: PivotChartsRendererOptions,
5
);

`createSvg`

1
export function createSvg<K extends keyof SVGElementTagNameMap>(
2
  document: Document,
3
  name: K,
4
  attributes: Record<string, string | number> = {},
5
);

`setAttributes`

1
export function setAttributes(
2
  element: Element,
3
  attributes: Record<string, string | number>,
4
);

`appendRect`

1
export function appendRect(
2
  svg: SVGElement,
3
  x: number,
4
  y: number,
5
  width: number,
6
  height: number,
7
  fill: string,
8
  radius = 0,
9
);

`appendLine`

1
export function appendLine(
2
  svg: SVGElement,
3
  x1: number,
4
  y1: number,
5
  x2: number,
6
  y2: number,
7
  stroke: string,
8
);

`appendText`

1
export function appendText(
2
  svg: SVGElement,
3
  x: number,
4
  y: number,
5
  value: string,
6
  attributes: Record<string, string | number>,
7
);

`resolveTheme`

1
export function resolveTheme(
2
  input: PivotChartRenderInput,
3
  override?: PivotChartRendererTheme,
4
): ChartTheme;;

`initializeChartTooltip`

1
export function initializeChartTooltip(
2
  svg: SVGSVGElement,
3
  input: PivotChartRenderInput,
4
  options: PivotChartsRendererOptions,
5
  categorySeparator: string,
6
);

`destroyChartTooltip`

1
export function destroyChartTooltip(svg: SVGSVGElement);

`ChartBounds`

1
interface ChartBounds {
2
  left: number;
3
  top: number;
4
  width: number;
5
  height: number
6
}

`Scale`

1
interface Scale {
2
  min: number;
3
  max: number;
4
  position(value: number): number
5
}

`RenderContext`

1
interface RenderContext {
2
  input: PivotChartRenderInput;
3
  svg: SVGSVGElement;
4
  bounds: ChartBounds;
5
  theme: ChartTheme;
6
  palette: readonly string[];
7
  categorySeparator: string
8
}

`PivotChartRenderFunction`

1
export type PivotChartRenderFunction = (context: RenderContext) => void;

`PivotChartTooltipOptions`

1
interface PivotChartTooltipOptions {
2
  /** Delay before a pointer tooltip opens. Keyboard tooltips open immediately. */
3
    showDelayMs?: number;
4
  /** Delay before a pointer tooltip closes. */
5
    hideDelayMs?: number;
6
  /** Keep an open pointer tooltip near the cursor. */
7
    followPointer?: boolean;
8
  /** Additional application class names applied to the tooltip root. */
9
    className?: string;
10
  /** Replaces or refines the default semantic tooltip content. */
11
    formatter?: PivotChartTooltipFormatter
12
}

`assertSupportedType`

1
export function assertSupportedType(
2
  chartType: PivotChartType,
3
  localeText: PivotChartsLocaleText,
4
);

`assertChartShape`

1
export function assertChartShape(
2
  chartType: PivotChartType,
3
  dataset: PivotChartDataset,
4
  localeText: PivotChartsLocaleText,
5
  bindings = {},
6
);

`assertAlive`

1
export function assertAlive(
2
  destroyed: boolean,
3
  localeText: PivotChartsLocaleText,
4
);

`createValueScale`

1
export function createValueScale(
2
  rows: Array<Array<number | null>>,
3
  stacked: boolean,
4
  length: number,
5
  normalized = false,
6
): Scale;

`createContinuousScale`

1
export function createContinuousScale(
2
  values: readonly number[],
3
  length: number,
4
): Scale;

`normalizeRows`

1
export function normalizeRows(rows: Array<Array<number | null>>);

`cumulativeRows`

1
export function cumulativeRows(rows: Array<Array<number | null>>);

`createStackedRows`

1
export function createStackedRows(rows: Array<Array<number | null>>);

`displayValue`

1
export function displayValue(
2
  dataset: PivotChartDataset,
3
  categoryIndex: number,
4
  seriesIndex: number,
5
  localeText: PivotChartsLocaleText,
6
);

`flattenCategory`

1
export function flattenCategory(
2
  category: PivotChartCategory,
3
  separator: string,
4
);

`formatNumber`

1
export function formatNumber(
2
  value: number | null,
3
  localeText: PivotChartsLocaleText,
4
);

`renderAreaLine`

1
renderAreaLine: PivotChartRenderFunction;

`renderArea`

1
renderArea: PivotChartRenderFunction;

`renderBarChart`

1
export function renderBarChart(
2
  context: RenderContext,
3
  options: BarChartOptions,
4
);

`BarChartOptions`

1
interface BarChartOptions {
2
  readonly orientation: 'horizontal' | 'vertical';
3
  readonly stacking: 'grouped' | 'stacked' | 'normalized'
4
}

`renderColumnLine`

1
renderColumnLine: PivotChartRenderFunction;

`renderCombinationChart`

1
export function renderCombinationChart(
2
  context: RenderContext,
3
  options: CombinationChartOptions,
4
);

`CombinationChartOptions`

1
interface CombinationChartOptions {
2
  readonly primary: 'column' | 'area'
3
}

`renderDonut`

1
renderDonut: PivotChartRenderFunction;

`renderGroupedBar`

1
renderGroupedBar: PivotChartRenderFunction;

`renderGroupedColumn`

1
renderGroupedColumn: PivotChartRenderFunction;

`renderLineAreaChart`

1
export function renderLineAreaChart(
2
  context: RenderContext,
3
  options: LineAreaChartOptions,
4
);

`LineAreaChartOptions`

1
interface LineAreaChartOptions {
2
  readonly area: boolean;
3
  readonly interpolation: LineAreaInterpolation;
4
  readonly stacking: 'none' | 'stacked' | 'normalized'
5
}

`createLinePath`

1
export function createLinePath(
2
  points: readonly LineAreaPoint[],
3
  interpolation: LineAreaInterpolation,
4
): string;

`createAreaPath`

1
export function createAreaPath(
2
  top: readonly LineAreaPoint[],
3
  baseline: readonly LineAreaPoint[],
4
  interpolation: LineAreaInterpolation,
5
): string;

`LineAreaPoint`

1
interface LineAreaPoint {
2
  readonly x: number;
3
  readonly y: number
4
}

`LineAreaInterpolation`

1
export type LineAreaInterpolation = 'linear' | 'smooth' | 'step';

`renderLine`

1
renderLine: PivotChartRenderFunction;

`renderNormalizedArea`

1
renderNormalizedArea: PivotChartRenderFunction;

`renderNormalizedBar`

1
renderNormalizedBar: PivotChartRenderFunction;

`renderNormalizedColumn`

1
renderNormalizedColumn: PivotChartRenderFunction;

`renderPie`

1
renderPie: PivotChartRenderFunction;

`renderPolarChart`

1
export function renderPolarChart(
2
  context: RenderContext,
3
  options: PolarChartOptions,
4
);

`PolarChartOptions`

1
interface PolarChartOptions {
2
  readonly donut: boolean;
3
  readonly startAngle?: number;
4
  readonly sweepAngle?: number;
5
  readonly mark?: string
6
}

`renderSemiDonut`

1
renderSemiDonut: PivotChartRenderFunction;

`renderSmoothLine`

1
renderSmoothLine: PivotChartRenderFunction;

`renderStackedArea`

1
renderStackedArea: PivotChartRenderFunction;

`renderStackedBar`

1
renderStackedBar: PivotChartRenderFunction;

`renderStackedColumn`

1
renderStackedColumn: PivotChartRenderFunction;

`renderSteppedArea`

1
renderSteppedArea: PivotChartRenderFunction;

`renderSteppedLine`

1
renderSteppedLine: PivotChartRenderFunction;

`createWaffleSlices`

1
export function createWaffleSlices(
2
  dataset: PivotChartDataset,
3
  seriesId?: string,
4
  cellCount = 100,
5
): WaffleSlice[];

`WaffleSlice`

1
interface WaffleSlice {
2
  readonly category: PivotChartCategory;
3
  readonly categoryIndex: number;
4
  readonly series: PivotChartSeries;
5
  readonly seriesIndex: number;
6
  readonly value: number;
7
  readonly cells: number
8
}

`collectDistributionData`

1
export function collectDistributionData(
2
  dataset: PivotChartDataset,
3
  seriesId?: string,
4
): DistributionDatum[];

`createHistogramBins`

1
export function createHistogramBins(
2
  data: readonly DistributionDatum[],
3
  requestedBinCount?: number,
4
): HistogramBin[];

`DistributionDatum`

1
interface DistributionDatum {
2
  category: PivotChartCategory;
3
  categoryIndex: number;
4
  series: PivotChartSeries;
5
  seriesIndex: number;
6
  value: number
7
}

`HistogramBin`

1
interface HistogramBin {
2
  index: number;
3
  start: number;
4
  end: number;
5
  count: number;
6
  mean: number;
7
  data: DistributionDatum[]
8
}

`renderPriceSeries`

1
export function renderPriceSeries(
2
  context: RenderContext,
3
  options: PriceRenderOptions,
4
);

`PriceMarkKind`

1
export type PriceMarkKind = 'candlestick' | 'ohlc';

`PriceRenderOptions`

1
interface PriceRenderOptions {
2
  readonly kind: PriceMarkKind;
3
  readonly bounds?: ChartBounds;
4
  readonly attributePrefix: string;
5
  readonly renderAxes?: boolean;
6
  readonly renderCategoryLabels?: boolean
7
}

`collectFinancialData`

1
export function collectFinancialData(
2
  dataset: PivotChartDataset,
3
  bindings: PivotChartBindings,
4
  requireVolume = false,
5
): FinancialDatum[];

`FinancialDatum`

1
interface FinancialDatum {
2
  readonly categoryIndex: number;
3
  readonly open: number;
4
  readonly high: number;
5
  readonly low: number;
6
  readonly close: number;
7
  readonly volume?: number;
8
  readonly openSeriesIndex: number;
9
  readonly highSeriesIndex: number;
10
  readonly lowSeriesIndex: number;
11
  readonly closeSeriesIndex: number;
12
  readonly volumeSeriesIndex?: number
13
}

`collectHierarchyValues`

1
export function collectHierarchyValues(
2
  dataset: PivotChartDataset,
3
): readonly HierarchyCategoryValue[];

`commonCategoryPrefix`

1
export function commonCategoryPrefix(
2
  categories: readonly PivotChartCategory[],
3
): readonly string[];

`HierarchySeriesValue`

1
interface HierarchySeriesValue {
2
  readonly category: PivotChartCategory;
3
  readonly categoryIndex: number;
4
  readonly series: PivotChartSeries;
5
  readonly seriesIndex: number;
6
  readonly value: number
7
}

`HierarchyCategoryValue`

1
interface HierarchyCategoryValue {
2
  readonly category: PivotChartCategory;
3
  readonly categoryIndex: number;
4
  readonly total: number;
5
  readonly values: readonly HierarchySeriesValue[]
6
}

`renderGaugeChart`

1
export function renderGaugeChart(
2
  context: RenderContext,
3
  options: GaugeOptions,
4
);

`GaugeOptions`

1
interface GaugeOptions {
2
  readonly kind: 'semi' | 'radial';
3
  readonly attributePrefix: string
4
}

`resolveKpiLayouts`

1
export function resolveKpiLayouts(
2
  bounds: ChartBounds,
3
  count: number,
4
): KpiLayout[];

`KpiLayout` (Extended from `kpi-layout.ts`)

1
interface KpiLayout {
2
  readonly index: number
3
}

`collectKpiData`

1
export function collectKpiData(
2
  dataset: PivotChartDataset,
3
  bindings: PivotChartBindings,
4
): KpiDatum[];

`KpiDatum`

1
interface KpiDatum {
2
  readonly categoryIndex: number;
3
  readonly actual: number;
4
  readonly target: number;
5
  readonly variance: number;
6
  readonly progress: number;
7
  readonly actualSeriesIndex: number;
8
  readonly targetSeriesIndex: number;
9
  readonly varianceSeriesIndex?: number
10
}

`createHeatmapBuckets`

1
export function createHeatmapBuckets(
2
  dataset: PivotChartDataset,
3
  maximumRows: number,
4
  maximumColumns: number,
5
): HeatmapBucket[];

`collectCalendarData`

1
export function collectCalendarData(
2
  dataset: PivotChartDataset,
3
  seriesId?: string,
4
): CalendarDatum[];

`HeatmapBucket`

1
interface HeatmapBucket {
2
  row: number;
3
  column: number;
4
  rowStart: number;
5
  rowEnd: number;
6
  columnStart: number;
7
  columnEnd: number;
8
  count: number;
9
  value: number;
10
  category: PivotChartCategory;
11
  series: PivotChartSeries
12
}

`CalendarDatum`

1
interface CalendarDatum {
2
  category: PivotChartCategory;
3
  categoryIndex: number;
4
  series: PivotChartSeries;
5
  seriesIndex: number;
6
  value: number;
7
  epochDay: number;
8
  day: number;
9
  week: number
10
}

`renderPolarColumnChart`

1
export function renderPolarColumnChart(
2
  context: RenderContext,
3
  options: PolarColumnOptions,
4
);

`PolarColumnMode`

1
export type PolarColumnMode = 'grouped' | 'stacked' | 'normalized';

`PolarColumnOptions`

1
interface PolarColumnOptions {
2
  mode: PolarColumnMode
3
}

`resolvePolarLayout`

1
export function resolvePolarLayout(
2
  context: RenderContext,
3
  labelPadding = 26,
4
): PolarLayout;

`finitePositiveMaximum`

1
export function finitePositiveMaximum(
2
  values: ReadonlyArray<ReadonlyArray<number | null>>,
3
  categoryIndexes?: readonly number[],
4
): number;

`appendPolarGrid`

1
export function appendPolarGrid(
2
  context: RenderContext,
3
  layout: PolarLayout,
4
  axes = true,
5
);

`valueAt`

1
export function valueAt(
2
  context: RenderContext,
3
  categoryIndex: number,
4
  seriesIndex: number,
5
): number | null;

`PolarLayout`

1
interface PolarLayout {
2
  centerX: number;
3
  centerY: number;
4
  radius: number;
5
  categoryIndexes: number[]
6
}

`renderRadarChart`

1
export function renderRadarChart(
2
  context: RenderContext,
3
  options: RadarOptions,
4
);

`RadarOptions`

1
interface RadarOptions {
2
  area: boolean
3
}

`renderRadialBarChart`

1
export function renderRadialBarChart(
2
  context: RenderContext,
3
  options: RadialBarOptions,
4
);

`RadialBarOptions`

1
interface RadialBarOptions {
2
  multiRing: boolean
3
}

`renderProcessChart`

1
export function renderProcessChart(
2
  context: RenderContext,
3
  shape: ProcessShape,
4
);

`createProcessBands`

1
export function createProcessBands(
2
  values: readonly number[],
3
  bounds: ProcessBounds,
4
  shape: ProcessShape,
5
): readonly ProcessBand[];

`ProcessShape`

1
export type ProcessShape = 'funnel' | 'pyramid';

`ProcessBounds`

1
interface ProcessBounds {
2
  readonly left: number;
3
  readonly top: number;
4
  readonly width: number;
5
  readonly height: number
6
}

`ProcessBand`

1
interface ProcessBand {
2
  readonly index: number;
3
  readonly value: number;
4
  readonly top: number;
5
  readonly bottom: number;
6
  readonly topWidth: number;
7
  readonly bottomWidth: number;
8
  readonly points: string
9
}

`collectProcessStages`

1
export function collectProcessStages(
2
  dataset: PivotChartDataset,
3
): readonly ProcessStage[];

`ProcessStage`

1
interface ProcessStage {
2
  readonly category: PivotChartCategory;
3
  readonly categoryIndex: number;
4
  readonly series: PivotChartSeries;
5
  readonly seriesIndex: number;
6
  readonly value: number
7
}

`renderRangeChart`

1
export function renderRangeChart(
2
  context: RenderContext,
3
  options: RangeChartOptions,
4
);

`RangeChartOptions`

1
interface RangeChartOptions {
2
  readonly kind: 'bar' | 'area' | 'interval';
3
  readonly orientation?: 'horizontal' | 'vertical';
4
  readonly valueMode?: RangeValueMode;
5
  readonly attribute: string
6
}

`collectRangeData`

1
export function collectRangeData(
2
  dataset: PivotChartDataset,
3
  bindings: PivotChartBindings,
4
  mode: RangeValueMode = 'bounds',
5
): RangeDatum[];

`RangeDatum`

1
interface RangeDatum {
2
  readonly categoryIndex: number;
3
  readonly lower: number;
4
  readonly upper: number;
5
  readonly center?: number;
6
  readonly lowerSeriesIndex: number;
7
  readonly upperSeriesIndex: number;
8
  readonly centerSeriesIndex?: number
9
}

`RangeValueMode`

1
export type RangeValueMode = 'bounds' | 'centerBounds';

`createDensityBins`

1
export function createDensityBins(
2
  points: readonly DensityPoint[],
3
  radius: number,
4
): DensityBin[];

`DensityPoint`

1
interface DensityPoint {
2
  category: PivotChartCategory;
3
  categoryIndex: number;
4
  xSeries: PivotChartSeries;
5
  xSeriesIndex: number;
6
  ySeries: PivotChartSeries;
7
  ySeriesIndex: number;
8
  x: number;
9
  y: number;
10
  plotX: number;
11
  plotY: number
12
}

`DensityBin`

1
interface DensityBin {
2
  column: number;
3
  row: number;
4
  count: number;
5
  x: number;
6
  y: number;
7
  plotX: number;
8
  plotY: number;
9
  points: DensityPoint[]
10
}

`renderRelationshipChart`

1
export function renderRelationshipChart(
2
  context: RenderContext,
3
  options: RelationshipChartOptions,
4
);

`RelationshipChartOptions`

1
interface RelationshipChartOptions {
2
  bubble: boolean
3
}

`prepareStatisticalChart`

1
export function prepareStatisticalChart(
2
  context: RenderContext,
3
  options?: {
4
    valueExtent?: (datum: StatisticalDatum) => readonly [number, number];
5
  },
6
): StatisticalChartLayout | undefined;

`appendStatisticalCategoryLabels`

1
export function appendStatisticalCategoryLabels(
2
  context: RenderContext,
3
  categorySize: number,
4
);

`statisticalCategoryCenter`

1
export function statisticalCategoryCenter(
2
  context: RenderContext,
3
  categoryIndex: number,
4
  categorySize: number,
5
);

`statisticalValueY`

1
export function statisticalValueY(
2
  context: RenderContext,
3
  scale: StatisticalChartLayout['scale'],
4
  value: number,
5
);

`StatisticalChartLayout`

1
interface StatisticalChartLayout {
2
  readonly data: StatisticalDatum[];
3
  readonly scale: ReturnType<typeof createValueScale>;
4
  readonly categorySize: number
5
}

Pivot Charts

Module Extensions

HTMLRevoGridElement (Extended from global)

HTMLRevoGridElementEventMap (Extended from global)

Plugin API

toPivotChartError

PivotChartErrorCode

PivotChartError

PIVOT_CHART_CREATED_EVENT

PIVOT_CHART_UPDATED_EVENT

PIVOT_CHART_DESTROYED_EVENT

PIVOT_CHART_NODE_CLICK_EVENT

PIVOT_CHART_ERROR_EVENT

PIVOT_CHART_BEFORE_DRILL_EVENT

PIVOT_CHART_DRILL_START_EVENT

PIVOT_CHART_DRILLED_EVENT

PIVOT_CHART_DRILL_ERROR_EVENT

PIVOT_CHART_DRILL_RESET_EVENT

PIVOT_CHART_DRILL_SYNC_EVENT

createPivotChartAnalyticalFrame

ensurePivotChartAnalyticalFrame

PIVOT_CHART_CATEGORY_FIELD_ID

PIVOT_CHART_SERIES_FIELD_ID

getPivotChartDefinition

PivotChartFamily

PivotChartDataChannel

PivotChartChannelRequirement

PivotChartDefinition

PIVOT_CHART_DEFINITIONS

PivotChartType

PIVOT_CHART_TYPES

getPivotChartCatalogExtensionDefinitions

PivotChartCatalogExtensionDefinition

evaluatePivotChartCatalog

evaluatePivotChartCompatibility

resolveRelationshipBindings

PivotChartCompatibilityStatus

PivotChartCompatibilityReason

PivotChartCompatibility

PivotChartCompatibilityContext

createInitialRowDrillState

canDrillIntoCategory

canDrillIntoSeries

canDrillIntoTarget

createRowDrillFrame

appendRowDrillFrame

appendDrillFrame

drillToFrame

getParentDrillState

reconcileDrillState

createRootPivotChartDrillState

parsePivotChartModel

clonePivotChartModel

mountPivotChart

PivotChartMountControls

PivotChartMountParams (Extended from index.ts)

createPivotChartOptionsSchema

parsePivotChartOptions

resolvePivotChartOption

PivotChartOptionKey

PivotChartBooleanOptionDefinition

PivotChartRangeOptionDefinition

PivotChartOptionDefinition

PivotChartOptionsSchema

projectPivotChartDataset

projectPivotChartSemanticSlice

PIVOT_CHART_MODEL_VERSION

PivotChartTotalsMode

PivotChartTheme

PivotChartUpdateReason

PivotChartLegendPosition

PivotChartAxis

PivotChartDrillSyncMode

PivotChartLimits

DEFAULT_PIVOT_CHART_LIMITS

PivotChartMeasure

PivotChartMeasureSelection

PivotChartMemberKind

PivotChartHierarchyLevel

PivotChartHierarchyDefinition