@finos/perspective-viewer
Version:
The `<perspective-viewer>` Custom Element, frontend for Perspective.js
103 lines (102 loc) • 5 kB
TypeScript
import type { Aggregate } from "./Aggregate.js";
import type { ColumnConfigValues } from "./ColumnConfigValues.js";
import type { Expressions } from "./Expressions.js";
import type { Filter } from "./Filter.js";
import type { FilterReducer } from "./FilterReducer.js";
import type { OptionalUpdate } from "./OptionalUpdate.js";
import type { PluginConfig } from "./PluginConfig.js";
import type { Sort } from "./Sort.js";
export type ViewerConfigUpdate = {
version?: OptionalUpdate<string>;
plugin?: OptionalUpdate<string>;
title?: OptionalUpdate<string>;
theme?: OptionalUpdate<string>;
settings?: OptionalUpdate<boolean>;
plugin_config?: PluginConfig | null;
columns_config?: OptionalUpdate<{
[key in string]?: ColumnConfigValues;
}>;
/**
* A group by _groups_ the dataset by the unique values of each column used
* as a group by - a close analogue in SQL to the `GROUP BY` statement.
* The underlying dataset is aggregated to show the values belonging to
* each group, and a total row is calculated for each group, showing
* the currently selected aggregated value (e.g. `sum`) of the column.
* Group by are useful for hierarchies, categorizing data and
* attributing values, i.e. showing the number of units sold based on
* State and City. In Perspective, group by are represented as an array
* of string column names to pivot, are applied in the order provided;
* For example, a group by of `["State", "City", "Postal Code"]` shows
* the values for each Postal Code, which are grouped by City,
* which are in turn grouped by State.
*/
group_by?: Array<string>;
/**
* A split by _splits_ the dataset by the unique values of each column used
* as a split by. The underlying dataset is not aggregated, and a new
* column is created for each unique value of the split by. Each newly
* created column contains the parts of the dataset that correspond to
* the column header, i.e. a `View` that has `["State"]` as its split
* by will have a new column for each state. In Perspective, Split By
* are represented as an array of string column names to pivot.
*/
split_by?: Array<string>;
/**
* The `columns` property specifies which columns should be included in the
* [`crate::View`]'s output. This allows users to show or hide a specific
* subset of columns, as well as control the order in which columns
* appear to the user. This is represented in Perspective as an array
* of string column names.
*/
columns?: Array<string | null>;
/**
* The `filter` property specifies columns on which the query can be
* filtered, returning rows that pass the specified filter condition.
* This is analogous to the `WHERE` clause in SQL. There is no limit on
* the number of columns where `filter` is applied, but the resulting
* dataset is one that passes all the filter conditions, i.e. the
* filters are joined with an `AND` condition.
*
* Perspective represents `filter` as an array of arrays, with the values
* of each inner array being a string column name, a string filter
* operator, and a filter operand in the type of the column.
*/
filter?: Array<Filter>;
/**
* The `sort` property specifies columns on which the query should be
* sorted, analogous to `ORDER BY` in SQL. A column can be sorted
* regardless of its data type, and sorts can be applied in ascending
* or descending order. Perspective represents `sort` as an array of
* arrays, with the values of each inner array being a string column
* name and a string sort direction. When `column-pivots` are applied,
* the additional sort directions `"col asc"` and `"col desc"` will
* determine the order of pivot columns groups.
*/
sort?: Array<Sort>;
/**
* The `expressions` property specifies _new_ columns in Perspective that
* are created using existing column values or arbitary scalar values
* defined within the expression. In `<perspective-viewer>`,
* expressions are added using the "New Column" button in the side
* panel.
*/
expressions?: Expressions;
/**
* Aggregates perform a calculation over an entire column, and are
* displayed when one or more [Group By](#group-by) are applied to the
* `View`. Aggregates can be specified by the user, or Perspective will
* use the following sensible default aggregates based on column type:
*
* - "sum" for `integer` and `float` columns
* - "count" for all other columns
*
* Perspective provides a selection of aggregate functions that can be
* applied to columns in the `View` constructor using a dictionary of
* column name to aggregate function name.
*/
aggregates?: {
[key in string]?: Aggregate;
};
group_by_depth?: number;
filter_op?: FilterReducer;
};