4.2.11Displays the about popup. There is no requirement concerning its availability (it can be used anywhere).
Type: Object
{
key: 'about',
args: {}
}
Version of the package and the Content Server
Type: Object
Build an action offered to users in several places of the UI.
For example in the title bar of a dock in a dashboard, or in context menus or other user event handlers.
Most of its methods are optional but one, execute. The methods are given different payloads depending on the
situation in which they are instantiated (see ActionSituation to have a list of the different situations).
Type: Object
(function (event: AnyEvent, actionPayload: ActionPayload): void)
: Called when the action is being interacted with.
(function (actionPayload: ActionPayload): (string | number)?)
: Returns a number or a string that will be displayed inside a badge on the
bottom left corner of the icon. Not implementing this function means that no badge will be displayed.
(function (actionPayload: ActionPayload): TranslationPayload?)
: Returns the caption of the action. Defaults to 'errors.noCaption'.
(function (actionPayload: ActionPayload): string?)
: Returns the icon key for the action. Default to having no icon.
(function (actionPayload: ActionPayload): boolean?)
: Returns whether the action should be present in the UI. This can
be used to hide actions dynamically based on the conditions in which it is used. Defaults to true.
(function (actionPayload: ActionPayload): boolean?)
: Returns whether the action should be disabled if present. This comes
on top of isAvailable in order to still display the action but in a disabled mode. Defaults to false.
(function (actionPayload: ActionPayload): void?)
: Called when the action is loaded in the UI.
(function (actionPayload: ActionPayload): void?)
: Called when the action is unloaded from the UI.
Type: Object
Type: (DockActionPayload | ChartHandlerActionPayload | FeaturedValuesHandlerActionPayload | StandaloneActionPayload | TabularHandlerActionPayload | TreeHandlerActionPayload)
Type:
("chart-handler" | "dock-action" | "featured-values-handler" | "standalone" | "tabular-handler" | "tree-handler")
Type: Object
(string)
: the key of the originating filter.
(HierarchyUniqueName)
: the hierarchy of the cube of the query on which this filter applies.
(FilterValueType)
: the value of the filter.
Agent registered to an ActiveMonitor Server
Type: Object
Details about connection to an agent
Type: Object
(Url)
: url to reach the agent
Map Site to agent
Type: Object<string, ActiveMonitorAgent>
Alert received from an ActiveMonitor websocket.
Type: Object
Type: number
Event received from ActiveMonitor Server.
Type: Object
(number)
: event id
(number)
: id of the monitor owning the event
(string)
: site of the monitor
(Timestamp)
: datetime of the event
(ActiveMonitorResource)
: resource concerned by the event
(Array<ActiveMonitorState>)
: data state at the time of the event
(number)
A message received from ActiveMonitor websocket.
Type: Object
Type: Object
Content of an ActiveMonitorMessage.
Type: Object
Display the ActiveMonitor Messages. It is displaying the number of unread messages in a badge.
Type: Object
("messages")
(boolean?)
(Url)
{
key: 'activemonitor-messages',
args: {
passedConfig.itemsType: /* "messages" */,
passedConfig.readOnMessageOpening: /* boolean= */,
passedConfig.serverUrl: /* Url */,
passedConfig: /* {itemsType: "messages", readOnMessageOpening: boolean=, serverUrl: Url} */
}
}
String can be a timestamp or "now"
Type:
("now" | string)
Representation of a resource as seen by ActiveMonitor. For event coming from ActivePivot, keys are level unique names and values member unique names.
Type: Object
(AgentsApi)
(AlertsApi)
(MessagesApi)
(MonitorsApi)
(ParametersApi)
(WorkflowsApi)
Type: SavedServerParameters
Type: Object
Type: Object
(function (cubeName: string, kpiDefinition: KpiDefinition, permissions: Permissions): Promise<void>)
(function (definition: MdxDefinition): Promise<void>)
(function (cubeName: string, kpiName: string): Promise<KpiDefinition>)
(function (cubeName: string, kpiDefinition: KpiDefinition, permissions: Permissions): Promise<void>)
Handle all the communications with an ActivePivot Server.
(function (mdx: Mdx, context: MdxContextValues, transformers: Array<Transformer>, additionalUpdateMode: UpdateMode): MdxQuery)
: Creates an
MdxQuery
with a DRILLTHROUGH statement.
(function (mdx: Mdx, context: MdxContextValues, transformers: Array<Transformer>, additionalUpdateMode: UpdateMode, refreshInterval: number, ranges: RangesConfiguration): MdxQuery)
: Creates an
MdxQuery
with a SELECT statement.
(function (cubeName: CubeName, context: MdxContextValues, transformers: Array<Transformer>, additionalUpdateMode: UpdateMode, refreshInterval: number, ranges: RangesConfiguration): MdxQuery)
: Create a simple
MdxQuery
with a SELECT statement.
(ActivePivotConfiguration)
(function (MdxQueryPayload): Promise<CellSet>)
(function (): (ActiveMonitorServer | void))
(function (): (ContentServer | void))
(function (): DiscoveryCache)
(MemberCaptionProvider)
Type: (SavedServerParameters & Object)
(ActiveMonitorServer?)
(ContentServer?)
Type: Object
(AboutApi)
(DataApi)
(DragAndDropApi)
(function (contentServerUrl: Url): BookmarksApi)
(Internationalization)
(MdxApi)
(QueriesApi)
(AuthenticationHolder)
(SettingsManager)
(Theming)
(WidgetsApi)
A component to consume an instance of ActiveUI that is provided higher up in the component tree.
Type: React.ComponentType<{children: function (activeUI: ActiveUI): React.Node}>
The raw context used by ActiveUI.
Type: Object
Type: Object
(Array<LocaleDescription>?)
: List of locales to add to the default ones. - DEPRECATED
(AutomaticRestoreStorageType?)
: Type of storage used to store last state of the application and restore it at startup
(string?)
: Custom name of the Content Server root folder.
(SettingsMap?)
: Settings map that will be merged on top of the default one.
(boolean?)
: Enable exiting full-screen mode using the Escape key.
(boolean?)
: Enable global undo/redo keyboard controls: Ctrl+Z/Cmd+Z for undo, Ctrl+Y/Cmd+Y or Ctrl+Shift+Z/Cmd+Shift+Z for redo
(Array<string>?)
: A list of experimental features to activate in ActiveUI. See the documentation
for an exhaustive list of available features.
(boolean?)
: Whether ActiveUI SDK should display an error notification when facing an uncaught exception, or let it propagate. Defaults to
true
.
({}?)
: A map with plugin types as keys. Values are lists of
PluginDescription
s to be registered.
(SerializedPlugin?)
: The serialized authentication holder plugin to use.
Refer to the Public Plugins page in the ActiveUI Developer documentation for a list of built-in implementations.
(ApplicationState?)
: Object that will be merged on top of the default initial state.
(Array<LocaleDescription>?)
: List of the locales supported by the project.
(boolean?)
: Set to false to disable server calls to synchronize locale.
(FetchTranslation?)
A component to provide an instance of ActiveUI to child components.
Type: React.ComponentType<{activeUI: ActiveUI, children: React.Node}>
Color scale of size 10 created by ActiveViam with the following colors: turquoise blue, wisteria, cream can, celery, cinnabar, el salva, neon carrot, cabaret, governor bay, nepal
Type: Object
{
key: 'activeviam',
args: {}
}
Type: function (listener: Listener<T>): RemoveListener
Opens the Add Server popup
Type: Object
{
key: 'add-server',
args: {}
}
Adds a bookmark to the user's favorites.
Type: Object
{
key: 'add-to-favorites',
args: {}
}
An action available with dashboards only, to display a popup to add widgets in a dashboard.
Type: Object
{
key: 'add-widget',
args: {}
}
Type: Object
(function (): Promise<ActiveMonitorAgentMap>)
: Sends a discovery to the ActiveMonitor Server to get the available ActiveMonitor agents. Returns the promise for the discovery, with the list of agents on success
(function (string): Promise<ActiveMonitorAgent>)
: Gets an agent details given its name. Returns a promise with agent details
Type: Object
Display the ActiveMonitor Alerts. It is displaying the number of alerts in a badge.
Type: Object
("alerts")
(string?)
({itemsType: "alerts", serverUrl: string?})
{
key: 'activemonitor-alerts',
args: {
passedConfig.itemsType: /* "alerts" */,
passedConfig.serverUrl: /* string= */,
passedConfig: /* {itemsType: "alerts", serverUrl: string=} */
}
}
Type: Object
(function (AllAlertOptions): Promise<Array<ActiveMonitorAlert>>)
: Gets all alerts recorded in an ActiveMonitor Server.
(function (ActiveMonitorAlertId): Promise<ActiveMonitorAlert>)
: Gets a single alert.
(function (ActiveMonitorAlert): Promise<ActiveMonitorAlert>)
: Starts a new alert. It creates it on server side. For this method, id attribute is ignored.
(function (ActiveMonitorAlertId): Promise<void>)
: Stops an existing alert.
(function (ActiveMonitorAlert): Promise<ActiveMonitorAlert>)
: Updates an existing alert.
(function (): FeedInfo)
Type: Object
(boolean?)
: flag to only retrieve active alerts instead of all
If not defined, all alerts are retrieved
(ActiveMonitorPeriod)
: Bottom boundary for the alert start or stop time.
(ActiveMonitorPeriod)
: Top boundary for the alert start or stop time.
Matches any filter
Type: Object
{
key: 'all',
args: {}
}
Sorts headers alphabetically.
Type: Object
{
key: 'alphabetical',
args: {}
}
Alternate colors are generated automatically by a shift of Hue in the HSL coordinates from the accent1Color and are then declined in shades.
This palette can be derived from the CorePalette and the ShadePalette.
Type: Object
Type: (SyntheticKeyboardEvent<> | SyntheticMouseEvent<> | SyntheticWheelEvent<>)
Data structure used to configure the application at startup
Type: Object
(SettingsMap?)
({settings: SettingsMap?}?)
(Array<LocaleDescription>?)
(boolean?)
({synchronize: boolean?}?)
({locales: Array<LocaleDescription>?, server: {synchronize: boolean?}?}?)
(SerializedPlugin?)
({type: SerializedPlugin?}?)
(string?)
({rootFolderName: string?}?)
({contentServer: {rootFolderName: string?}?}?)
({i18n: {locales: Array<LocaleDescription>?, server: {synchronize: boolean?}?}?, security: {type: SerializedPlugin?}?, servers: {contentServer: {rootFolderName: string?}?}?}?)
Type:
("RUNNING" | "OS_RUNNING" | "OS_STARTING" | "STOPPING" | "STOPPED" | "HALF_STOPPING" | "HALF_STOPPED" | "DELETING" | "DELETED" | "UNKNOWN")
Formats axis tick labels into k/M/B notation. e.g. 1000 -> 1k
Type: Object
(number)
: number of decimal points to include in the formatted number.
Integers will have x number of 0's appended. e.g. decimal(2) 1000 -> 1.00k
(string)
: if equal to "parentheses", negative numbers are displayed in parentheses. -1000 -> (1k)
Otherwise negative numbers are displayed with a minus.
(string)
: string to prepend to tick label.
(string)
: string to append to tick label.
{
key: 'thousands',
args: {
decimal: /* number */,
negative: /* string */,
prefix: /* string */,
suffix: /* string */
}
}
Type:
("PLACE_HOLDER" | "SCALAR" | "KEYWORD" | "STRING")
Defaults to true, as the position of the popup is usually converted in percentage to adjust with window resizing. If a popup needs to really stay at the event pixels it should provide a false value to this parameter.
Type: boolean
Type: Object
Represent a filter that impacts a MDX statement.
Type: (ActiveFilter & Object)
(any)
: the selector pointing at this active filter.
(number)
(MdxNode)
(function (): SelectNode?)
(function (FilterValueType): SelectNode)
(FilterSource)
Type: SerializablePluginImplementation<AuthenticationHolderFactoryProperties>
Exposes the authentication API that every part of ActiveUI requiring authentication can consume.
Type: Object
(function (url: Url): Promise<RequestOptions>?)
: Resolves to the request options to use for each authenticated calls.
(function (): SortedRoles)
: Returns the roles of the currently logged in user.
(function (): Username?)
: Returns the name of the currently logged in user.
(function (usedParameters: RequestOptions): Promise<void>?)
: Called with the fetch parameters used in the request that was rejected by the server.
The holder should try to get a new value either from the user or from a broker.
Type: Object
(boolean?)
: True means that there is no need to logout from the servers .ActiveUI is connected to.
If you turn on this feature, we advise you also provide the reset-to-default-view action.
Type: Object
Type: MapStorage
Type:
("html5-local-storage" | "html5-session-storage")
An MdxNode representing an axis such as ROWS or COLUMNS and its associated expression.
Type: Object
("Axis")
(ExpressionNode)
(string)
(boolean)
(Array<Todo>)
Resend Basic authentication for each REST call and uses cookies for WebSockets. Do not store any credentials. Will be asked again on reload.
Type: Object
{
key: 'basic',
args: {}
}
Color scale of size 2: black and white
Type: Object
{
key: 'black-white',
args: {}
}
Uses bold font if the row corresponds to a parent aggregate.
Type: Object
{
key: 'bold-total',
args: {}
}
Type: Object
The type of bookmark.
Type:
("folder" | "mdx" | "container")
Type: Object
Type: (BookmarkContent & Object)
(Url)
(BookmarkId)
(BookmarkPath)
(string?)
(boolean?)
Type: string
Type: Object
(BookmarkId)
(BookmarkPath)
Type: string
The file path to the bookmark on the content server.
Type: string
Type: Object
(function (bookmark: Bookmark, parentPath: string, owners: PermissionGroups, readers: PermissionGroups): Promise<BookmarkMetaData>)
: Create a bookmark. If owners/readers are unspecified,
they default to an array containing the current username as single element.
(function (id: BookmarkId, path: BookmarkPath): Promise<void>)
: Delete the bookmark identified by its
BookmarkId
and path.
(function (predicate: function (BookmarkDescription): boolean): Promise<BookmarkDescription>)
: Returns the first bookmark that matches a predicate, where the
predicate takes as parameter a bookmark and returns a boolean.
(function (name: BookmarkName): Promise<BookmarkId>)
: This function will iterate through the bookmarks
and return the first bookmark id matching
name
.
(function (id: BookmarkId): Promise<BookmarkDescription>)
: Retrieve a bookmark identified by its
BookmarkId
.
(function (): Promise<Array<BookmarkDescription>>)
Type: Object
(function (bookmark: Bookmark, parentPath: BookmarkPath, owners: PermissionGroups, readers: PermissionGroups): Promise<BookmarkMetaData>)
(function (id: BookmarkId, path: BookmarkPath): Promise<void>)
(function (id: BookmarkId, path: BookmarkPath): Promise<void>)
(function (id: BookmarkId, pathOrParentPath: BookmarkPath, updatedParentPath: string, content: Bookmark, owners: PermissionGroups, readers: PermissionGroups): Promise<BookmarkMetaData>)
(function (id: BookmarkId): Promise<string>)
(function (id: BookmarkId): Promise<BookmarkDescription>)
(function (id: BookmarkId): Promise<ContentCSFile>)
(function (id: BookmarkId): Promise<I18nCSFile>)
(function (filterFn: function (ContentCSFile): boolean): Array<BookmarkDescription>)
(function (path: BookmarkPath): Promise<StructureCSFile>)
(function (id: BookmarkId): (ContentCSFile | void))
(function (id: BookmarkId): (I18nCSFile | void))
(function (path: BookmarkPath): (StructureCSFile | RootStructureCSFile | void))
(function (id: BookmarkId): PermissionGroups)
(function (id: BookmarkId): PermissionGroups)
(function (bookmarkContentFile: ContentCSFile, bookmarkI18nFile: I18nCSFile, bookmarkStructureFile: StructureCSFile, id: BookmarkId): BookmarkDescription)
(function (): CacheStatus)
(function (): (number | void))
(function (): Promise<void>)
(function (id: BookmarkId): boolean)
The categories used by built-in containers.
Type:
("activemonitor" | "data" | "misc" | "query")
Type: Object
(function (function (CacheStatus, T): void, boolean?): RemoveListener)
: Add a listener callback, called with the status and the data when one of these two changes. The second argument indicates if the data should be fetched directly after calling this function, if not already loaded.
(function (): Promise<T>)
(function (): T)
(function (): CacheStatus)
(function (): Promise<T>)
Type:
("notLoaded" | "loading" | "loaded" | "loadingFailed")
Type: Object
(any)
: The chart configuration, as written in its state.
(Table)
: The data received by the chart, as a Table.
Render the caption contained in the cell.
Type: Object
{
key: 'caption-renderer',
args: {}
}
An MdxNode representing a CASE statement.
Type: Object
(Array<WhenClauseNode>)
("CaseExpression")
(ExpressionNode)
(ExpressionNode)
Type: Object
(CatalogName)
Type: string
A cell editor that can be added in a table.
Type: Object
(function (rowIndex: number, columnKey: string, data: Table, dataSource: DataSource, columnProps: TabularColumnProps): boolean)
: called on every cell marked as 'edited' to know if the editor should
be rendered or not.
(function ({colKey: number, columnProps: TabularColumnProps, rowIdx: number}): React.Element<any>)
: called on every cell for which isEditable has returned true.
Type: Object
Performs a manipulation on the columns of a table, for example to render several columns as one.
Type: Object
(function (columnProps: TabularColumnProps, columnInstance: any): any?)
: A way to enrich the columnProps with a calculation that will only be run once for
the whole column.
(function (rowIndex: number, minRowHeight: number, columnProps: TabularColumnProps): number?)
: The specific row height, only called if
hasCustomRowHeight
returns true.
(function (): boolean?)
: Whether the cell needs a higher height.
(function ({colKey: number, columnProps: TabularColumnProps, rowIdx: number}): React.Element<any>)
(function (): boolean?)
: Whether the original cells should be replaced or not. Defaults to true.
(function (): any?)
Type: Object
Type: Object
Change the rendering of cells in a table.
Type: Object
(function (rowIndex: number, columnProps: TabularColumnProps): {}?)
: assign a CSS style to the cell. This style will be merged with the default style.
(function ({colKey: number, columnProps: TabularColumnProps, rowIdx: number}): boolean?)
: decide if the other methods of the plugin should be called (applies to
getCellStyle AND renderCell). Returns true by default.
(function ({colKey: number, columnProps: TabularColumnProps, onCellRef: function (HTMLElement?): {}, rowIdx: number}): React.Element<any>)
: render the content of the cell.
Type: Object
Type: Object
(Array<CellSetAxis>)
(Array<CellSetCell>)
(CubeName)
(Array<DefaultCellSetMember>)
(number)
Type: Object
(Array<HierarchyCoordinates>)
(number)
(MaxLevelPerHierarchy)
(Array<Array<CellSetMember>>)
(TableAxisRangeData)
Type: Object
Type: Object
Type: Todo
Merges the ouput style on top of the current style.
Type: Object
(Function)
: function returning a style that will be merged on top of the input 'currentStyle'.
This style will be applied to the chart element corresponding to the input data tuple.
Type: Object
Type: Object
(TableHeader?)
: The measure associated with the chart node that is being hovered on.
Only returns defined if the chart is a combo chart. Otherwise it will return undefined.
(TableTuple?)
: The data associated to the element on which the action has been called. Is not defined
when the user clicks in the background of the chart.
(WidgetApi)
: The api for the layer that has been interacted with. If the interaction happened with the chart
background, it points to the api of the first layer.
("chart-handler")
(WidgetApi)
Display an overlay over a chart.
Type: Object
(function (): Array<OverlayCustomizableParameter>)
: These parameters will generate controls in the UI for the user to configure
the overlay.
(function (): React.Element<any>)
: The description of the overlay as React elements, to display a small summary of it.
(function (renderOverlayPayload: RenderOverlayPayload): void)
: The code ran by this method should render the overlay inside of the provided d3 selection.
Type: Object
(function (canOverlayDisplayPayload: CanOverlayDisplayPayload): boolean)
: Whether the overlay can be displayed on the current chart. This is used to filter the overlays
that can be added by the user through the UI.
An action to export the chart as a png.
Type: Object
(function (): void)
: An internal function registered in-memory, making this plugin tied to the specific
chart workflow. This plugin is not usable out of the context built by the SDK.
{
key: 'chart-png-export',
args: {
rasterizationCallback: /* function (): void */
}
}
Lets projects interact with the core chart selection.
Type: Object
(function (selection: ChartSelection, layerApi: WidgetApi, widgetApi: WidgetApi): void?)
: Is called back each time the selection changes.
(function (selection: ChartSelection, layerApi: WidgetApi, widgetApi: WidgetApi): ChartSelection?)
: Lets you apply a custom selection on the fly, instead of the default one. Note that returning
undefined
will cancel the selection.
Type: Object
An action to display the data of the chart as a table.
Type: Object
{
key: 'chart-show-data',
args: {}
}
Format date/time members on chart axis
Type: Object
(function (d3: D3Api, translator: Translator): Array<Formatter>)
Type: Object
Display a tooltip for the chart widget.
Type: Object
(number)
: The timeout after which the tooltip should appear.
{
key: 'chart-tooltip-show',
args: {
timeout: /* number */
}
}
Type: Object
Unload the current bookmark from the dock (or in other terms, clear the dock).
Type: Object
{
key: 'clear-dock',
args: {}
}
Type: Function
Type: Object
(function (): string)
(function (): string)
(function (): Url)
(function (): ApplicationStatus)
(function (): Url)
A CSS valid color: RGB(r,g,b), #hexa, colorName...
Type: string
Uses the tabularAlternatingRowColor as a background on even-indexed rows.
Type: Object
{
key: 'color-alternate',
args: {}
}
A caption producer that merges headers together, separated with a '/', like 'Desk / Currency'
Type: Object
{
key: 'columnMerge',
args: {}
}
A column selector, used for grouping table columns.
Type: Object
(function (headers: Array<TableHeader>, hiddenColumnsNames: Array<string>, dataSource: DataSource): Array<{key: string, selection: Array<TableHeader>}>)
: Create one or several groups of columns, with a key for the group.
Type: Object
Contains colors used by ActiveUI components.
This palette can be derived from the CorePalette, the ShadePalette and the AlternatePalette.
Type: Object
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
({background-color-base: Color, background-color-light: Color, body-background: Color, border-color-base: Color, border-color-split: Color, btn-default-bg: Color, btn-primary-color: Color, component-background: Color, disabled-bg: Color, disabled-color-dark: Color, disabled-color: Color, error-color: Color, heading-color: Color, highlight-color: Color, info-color: Color, input-bg: Color, layout-header-background: Color, primary-1: Color, primary-color: Color, success-color: Color, text-color-secondary: Color, text-color: Color, warning-color: Color})
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
({color: Color, histogramBackgroundColor: Color, histogramStrokeColor: Color, lineColor: Color, lineTextColor: Color, pointColor: Color, pointStrokeColor: Color, splitHoverBackgroundColor: Color, strokeColor: Color, textColor: Color, textColorPrimary: Color})
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
({backgroundColor: Color, color: Color, section: {backgroundColor: Color, borderColor: Color, color: Color}})
({compoundIdentifier: Color, filter: Color, function: Color, level: Color, measure: Color, select: {backgroundColor: Color, color: Color, section: {backgroundColor: Color, borderColor: Color, color: Color}}})
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
(Color)
The subset of MdxNodes that identify something using hierarchical dot notation, as in the MDX [Measures].[MyMeasure]. Each segment is an IdentifierNode.
Type: (UnknownCompoundIdentifierNode | DimensionCompoundIdentifierNode | HierarchyCompoundIdentifierNode | LevelCompoundIdentifierNode | MemberCompoundIdentifierNode | NamedSetCompoundIdentifierNode)
Open a popup to format the current measure.
Type: Object
{
key: 'conditional-formatting',
args: {}
}
A popup displaying a message, and asking for confirmation from the user
Type: Object
(TranslationPayload)
: the cancel button text
(TranslationPayload)
: the message content of the confirmation popup
(TranslationPayload)
: the submit button text
(function (): void)
: the submit callback to exexute when the submit button is clicked
(TranslationPayload)
: the title to give to the Popup
An overlay that displays a line of constant value. Only available on charts with an x and y axis, and with y being a numerical axis.
Type: Object
(string?)
: The color of the regression line.
(any?)
: A formatter specification understood by d3:
https://github.com/d3/d3-format/blob/master/README.md#api-reference
This formatter is used to format the equation coefs + r^2, and X and Y when the chart scales have no formatters.
(any?)
: A formatter used for the time in the tooltip, from the types.chartTimeFormatter plugin
(number?)
: The value to use for the regression line. Defaults to 0.
{
key: 'constant',
args: {
color: /* string= */,
formatter: /* *= */,
timeFormatter: /* *= */,
value: /* number= */
}
}
The body of the bookmark. This is specific to each type of container.
Type: any
The category in which the container should appear. If a string not part of the BuiltInContainerCategory is given, it should be added to the project translation.
Type: (BuiltInContainerCategory | string)
Type: string
Type: Object
(string?)
(BookmarkName?)
("container"?)
(ContainerValue<any>)
(boolean?)
Projects should only use ReactContainerImplementationProperties.
Type: (ReactContainerImplementationProperties | CoreContainerImplementationProperties)
Projects should only use ReactContainerImplementationStaticProperties.
Type: (ReactContainerImplementationStaticProperties | CoreContainerImplementationStaticProperties)
For more information about the controlled/uncontrolled distinction see https://reactjs.org/docs/uncontrolled-components.html.
See also the "Container" page in the docs for the current limitations of the controlled mode.
Type: Object
(AutomaticRestoreOptions)
: Only available when the container is mounted as a root.
Meaning that it cannot be used for a container rendered as a child of another container.
(ContainerChildKey?)
: Required when the container is rendered as a child of another container.
That's the key under which the API of the child container will be in the map returned by
ContainerApi#getChildrenMap
.
(ContainerFullValue?)
: Value in uncontrolled mode.
(function (WidgetApi): void?)
: Called everytime the API corresponding to the underlying container changes.
It will be called after the container is done loading the first time and every time the underlying container is reloaded.
(function (ContainerFullValue?): void?)
: Called when the value of the underlying container changes.
Only called once per loop in the event-loop.
(ContainerFullValue?)
: Value in controlled mode.
Type: Object
Type: Object
(Body?)
: Specific to each container.
(Array<SerializedPlugin>?)
(boolean?)
(string)
(Url?)
(Array<SerializedPlugin>?)
(boolean?)
(ContainerStyle?)
Type: CSFile<{}, BookmarkContent>
Expose the API to interact with a Content Server.
For all calls accepting owners and readers, if no permissions are given, they will default to the current username.
(function (): boolean)
: Returns a boolean indicating whether the underlying Content Server supports moving files.
(function (path: ContentServerPath, content: string, owners: PermissionGroups, readers: PermissionGroups): Promise<void>)
: Create a new file in the specified directory, letting the server specify its name.
(function (path: ContentServerPath, childrenOnly: boolean): Promise<void>)
: Delete the file at the given path. If the file is a directory, its content will be recursively removed.
Set
childrenOnly
to
true
to only remove a directory's children but not the directory itself.
(function (path: ContentServerPath): Promise<void>)
: Resolved if the path exists and rejected otherwise.
(function (path: ContentServerPath, recursive: number, metadata: boolean): Promise<void>)
: Retrieve the file found at the given path.
If the file is a directory, list all its accessible children, by default recursively.
recursive
is the maximum depth at which to retrieve children.
-1
means that all available children are retrieved,
0
means that only the directory itself is retrieved.
When
metadata
is
true
, only the metadata of the entries will be retrieved. Their content will be omitted.
(function (path: ContentServerPath, owners: PermissionGroups, readers: PermissionGroups, recursive: boolean): Promise<void>)
: Create an empty directory at the given path.
Set
recursive
to
true
to reate the directory and its parents if they do not exist.
(function (source: ContentServerPath, destination: ContentServerPath): Promise<void>)
: Move an existing file to a different location.
(function (payload: ReportingPayload): Promise<void>)
: Trigger the generation of a report.
If the feature is not enabled server-side, the returned promise will be rejected.
(function (path: ContentServerPath, content: string, owners: PermissionGroups, readers: PermissionGroups, overwrite: boolean, recursive: boolean): Promise<void>)
: Create a file at the given path or update an existing one.
If the file already exists and no
content
is given, only permissions will be updated.
If the file already exists and
overwrite
is
true
, the existing content will be overwritten.
Set
recursive
to
true
to create a directory and its parents. If
false
, then the parent must exist.
(function (path: ContentServerPath, owners: PermissionGroups, readers: PermissionGroups): Promise<void>)
: Update the permissions of the file at the given path.
(BookmarksManager)
Type: (SavedServerParameters & Object)
A sequence of sections forming the full path to a directory or file.
Type: Array<ContentServerPathSection>
A directory or file name.
Type: string
Type: Object
(function (translator: Translator, deserializer: Deserializer, renderMultiBinding: MultiBinding): Array<(ContextMenuItem | "separator")>)
(function (): boolean?)
: Whether the menu has items to display or not.
(function (renderMultiBinding: MultiBinding): void?)
: Called when the menu is loaded in the UI.
(function (renderMultiBinding: MultiBinding): void?)
: Called when the menu is unloaded from the UI.
Type: Object
Copy to clipboard the underlying table. Only available if the underlying table is fully downloaded (i.e. not lazy loaded)
Type: Object
{
key: 'copy-table',
args: {}
}
Main part of the palette from which all the other colors can be derived.
Type: Object
Creates an instance of ActiveUI based on the given options.
Type: function (options: ActiveUIOptions): ActiveUI
Open a popup to create a folder under the selected node.
Type: Object
{
key: 'create-folder',
args: {}
}
An action to open the kpi editor, with some contextual information if available.
Type: Object
{
key: 'create-kpi',
args: {}
}
Creates a serializable class from a plugin implementation description.
(SerializablePluginDescription<FactoryProperties, FactoryStaticProperties, ImplementationProperties, ImplementationStaticProperties, TypeParameters, ImplementationParameters>)
SerializablePluginImplementationClass<FactoryProperties, FactoryStaticProperties, TypeParameters, ImplementationParameters>
An MdxNode representing a CREATE statement.
Type: Object
Type: Object
({}?)
(any)
Type: Object
(boolean)
(boolean)
(Content)
(boolean)
(PermissionGroup)
(PermissionGroups)
(PermissionGroups)
(number)
Type: string
Type: Object
(string)
(Array<CubeContextValue>)
(Array<CubeMember>)
(Array<CubeDimension>)
(Array<EnrichedCubeKpi>)
(Array<CubeMeasureGroup>)
(Array<EnrichedCubeMeasure>)
(CubeName)
Type: Object
Type: Object
Type: Object
(string)
(HierarchyName)
(string)
(Array<CubeHierarchy>)
(DimensionName)
(("REGULAR" | "TIME"))
(boolean)
Type: Object
(function (): Cube)
(function (): CubeName)
(function (): MeasureName)
(function (HierarchyCoordinates): Array<string>)
(function (HierarchyName): CubeDimension)
(function (HierarchyUniqueName): (LevelName | void))
(function (DimensionName, HierarchyName): (CubeHierarchy | void))
(function (HierarchyUniqueName): (CubeHierarchy | void))
(function (string, attributeName: string): (DiscoveryKpi | void))
(function (level: LevelCoordinates): CubeLevel)
(function (DimensionName, HierarchyName, LevelName): number)
(function (MeasureName): (EnrichedCubeMeasure | void))
(function (): Discovery)
(function (DimensionName, HierarchyName, LevelName): boolean)
Type: Object
Type: Object
Type: Object
Type: Object
Type: Object
Type: Object
(DimensionName)
(HierarchyName)
Type: string
Type: Object
Formats axis tick labels into currency. e.g. 1000 -> $1,000.00
Type: Object
(number)
: number of decimal points to include in the formatted number.
Integers will have x number of 0's appended. e.g. decimal(2) 1000 -> $1,000.00
(string)
: three letter ISO code for which currency symbol to use. Undefined by default. If undefined, will take user's locale's currency code.
(string)
: if equal to "parentheses", negative numbers are displayed in parentheses. -1000 -> ($1,000)
Otherwise negative numbers are displayed with a minus.
{
key: 'currency',
args: {
decimal: /* number */,
currencyCode: /* string */,
negative: /* string */
}
}
Color scale of size 10 provided by D3. See https://github.com/d3/d3-scale/blob/master/README.md#schemeCategory10
Type: Object
{
key: 'd3-10',
args: {}
}
Color scale of size 20 provided by D3. See https://github.com/d3/d3-scale/blob/master/README.md#schemeCategory20b
Type: Object
{
key: 'd3-20b',
args: {}
}
Color scale of size 20 provided by D3. See https://github.com/d3/d3-scale/blob/master/README.md#schemeCategory20c
Type: Object
{
key: 'd3-20c',
args: {}
}
Color scale of size 20 provided by D3. See https://github.com/d3/d3-scale/blob/master/README.md#schemeCategory20
Type: Object
{
key: 'd3-20',
args: {}
}
The D3 api. See https://github.com/d3/d3/blob/master/API.md for more details.
Type: any
Built-in dark theme.
Type: Object
{
key: 'dark-cerulean',
args: {}
}
API entry point for all data-related features.
Type: Object
(Todo)
(Todo)
(Todo)
(function (dataSource: DataSource, filterSelector: MdxFilterSelector): (FiltersMembersContribution | void))
(function (payload: TabularHandlerActionPayload, defaultMembersPolicy: DefaultMembersPolicy): LocationInfo)
(function (payload: TabularHandlerActionPayload, defaultMembersPolicy: DefaultMembersPolicy): LocationsInfo)
(function (discovery: Discovery, cubeName: CubeName, table: Table, selection: TableSelection, dataIdsByColumnIndex: DataIdsByColumnIndex, defaultMembersPolicy: DefaultMembersPolicy): LocationsInfo)
(function (newDateRecognizer: DateRecognizer): void)
(function (headers: Array<SimpleTableHeader>, content: Array<SimpleTableTuple>): Table)
Mapping of the form {displayed column index} => {corresponding data columns indexes}
Type: {}
Type: Object
(function (): InternalDataSource)
Type: Object
Type: Object
A logger that logs everything, and adds timestamp and the caller to each message.
Type: Object
{
key: 'debug',
args: {}
}
Open a popup that displays the internal state of the widget.
Type: Object
{
key: 'debug-widget-state',
args: {}
}
Type: Object
(DimensionName)
(HierarchyName)
Default chart selection mechanism
Type: Object
{
key: 'default',
args: {}
}
Automatically format a date based on how much details the date contains. If the date contains milliseconds, the date will be formatted in milliseconds. If the date contains seconds, the date will be formatted in seconds. If the date contains minutes, the date will be formatted in minutes. If the date contains hours, the date will be formatted in hours. If the date contains days, the date will be formatted in days. If the date contains months, the date will be formatted in month. Otherwise the date will be formatted in years.
Type: Object
{
key: 'default',
args: {}
}
The policy that defines whether default members should be kept in the LocationMembers mapping that characterizes a LocationInfo.
Type:
("all" | "none" | "non-trivial")
Reads from the cell {row: 0, column: 0}.
Type: Object
{
key: 'default',
args: {}
}
Default Tabular selection mechanism
Type: Object
{
key: 'default',
args: {}
}
Deletes a bookmark or a folder recursively. If the bookmark has been registered as user's favorite and the user has the right to edit that, it will also delete the favorite.
Type: Object
{
key: 'delete-bookmark',
args: {}
}
An action to delete the a persisted measure, disabled if the user does not have the permissions to delete it.
Type: Object
{
key: 'delete-calculated-measure',
args: {}
}
An action to delete the kpi, disabled if the user does not have the permissions to delete it.
Type: Object
{
key: 'delete-kpi',
args: {}
}
Open a popup to notify a user before deleting the selected rows.
Type: Object
{
key: 'delete-pointvalues',
args: {}
}
Opens a popup to confirm the deletion of a server from the serversPool.
Type: Object
{
key: 'delete-server',
args: {}
}
Type: Array<HierarchyCoordinates>
A CompoundIdentifierNode that represents a dimension.
Type: Object
(DimensionName)
("CompoundIdentifier")
(Array<IdentifierNode>)
("dimension")
Type: string
Information discovered from an ActivePivot server about what data is available.
Type: Object
(Array<Catalog>)
: the available catalogs, which include dimensions, hierarchies, and levels as well as other items such as KPIs
(Array<CubeContextValueDefinition>)
: the available context values that statements can be executed with
(Url?)
: the URL of the ActivePivot server from which this information was fetched
(number)
Type: (CachedQuerier & Object)
(function (cubeName: CubeName, catalogName: CatalogName): CubeDiscovery)
(function (cubeName: CubeName, catalogName: CatalogName): Promise<CubeDiscovery>)
KPI object provided by a discovery REST call This describes a KPI from an MDX point of view.
Type: Object
(string)
: KPI name
(string?)
: KPI caption
(string?)
: description of the KPI purpose
(string?)
: folder containing the defined KPI
(string?)
: group to which the defined KPI belongs
(string?)
: name of a parent KPI
(number?)
: weight given to the defined KPI. This matters when the KPI has a parent.
(string)
: unique name of a measure representing a KPI value (numeric measure)
(string?)
: unique name of a measure representing a KPI goal (numeric measure)
(string?)
: unique name of a measure representing a KPI status (numeric measure)
(string?)
: unique name of a measure representing a KPI trend (numeric measure)
(string?)
: keyword indicating how to represent a KPI status.
Mandatory if a status is defined.
(string?)
: keyword indicating haw to represent a KPI trend.
Mandatory if a trend is defined
Type:
("bookmark" | "dataHeader" | "discovery" | "popup" | "layoutTile" | "mdx" | "tabularHeader" | "wizardTile")
Type: Object
("dock-action")
(WidgetApi?)
Type: Object
({})
Type: Object
Type: Object
(function (): Array<DrillthroughColumn>)
Data structure sent by ActivePivot containing the drillthrough result.
Type: Object
(number)
(DrillthroughDataSetResult)
Type: Object
Type: Object
(Array<DrillthroughDataSetHeader>)
(Array<DrillthroughDataSetRow>)
Type: Array<DrillthroughDataSetCell>
An MdxNode representing a DRILLTHROUGH statement.
Type: Object
(Array<ExpressionNode>)
("Drillthrough")
(number)
(number)
(SelectStatementNode)
A type of MdxNode.
Type: Object
Opens a popup to edit a bookmark or a folder.
Type: Object
{
key: 'edit-bookmark',
args: {}
}
Open a popup to edit a calculated measure and modify the MDX of the widget.
Type: Object
{
key: 'edit-calculated-measure',
args: {}
}
An action to open the kpi editor, with some contextual information if available.
Type: Object
{
key: 'edit-kpi',
args: {}
}
Open a popup to edit the current single value widget.
Type: Object
{
key: 'edit-single-value',
args: {}
}
Type: void
Handler that always returns an empty selection
Type: Object
{
key: 'empty',
args: {}
}
Type: (CubeMeasure & Object)
(Permissions)
A logger that only logs errors.
Type: Object
{
key: 'errors',
args: {}
}
Filters out the specified filters on top of using a key
Type: Object
(string)
(Array<SerializablePluginImplementation<MdxFilterSelectorFactoryProperties>>)
{
key: 'except-filters-key',
args: {
key: /* string */,
selectorsToExcept: /* Array.<SerializablePluginImplementation.<MdxFilterSelectorFactoryProperties>> */
}
}
Renders a progress bar instead of the start and expiry columns of a KPI.
Type: Object
{
key: 'expiry',
args: {}
}
Sorts headers in the same order as a given list.
Type: Object
(OrderedColumns)
{
key: 'explicit',
args: {
orderedColumns: /* OrderedColumns */
}
}
Create a custom color scale that explicitly list all colors. Fallback to text color if no parameters are provided.
Type: Object
{
key: 'explicit',
args: {
colors: /* Array.<Color> */
}
}
Theme reading its properties from its parameters.
Type: ThemeImplementationProperties
{
key: 'explicit',
args: /* ThemeImplementationProperties */
}
The exports of '@activeviam/activeui-sdk'.
Type: Object
(ActiveUIConsumer)
(ActiveUIContext)
(ActiveUIProvider)
(React.Component<ContainerProps>)
(CreateActiveUI)
The subset of MdxNodes that can be used in expression contexts such as the expression of a calculated measure.
Type: (LiteralNode | IdentifierNode | CompoundIdentifierNode | CaseExpressionNode | MdxFunctionNode | StringFormulaSpecificationNode)
Type: Object
Display a tooltip for the featured values widget.
Type: Object
(number)
: The timeout after which the tooltip should appear.
{
key: 'featured-values-tooltip-show',
args: {
timeout: /* number */
}
}
Type: Object
(function (): void)
(function (): void)
(function (): void)
Type: string
Type: Object
Takes locale and default "fetch translation" method and returns a promise resolving to the translation data
Type: function (Locale, function (): Promise<TranslationTree>): Promise<TranslationTree>
Type: Object
Type: Object<HierarchyUniqueName, Array<Member>>
Enum of the scope of widgets to apply filter on
Type:
("all" | "only-siblings" | "only-current-widget")
An array corresponding to the intersection of the members included by each explicit filter for a given hierarchy.
Type: Object
(boolean)
: false
when there is no data for the equivalent effective filter
for example if there are two filters on Currency, one on
[EUR, GBP]
and the other on
[USD]
, then the intersection
has no data.
(boolean)
: indicates whether the members retrieved are guaranteed to contribute
to the query's result. It is false as soon as there are non-explicit filters (or explicit filters in exclude mode)
on the hierarchy.
(FilterMembers)
The source of the filter. One of Slicers: 0, SubSelects: 1 or Server: 2.
Type:
(0 | 1 | 2)
This caption producer keeps the caption as it is in the first column of the group.
Type: Object
{
key: 'firstColumn',
args: {}
}
Type: Object
(function (Date): TranslationResult)
Formats a caption into a specific format incorporating the user's locale.
Type: Object
(function (value: (string | number), caption: string): string)
: A function receiving the value and sometimes caption from the data and produces a caption
to be displayed in the application. Sometimes the caption is undefined because the element to format does not come
from the data. For example in the case of the formatter used for the axis of charts:
On numerical axis, the values to format are for 'ticks', for which the values do not necessarily correspond to values
in the data. Thus, a caption cannot be provided in that case.
Use ChooseableFormatterImplementationStaticProperties or NotChooseableFormatterImplementationStaticProperties
Type: (ChooseableFormatterImplementationStaticProperties | NotChooseableFormatterImplementationStaticProperties)
An MdxNode representing an formula definition in the WITH clause of a SelectStatementNode. An example formula: WITH Member [Measures].[MyConstant] AS 42.
Type: Object
("Formula")
(ExpressionNode)
((boolean | void))
(Array<MemberPropertyDefinitionNode>)
(string)
An MdxNode representing a named cube for the FROM clause of a SelectNode. Does not represent a subselect expression in a FROM clause – that is represented by a SubSelectNode instead.
Type: Object
(CubeName)
("From")
Structure containing all the colors used by ActiveUI components. It is a merge of the sub-palettes:
It shares the same structure than the InputPalette but in this palette none of the properties are optional.
Type: (CorePalette & ShadePalette & AlternatePalette & ComponentPalette)
Display widgets in full screen.
Type: Object
{
key: 'full-size',
args: {}
}
Retrieve a bookmark based on ID.
(BookmarkId)
Bookmark ID
Promise<BookmarkDescription>:
A Bookmark object.
Type: (GetReactCaptionProperty & Object)
(function (translator: Translator, headers: Array<TableHeader>, groupedHeadersIds: Array<number>, dataSource: DataSource): TranslationResult)
Type: (GetReactCaptionProperty & Object)
(function (translator: Translator, headers: Array<TableHeader>, groupedHeadersIds: Array<number>, dataSource: DataSource): {captions: Array<TableHeaderCaption>, sizes: Array<number>?})
Type: Object
(function (translator: Translator, headers: Array<TableHeader>, groupedHeadersIds: Array<number>, dataSource: DataSource, data: Table, cellFactory: SerializableCellFactory): React.Node?)
Color scale of size 5 following Google Chart/ActivePivot Live 3 color scheme. It contains the following colors: mariner, tia maria, orange peel, la palma, flirt. See https://developers.google.com/chart/
Type: Object
{
key: 'google-chart',
args: {}
}
Produces captions based on the provided headers.
Type: (GetCaptionProperty | GetCaptionsProperty)
Type: Object
Customizes the order in which tabular view and pivot table columns are displayed.
Type: Object
(function (h1: SortableTabularHeader, h2: SortableTabularHeader): number)
Type: Object
An action to hide any tooltip that is displayed in ActiveUI.
Type: Object
{
key: 'hide-tooltip',
args: {}
}
A CompoundIdentifierNode that represents a hierarchy.
Type: Object
(DimensionName)
("CompoundIdentifier")
(HierarchyName)
(Array<IdentifierNode>)
("hierarchy")
Type: Object
(DimensionName)
(HierarchyName)
Matches filters with the provided hierarchy and an index greater than the one provided
Type: Object
{
key: 'hierarchy-greater-index',
args: {
hierarchy: /* string */,
index: /* number */
}
}
Matches filters with the provided key, index and hierarchy
Type: Object
{
key: 'hierarchy-key-index',
args: {
hierarchy: /* string */,
index: /* number */,
key: /* string */
}
}
Matches filters with the provided key and hierarchy
Type: Object
{
key: 'hierarchy-key',
args: {
hierarchy: /* string */,
key: /* string */
}
}
Matches filters with the provided key, filter value and hierarchy
Type: Object
{
key: 'hierarchy-key-value',
args: {
hierarchy: /* string */,
key: /* string */,
value: /* FilterValue */
}
}
Matches filters with the provided hierarchy
Type: Object
(string)
{
key: 'hierarchy',
args: {
hierarchy: /* string */
}
}
Type: string
Type: string
Responsible for converting plain text to HTML.
Type: Object
(function (): ReactTranslationPayload)
: Return a text to be translated and used to explain the features of the renderer.
Type: Object
(function (palette: FullPalette): {}?)
: Return a map of CSS in JS rules to be applied to the rendered output.
The keys of the map are CSS selectors that will be prefixed by a custom class
so that they stay isolated to the div containing the rendered output.
The values of the map are regular CSS properties expressed in JavaScript such as
{color: 'blue'}
.
The CSS properties will be "autoprefixed" in order to work well in the different browsers.
Example of map that can be returned:
{p: {fontSize: '13px'}}
.
Type: CSFile<{}, any>
Renders an icon. The expected output is any React element. For the list of available keys in the SDK, see the theme page of the Showcase application.
Type: Object
(function (palette: CorePalette, props: any): React.Element<any>)
: The render method of the icon. The props provided as the second argument might change depending
on where the icon is rendered. We recomment to always propagate this props to the top-level component and to not
try to use what is inside.
Type: Object
An MdxNode representing an identifier – the name of a hierarchy, level, measure, KPI, etc. For example, this could represent the MDX Geography or [Geography]. A CompoundIdentifierNode is made of these separated by dots.
Type: Object
An object to expose the locale events and provide ActiveUI's translator implementation to an external application
Type: Object
(AddListener<TranslationTree>)
(function (): Translator)
(function (): Array<LocaleDescription>)
Uses JWT for REST and cookies for WebSockets.
Type: Object
{
key: 'jwt',
args: {}
}
Type: Object
Type: Object
(string?)
: The path to the page to call to ask the user to log-in again
(after a token has expired for example), relative to the path of the application.
Defaults to
afterlogin.html
.
(Url)
: The endpoint URL to logout the current user.
(number?)
: Time in ms after which the application re-tries to retrieve a token from Keycloak
if it failed the first time. This can happen due to clock offsets between the Keycloak server and the ActiveUI server.
Defaults to
10000
.
(Url)
: The endpoint URL to get a token.
(Array<string>?)
: URL prefixes for which the Keycloak token should not be included in the Authorization header.
Calls to access resources protected by a Keycloak filter should not include the Keycloak token,
as it would trigger an unwanted authentication flow, and lead to tokens not refreshing correctly.
Defaults to
[window.location.origin, logoutEndPointUrl]
.
(number?)
: Interval in ms to check if the user has closed the popup asking to log-in again.
Defaults to
2000
.
Uses Keycloak for REST and cookies for WebSockets.
Type: Object
(("Jwt" | "Bearer")?)
: Will be used as a prefix before the token in the Authorization header.
Defaults to
Jwt
.
(KeycloakAuthenticationHolderOptions)
{
key: 'keycloak',
args: {
type: /* ("Jwt"|"Bearer")= */,
options: /* KeycloakAuthenticationHolderOptions */
}
}
Matches non server filters with the provided key
Type: Object
(string)
{
key: 'key',
args: {
key: /* string */
}
}
Type: Todo
Type: Array<KeyValueTooltipEntry>
Type: Object
Type: Object
(KeyValueTooltipEntries)
Type: Object
Groups together the start and expiry columns of a kpi
Type: Object
(boolean?)
: If true, there will be one group per kpi. Otherwise, all the kpis will be in the same group.
Defaults to false.
{
key: 'kpi-expiry',
args: {
groupByKpi: /* boolean= */
}
}
This caption producer is useful when the expiry column groups several expiries together (when the groupByKpi flag is true on the kpiExpiryColumnsSelector), because it displays 'kpiName Expiry'. It relies on the fact that the captions of the members that are crossjoined are displayed directly in the cell.
Type: Object
{
key: 'expiry',
args: {}
}
Selects the columns that are the goal of a kpi.
Type: Object
(boolean?)
: If true, there will be one group per kpi. Otherwise, all the kpis will be in the same group.
Defaults to false.
{
key: 'kpi-goal',
args: {
groupByKpi: /* boolean= */
}
}
The monitor configuration that will be stringified
Type: Object
Type: string
Renders the customized cell of the status of a KPI status.
Type: Object
{
key: 'kpi-status',
args: {}
}
Render different icons for cell values value < -0.5, -0.5< value <0.5 and value > 0.5
Type: Object
Groups together the status columns of a kpi.
Type: Object
{
key: 'kpi-status',
args: {}
}
Built-in lean dark theme.
Type: Object
{
key: 'lean-dark-cerulean',
args: {}
}
Built-in lean light theme.
Type: Object
{
key: 'lean-light-cerulean',
args: {}
}
A CompoundIdentifierNode that represents a level.
Type: Object
(DimensionName)
("CompoundIdentifier")
(HierarchyName)
(Array<IdentifierNode>)
(LevelName)
("level")
Type: (HierarchyCoordinates & Object)
(LevelName)
Type: string
Old light theme.
Type: Object
{
key: 'light-bluewood',
args: {}
}
Built-in light theme.
Type: Object
{
key: 'light-cerulean',
args: {}
}
An overlay displaying a line following the equation y = mx + b. Only available on charts with an x and y axis, and with y being a numerical axis.
Type: Object
(number?)
: the b parameter, as in y = mx + b. Defaults to 0
(number?)
: The step for the UI control for b. Defaults to 1
(string?)
: The color of the regression line.
(any?)
: A formatter specification understood by d3:
https://github.com/d3/d3-format/blob/master/README.md#api-reference
This formatter is used to format the equation coefs + r^2, and X and Y when the chart scales have no formatters.
(number?)
: the m parameter, as in y = mx + b. Defaults to 0
(number?)
: The step for the UI control for m. Defaults to 0.1
(any?)
: A formatter used for the time in the tooltip, from the types.chartTimeFormatter plugin
{
key: 'linear',
args: {
b: /* number= */,
bStep: /* number= */,
color: /* string= */,
formatter: /* *= */,
m: /* number= */,
mStep: /* number= */,
timeFormatter: /* *= */
}
}
A linear profile, that returns the percentage of the value between the domain min and max.
Type: Object
{
key: 'linear',
args: {}
}
A profile linear in 2 pieces, centered around middle.
Type: Object
{
key: 'linear-piecewise',
args: {
middle: /* number */
}
}
Callback for listener on value<T>.
Type: function (value: T): void
An MdxNode representing a literal value such as a number or string.
Type: Object
Loads a dashboard bookmark in a root container, opening a popup if several are available.
Type: Object
{
key: 'load-bookmark',
args: {}
}
A string symbolizing a locale following the ISO/IEC 15897 specification, for example en-US.
Type: string
A object describing a locale
Type: Object
Type: Object
(LocationMeasure?)
(LocationMembers)
Type: Object
Type: Object<HierarchyUniqueName, Member>
Type: Array<LocationInfo>
A plugin to handle logging side-effect. It is called for every logging request in activeUI
Type: Object
Type: Object
(function (data: LoggingData, {formatter: LoggingFormatter, tags: LoggingTags}): void)
: A function called every time a log operation is requested.
Logs the current user out. There is no requirement concerning its availability (it can be used anywhere).
Type: Object
{
key: 'logout',
args: {}
}
Renders an editable cell when the column displays a lookup.
Type: Object
{
key: 'lookup',
args: {}
}
Selects the columns that correspond to a formula lookup("...").
Type: Object
{
key: 'lookup',
args: {}
}
Creates one group of columns, according to the selection provided.
Type: Object
(string?)
: The key to use as a reference of the column group, generated if not provided
{
key: 'manual',
args: {
selection: /* Array.<string> */,
key: /* string= */
}
}
Type: Object
(function (): void)
: Empty the storage
(function (string): any)
: return an element from the storage
(function (string): void)
: remove an element from the storage
(function (): number)
: return how many elements are currently present in the storage
(function (string, any): void)
: insert an element in the storage
Use the default preset of https://github.com/markdown-it/markdown-it to convert Markdown to HTML.
The linkify and typographer options are enabled.
Type: Object
{
key: 'markdown',
args: {}
}
A string representing an MDX query or a subset of one. This type can represent a whole statement or just an expression – anything that could be parsed without more context than it being MDX.
Type: string
'SELECT\n [Measures].[contributors.COUNT] ON COLUMNS\n FROM [EquityDerivativesCube]'
'[Measures].[contributors.COUNT]'
'"a string in MDX"'
'123'
Manipulate Mdx (MDX), mostly via transforming it to a tree of MdxNodes.
Because MdxNodes are immutable, all functions within the MDX API that say they change an MDX Node (“add, “remove”, etc.) really just return a copy of the MDX Node with the described differences.
Type: Object
(MdxAxesApi)
(MdxBaseApi)
(MdxCleaningApi)
(MdxCreateApi)
(Todo)
(Todo)
(MdxDrillthroughApi)
(MdxFiltersApi)
(MdxFormulasApi)
(MdxFunctionsApi)
(function (dataSource: MdxUsingDataSource): StatementAndDiscovery)
(MdxHierarchiesApi)
(MdxKpiApi)
(MdxLevelsApi)
(MdxMeasuresApi)
(MdxNamedSetsApi)
(NodeMatcherFactory)
(MdxOrderApi)
(MdxParsingApi)
(MdxStatementsApi)
(MdxTabularApi)
(function (mdx: Mdx, discovery: Discovery, sndTransformer: function (StatementAndDiscovery): StatementAndDiscovery): Mdx)
(function (dataSource: MdxUsingDataSource, sndTransformer: function (StatementAndDiscovery): StatementAndDiscovery): void)
(function (mdx: Mdx, discovery: Discovery, nodeTransformer: function (SelectNode): SelectNode): Mdx)
(MdxTuplesApi)
Transform an MDX statement string using an S&D transformation function. The conversion between Mdx and MdxNode is taken care of in this method.
(Mdx)
the initial MDX statement.
(Discovery)
the content of a server discovery.
(function (StatementAndDiscovery): StatementAndDiscovery)
the transformer, taking as input a
StatementAndDiscovery
and returning a
StatementAndDiscovery containing a new
MdxNode
that will be printed to an
Mdx
string and then returned.
Mdx:
the transformed MDX statement.
// Adding hierarchy `[D1].[H1]` on the `ROWS` axis
const coordinates = mdxApi.hierarchies.toCoordinates('[D1].[H1]');
const newMdxString = mdxApi.transform(
oldMdxString,
discovery,
snd => mdxApi.hierarchies.addHierarchy(snd, coordinates, 'ROWS')
);
Transform an Mdx statement using an MdxNode transformation function. The difference from transform
is that the transformation function takes and returns just the statement part of a StatementAndDiscovery.
(Mdx)
the initial MDX statement.
(Discovery)
the content of a server discovery.
(function (SelectNode): SelectNode)
the transformer, taking as input a SelectNode and returning a
SelectNode that will be printed to an MDX string and then returned.
Mdx:
the transformed MDX statement.
Tells the data source to update its MDX according to the transformation function.
(MdxUsingDataSource)
(function (StatementAndDiscovery): StatementAndDiscovery)
takes the statement and discovery from the data source, and returns the new statement and discovery for the data source to use.
void
Get the statement and the discovery contained within an MDX-using data source.
(MdxUsingDataSource)
StatementAndDiscovery
Contains all the operations related to the axes of a Select statement. Axes can be split in two categories:
Type: Object
(function (node: SelectNode, axisName: string): (AxisNode | void))
(function (snd: StatementAndDiscovery): (AxisNode | void))
(function (node: SelectNode): (AxisNode | void))
(function (node: SelectNode): number)
(function (snd: StatementAndDiscovery): (AxisNode | void))
(function (node: SelectNode): (AxisNode | void))
(function (node: SelectNode): number)
(function (node: SelectNode): AxisNode)
(function (node: SelectNode, axisName: string): boolean)
(function (statement: SelectNode): Array<string>)
(string)
(function (statement: SelectNode, axisName: string, transform: function (AxisNode): AxisNode, createIfNotExisting: function (): (AxisNode | void)): SelectNode)
(function (mdxStatementNode: SelectNode, axisName: string, valueOfNonEmpty: boolean): SelectNode)
The name of the axis that measures are on by default.
Type: string
Get an axis by its name.
(SelectNode)
the statement to read from.
(string)
the name of the axis to look for. Use 'SLICER' for the slicer axis.
(AxisNode | void):
the axis node, or undefined if this statement has no axis with this name.
Indicate if a statement has an axis with the given name.
(SelectNode)
the statement to read from.
(string)
the name of the axis to look for. Use 'SLICER' for the slicer axis.
boolean:
true if the axis exists, false otherwise.
(SelectNode)
the statement to read from.
(AxisNode | void):
the columns axis, or undefined if it is absent.
(SelectNode)
the statement to read from.
number:
the index of the columns axis, or -1 if the columns axis is absent.
(SelectNode)
the statement to read from.
(AxisNode | void):
the rows axis, or undefined if it is absent.
(SelectNode)
the statement to read from.
number:
the index of the rows axis, or -1 if the rows axis is absent.
(SelectNode)
the statement to read from.
AxisNode:
the slicer axis, or undefined if it is absent.
Find the axis where measures should be present. This does not guarantee the measure hierarchy is on this axis. Returns undefined if the measures hierarchy is not present in the query and the axis that usually contains measures (COLUMNS) is not present in the statement.
(StatementAndDiscovery)
a statement and discovery containing the statement to search in.
(AxisNode | void):
Find the axis containing the measures hierarchy. Will return undefined if the measures hierarchy is not contained in the query. As opposed to getMeasuresAxis, calling addMeasureWithOther on a defined result of this function is guaranteed to work.
(StatementAndDiscovery)
a statement and discovery containing the statement to search in.
(AxisNode | void):
Give the list of main axes names present in a statement.
(SelectNode)
the statement for which axes should be listed.
Array<string>:
the names of the main axes. The slicer axis is by definition excluded.
Apply a transformation only on one axis of a statement.
(SelectNode)
the statement to update.
(string)
the name of the axis to transform (also supports slicer axis).
(function (): (AxisNode | void))
if the given statement doesn't have an axis with the given name, this
method will be called. If it returns a defined value we will use this value as the axis node. If this function
is not provided we will use a function that returns undefined.
SelectNode:
the modified statement (not just the axis).
Sets whether NON EMPTY is present or not in a given axis of a statement, not modifying the original statement.
(SelectNode)
(string)
(boolean)
Specify if non-empty should or should not be in the statement. Defaults to
true
.
SelectNode:
a clone of mdxStatementNode with the named axis modified,
or the original mdxStatementNode if there is no such axis
Contains basic read/write operations on Mdx and MdxNodes.
Some of these functions can be grouped into sets of related functions:
Functions for converting between an array of unquoted identifier MDX strings and a single dot-separated compound identifier MDX string.
This API contains other functions that do not belong in a specific group.
Type: Object
(function (string): LiteralNode)
(function (numberForMdx: (Mdx | number)): LiteralNode)
(function (args: Array<ExpressionNode>): MdxFunctionNode)
(function (string): LiteralNode)
(function (mdxNode: MdxNode): Array<CompoundIdentifierNode>)
(function (CompoundIdentifierNode): Array<string>)
(function (MemberCompoundIdentifierNode): MeasureName)
(any)
(function (TableHeader): boolean)
(function (TableHeader): boolean)
(function (cId1: CompoundIdentifierNode, cId2: CompoundIdentifierNode): boolean)
(function (): Mdx)
(function (snd: StatementAndDiscovery, transform: function (SelectNode): SelectNode): StatementAndDiscovery)
Return an updated version of a StatementAndDiscovery
(StatementAndDiscovery)
(function (SelectNode): SelectNode)
StatementAndDiscovery
(MdxNode)
boolean:
whether the MDX node represents a compound identifier (
CompoundIdentifierNode
) or not
(MdxNode)
boolean:
whether the MDX node represents a dimension compound identifier (
DimensionCompoundIdentifierNode
) or not
(MdxNode)
boolean:
whether the MDX node represents a hierarchy compound identifier (
HierarchyCompoundIdentifierNode
) or not
(MdxNode)
boolean:
whether the MDX node represents a level compound identifier (
LevelCompoundIdentifierNode
) or not
(MdxNode)
boolean:
whether the MDX node represents a named set compound identifier (
NamedSetCompoundIdentifierNode
) or not
(MdxNode)
boolean:
whether the MDX node represents an unknown type of compound identifier (
UnknownCompoundIdentifierNode
) or not
(MdxNode)
boolean:
whether the MDX node represents a member compound identifier (
MemberCompoundIdentifierNode
) or not
(MdxNode)
boolean:
whether the MDX node represents a literal value (
LiteralNode
) or not
(MdxNode)
boolean:
whether the MDX node represents a literal place holder value (
LiteralNode
with
type
'PLACE_HOLDER'
) or not
(MdxNode)
boolean:
whether the MDX node represents a function call (
MdxFunctionNode
) or not
(MdxNode)
boolean:
whether the MDX node represents a regular function call (
MdxFunctionNode
with
syntax
'Function'
) or not
(MdxNode)
boolean:
Whether the MDX node represents an infix function call (
MdxFunctionNode
with
syntax
'Infix'
) or not. An infix function call typically represents the usage of an operator.
(MdxNode)
boolean:
whether the MDX node represents a set (
MdxFunctionNode
for the function
'{}'
) or not
(MdxNode)
boolean:
whether the MDX node represents an explicit set (a
CompoundIdentifierNode
or a valid
MdxFunctionNode
)
(MdxNode)
boolean:
whether the MDX node represents a DRILLTHROUGH statement (
DrillthroughStatementNode
) or not
(MdxNode)
boolean:
whether the MDX node represents a SELECT statement (
SelectStatementNode
) or not
(MdxNode)
boolean:
whether the MDX node represents a subselect (
SubSelectNode
) or not
(MdxNode)
boolean:
whether the MDX node represents a formula definition (
FormulaNode
) or not
(MdxNode)
boolean:
whether the MDX node represents a named set definition (
FormulaNode
with
type
'SET'
) or not
(MdxNode)
boolean:
whether the MDX node represents a CASE statement (
CaseExpressionNode
) or not
(MdxNode)
boolean:
whether the MDX node represents a
WHEN
clause (
WhenClauseNode
) or not
(MdxNode)
boolean:
whether the MDX node represents a literal scalar value (
LiteralNode
with
type
'SCALAR'
) or not
(MdxNode)
boolean:
whether the MDX node represents a literal string value (
LiteralNode
with
type
'STRING'
) or not
(MdxNode)
boolean:
whether the MDX node represents a literal
NULL
value (a matching
LiteralNode
) or not
(MdxNode)
boolean:
whether the MDX node represents a KPI function (
MdxFunctionNode
) – a call to a supported function whose name begins with “KPI”
Indicate whether an MDX node represents the given MDX function (MdxFunctionNode). The function name matching is case-insensitive.
boolean:
Indicate whether an MDX node represents a regular function call (MdxFunctionNode with syntax 'Function') with the given name. The function name matching is case-insensitive.
boolean:
Indicate whether an MDX node represents an infix function call (MdxFunctionNode with syntax 'Infix') with the given name. The function name matching is case-insensitive.
boolean:
(MdxNode)
boolean:
whether the MDX node represents a call (an
MdxFunctionNode
) to the MDX
Lookup
function or not
(MdxNode)
boolean:
whether the MDX node represents a number, i.e. a (
LiteralNode
with
type
'SCALAR'
parsable as a number.
(MdxNode)
boolean:
whether the MDX node represents a negative number, i.e. the '-' function applied as a prefix on a
(
LiteralNode
with
type
'SCALAR'
parsable as a number.
(MdxNode)
boolean:
whether the MDX node represents a number, i.e. a (
LiteralNode
with
type
'SCALAR'
parsable as a number,
or the
-
function applied to such a node.
(MdxNode)
boolean:
whether the MDX node represents a measure compound identifier (a matching
MemberCompoundIdentifierNode
) or not
(MdxNode)
boolean:
whether the MDX node represents a tuple (
MdxFunctionNode
) with
syntax
'Parentheses'
) or not
(MdxNode)
boolean:
whether the MDX node represents a function call (
MdxFunctionNode
) that can indicate a crossjoin, for example a call to
Crossjoin
(MdxNode)
boolean:
whether the MDX node represents a function call (
MdxFunctionNode
) that can indicate a union, for example a call to
Union
Get the name of a measure from a measure compound identifier.
(MemberCompoundIdentifierNode)
MeasureName
Retrieve the measure name from an MDX node that represents a measure. Return undefined if the given KPI name or attribute does not exist in the cube discovery. Throw if the MDX node is of an unexpected type.
Type: any
((MemberCompoundIdentifierNode | MdxFunctionNode))
an MDX node that represents a measure (a measure compound identifier or a KPI function)
(CubeDiscovery)
any:
the name of the measure, or
undefined
if it is unavailable due to being a KPI function not in the cube discovery
Return an array of the values of each identifier in the given compound identifier node.
(CompoundIdentifierNode)
Array<string>
Create an MdxFunctionNode representing a set with the given arguments.
Type: function (args: Array<ExpressionNode>): MdxFunctionNode
Create a LiteralNode representing a string with the given value. See ArgumentTypeValue for what a string is in MDX.
Type: function (value: string): LiteralNode
Create a LiteralNode representing a scalar with the given value. See ArgumentTypeValue for what a scalar is in MDX.
LiteralNode
Create a scalar representing a positive number by applying createScalar on the absolute value of the input. If the input is negative, wrap this scalar as the argument of the MDX minus function '-', applied as a prefix.
(LiteralNode | MdxFunctionNode)
Create a LiteralNode representing a keyword with the given value. See ArgumentTypeValue for what a keyword is in MDX.
Type: function (value: string): LiteralNode
Return an array containing all the CompoundIdentifierNodes found within the MDX node
(MdxNode)
Array<CompoundIdentifierNode>:
the compound ID nodes
Given whether measures should be accepted or rejected, return a predicate function. The returned function is useful for narrowing an array of CompoundIdentifierNodes to only the measures or only the non-measures.
(boolean)
true
if only measures should pass the check or
false
if only non-measures should pass the check
function (MdxNode): boolean:
a function that can be used to filter
MdxNode
s
const isNotAMeasureCompoundId = activeUI.mdx.base.getMeasureCompoundIdFilter(false)
// myNodes: Array<CompoundIdentifierNode>
const onlyNonMeasures = myNodes.filter(isNotAMeasureCompoundId)
(CompoundIdentifierNode)
(CompoundIdentifierNode)
boolean:
whether the two compound identifier nodes would be represented by the same
Mdx
Returns an MDX node representing an empty SELECT statement on the given cube.
For example, with the cube name “EquityDerivativesCube”, returns the node representing the MDX SELECT FROM [EquityDerivativesCube].
SelectStatementNode
Returns true if the header represents a column of numeric values on the COLUMNS axis. (Currently, all numeric values are on the COLUMNS axis and all values on the COLUMNS axis are numeric.)
(TableHeader)
boolean
Returns true if the header is on the ROWS axis.
(TableHeader)
boolean
The default plugin for converting MDX cell properties to CSS.
Type: Object
Provides functions to clean a parsed tree and simplify it.
Type: Todo
A string or number representing the color. Example: 'rgb(0, 0, 255)' or 16711680 means blue.
Type: string
Type: Object<MdxContextValueKey, MdxContextValue>
Contains functions to create MDX nodes.
The definition of a configuration
Type: Object
(string)
: a mdx configuration statement
(PermissionGroups?)
: a list of roles/users that can edit the configuration
(PermissionGroups?)
: a list of roles/users that can read the configuration
Contains all the drillthrough statement related functions.
Type: Todo
Return the select statement necessary to fetch the columns available for the given drillthrough query.
(MdxNode)
the complete query with potentially MAXROWS, FIRSTROW and RETURN blocks
MdxNode:
the mdx sent to DrillthroughHeadersQuery
Contains functions to manipulate filters of an MDX query.
The main object used to manipulate the filters of an MDX statement is called ActiveFilter. Active here means that this filter is currently in use in a statement, as opposed to the class Filter which describes a type of filter, outside of any statement context.
Type: Todo
MdxFilterSelector are used to retrieve one or more filters matching a specific set of conditions in order to manipulate it: read, write, remove...
Type: Object
(function (activeFilter: AugmentedActiveFilter<any>): boolean)
: return true if and only if the provided filter matches the selector's condition
Type: Object
Contains all functions about calculated members.
Type: Todo
An MdxNode representing a function call. Some functions are called with syntax that makes them look like an operator or part of the language; see SyntaxValue for the different syntaxes for calling functions.
Type: Object
Allows reading and manipulating the MDX functions used in a statement.
Type: Todo
A caption producer relying on an MDX dataSource, useful for producing synthetic headers when grouping columns.
Type: Object
{
key: 'mdxHeaderCaption',
args: {}
}
Contains all the logic for hierarchies transformations.
Type: Todo
Contains all the operations related to KPIs and their functions.
Type: Todo
Contains all the logic for levels transformations.
Type: Todo
Contains all the basic read/write operations about MDX measures.
Type: Todo
Contains functions for manipulating named sets.
Type: Object
(function (snd: StatementAndDiscovery, name: string, expression: Mdx, axis: string, position: number, nonEmptyAxis: boolean): StatementAndDiscovery)
Add an already-defined named set to an axis of a statement.
(StatementAndDiscovery)
(Mdx)
the expression of the existing named set to reference, e.g.
'TopCount([Underlyings].[ALL].[AllMember].Children, 2, [Measures].[contributors.COUNT])'
.
(number)
the position among the axis hierarchies at which to add this new named set node, e.g. 0. If not specified, add the node at the last position.
(boolean)
if adding this hierarchy requires creating the axis, indicate if this axis should have the
nonEmpty
flag. Defaults to
false
, meaning without the
nonEmpty
flag.
StatementAndDiscovery:
The AST node representing an Mdx (MDX) string.
The only property common to all nodes is elementType.
The MdxApi provides functions for creating and manipulating MdxNode objects.
MdxNodes should never be mutated.
Type: (ExpressionNode | AxisNode | FromClauseNode | FormulaNode | CreateStatementNode | DrillthroughStatementNode | DropStatementNode | MemberPropertyDefinitionNode | RefreshStatementNode | SelectNode | WhenClauseNode)
Contains the methods to read or change the ordering in a statement. Ordering in MDX is controlled using
the Order function.
Type: Object
(function (parsedSelectStatement: SelectStatementNode, axisName: string): (void | {expression: ExpressionNode, mode: OrderModeLiteralNode}))
(function (orderingFormula: FormulaNode, cubeDiscovery: CubeDiscovery): (LevelName | void))
(function (node: MdxNode): (OrderFunctionNode | null))
(function (node: ExpressionNode, orderingExpression: ExpressionNode, orderMode: OrderModeLiteralNode): ExpressionNode)
(function (parsedSelectStatement: SelectNode, axisName: string, orderingExpression: string, orderMode: OrderMode): SelectNode)
(function (parsedSelectStatement: SelectNode, axisName: string): SelectNode)
Order an MDX set expression by inserting a call to the Order function in an appropriate place. As in the rest of the MdxApi, the original node is not mutated; this function returns a copy that contains the new Order function.
We insert the Order function at the deepest level inside functions that maintain order because they are subset/tail/head
that make a lot less sense if we don't order their argument.
As soon as we find a function not maintaining order we will order on top of it.
We replace the Order/Hierarchize function we find with our new ordering function.
(ExpressionNode)
the set expression to order.
(ExpressionNode)
the numeric or string expression on which to order the members of the set.
(OrderModeLiteralNode)
the node of a keyword literal representing the order mode.
ExpressionNode:
a set expression node representing the passed-in
node
with an order.
Get a version of the SELECT statement in which the named axis is ordered as specified.
SelectNode:
the modified
SELECT
statement.
Retrieve from within a node the node representing the Order function, if there is one.
(MdxNode)
the node in which to search for ordering.
(OrderFunctionNode | null):
the ordering node, or
null
if the node is not ordered.
Get information about the ordering, if any, on one of the axes of a SELECT statement.
(string)
the name of the axis to get the order information of.
(void | {expression: ExpressionNode, mode: OrderModeLiteralNode}):
undefined
if the axis is unordered, or the order mode and the ordering numeric or string expression if the axis has an order.
Give the ordering level represented by a formula.
This receives the expression of the calculated measure used in the second argument of the Order function.
Then it looks for one of the following functions:
Ancestor(<member>, <level>): we consider the formula to be sorted on the given level<hierarchy>.CurrentMember: we consider the formula to be sorted on last level of the hierarchy(FormulaNode)
the formula used as orderer in the ordering of another expression.
(CubeDiscovery)
the discovery for the given cube.
(LevelName | void):
the unique name of the level used as ordering source, or
undefined
if there is no ordering level
Remove the explicit ordering of an axis of a SELECT statement. Does the opposite of order.
If there was no ordering on the axis, the SELECT statement is returned unchanged.
(string)
the name of the axis.
SelectNode:
the modified
SELECT
statement.
Responsible for the conversion between MDX strings (Mdx) and their equivalent trees of nodes (MdxNode).
Type: Object
(function (expression: Mdx, discovery: Discovery, context: {cubeName: CubeName?}): MdxNode)
(function (node: MdxNode, options: MdxPrinterOptions): Mdx)
Convert an MDX node to a pretty-printed string of MDX.
(MdxType.MdxNode)
(MdxPrinterOptions
= {})
Mdx
Type: Object
(StringDeepJoiner?)
: If you want, you can override this function that collects together pieces of text to produce one big string.
(boolean?)
: If true, argument lists are separate by only the comma character, like “(a,b)”. If false, argument lists are also printed on separate lines, like “(a,\n b)”. Defaults to false.
(boolean?)
: Whether to automatically indent each line of the printed MDX. Defaults to false.
A MDX query on a given server.
A MdxQuery has two ids: clientId and serverId:
Type: Object
(function (function (Table): void): RemoveListener)
(function (): void)
(function (): void)
(function (): MdxContextValues)
(function (): QueryId)
(function (): Mdx)
(function (): Ranges)
(function (): number)
(function (): UpdateMode)
(function (): boolean)
(function (): boolean)
(function (): void)
(function (): Promise<CellSetMessage?>)
(function (MdxContextValues): MdxQuery)
(function (number): void)
(function (UpdateMode?, number?): MdxQuery)
(function (): MdxQuery)
(function (): MdxQuery)
(function (Mdx, MdxContextValues, UpdateMode, number): MdxQuery)
Type: Object
(MdxContextValues?)
(Mdx)
(RangesConfiguration?)
(Url?)
(UpdateMode)
Type: Object
(MdxContextValues?)
(Mdx)
Contains the functions used to manipulate the different type of MDX statements that can be encountered (Select, Drillthrough Select).
Type: Todo
Contains additional functions used for the tabular representation of a CellSet.
Type: Todo
Contains all the operations related to MDX tuples.
Type: Todo
Type: Object
(function ({_multiBinding: MultiBinding, additionalMeasuresCompoundIds: Array<CompoundIdentifierNode>, cubeName: string, serverUrl: Url}): React.Node)
Type: Object
Type: string
Type: string
Type: Object
(("ROWS" | "COLUMNS"))
(number)
({axis: ("ROWS" | "COLUMNS"), coordinate: number})
(MemberPathAsString)
Type: Object
(function (cubeName: CubeName, memberUniqueName: MemberUniqueName): string)
(function (cubeName: CubeName, memberUniqueName: MemberUniqueName): Promise<string>)
(function (): void)
(function (cubeName: CubeName, memberUniqueName: MemberUniqueName, caption: string): void)
Creates a group of columns containing all the levels representing members (as opposed to measures).
Type: Object
{
key: 'member',
args: {}
}
A CompoundIdentifierNode that represents a member.
Type: Object
(DimensionName)
("CompoundIdentifier")
(HierarchyName)
(Array<IdentifierNode>)
(LevelName)
("member")
Open a popup to filter on the current column
Type: Object
(boolean)
: to force the edition, and not remove the filter
(string)
: the scope of widgets to apply filter on. Accepted values are:
'all', 'only-siblings', and 'only-current-widget'. Defaults to 'only-current-widget' if not specified.
{
key: 'member-filter',
args: {
forceEdit: /* boolean */,
scope: /* string */
}
}
The path of a member within its hierarchy.
Type: string
'[AllMember].[EUR]' // for the member with full unique name [Currency].[Currency].[ALL].[AllMember].[EUR]
An MdxNode representing the definition of a property of a member that is defined in a FormulaNode. Some example property names are FORE_COLOR and FONT_FLAGS.
Type: Object
Type: string
Type: Object
(function (): Promise<Array<ActiveMonitorMessage>>)
: Gets all messages for the connected user.
(function (ActiveMonitorMessageId, ActiveMonitorMessageAnswerContent): Promise<void>)
(function (): FeedInfo)
(function (ActiveMonitorMessageId): Promise<void>)
(function (ActiveMonitorMessageId): Promise<void>)
Type: Object
((MonitorConfiguration | KpiMonitorConfiguration))
(AuditTimeInfo)
(Username)
(AuditTimeInfo?)
(string)
(number)
(string)
(string)
(string)
(string)
(string)
Type: Object
Type: Object
Type: Object
Either a site or "site/id"
Type: (MonitorSite | string)
Type: Object
(Timestamp)
(Timestamp)
(Monitor)
(MonitorStatistics)
Type: Object
(function ((MonitorSite | void)): Promise<Array<Monitor>>)
: Gets monitors of a given site. Use undefined to get monitors from all sites
(function ((MonitorPath | MonitorLocation | void)): Promise<Array<MonitorReport>>)
: Gets reports for monitors of a given site. Use undefined to get monitors from all sites
(function (Monitor): Promise<Monitor>)
: Updates a monitor definition. This uses the site and id stored in the monitor definition to build the update URL.
(function (): FeedInfo)
(function ((MonitorPath | MonitorLocation)): Promise<void>)
(function ((MonitorPath | MonitorLocation)): Promise<Monitor>)
(function ((MonitorPath | MonitorLocation)): Promise<Array<ActiveMonitorAlert>>)
(function ((MonitorPath | MonitorLocation), number): Promise<ActiveMonitorEvent>)
(function ((MonitorPath | MonitorLocation)): Promise<Array<ActiveMonitorEvent>>)
(function ((MonitorPath | MonitorLocation)): Promise<Array<Monitor>>)
(function ((MonitorPath | MonitorLocation)): Promise<MonitorReport>)
Type: string
Type: Object
Renders the customized cell of the status of a monitor.
Type: Object
Color scale of size 1 based on the current theme accent color
Type: Object
{
key: 'mono-accent',
args: {}
}
Color scale of size 1 based on the current theme text color
Type: Object
{
key: 'mono-text',
args: {}
}
A CompoundIdentifierNode that represents a named set.
Type: Object
("CompoundIdentifier")
(Array<IdentifierNode>)
(SetName)
("namedSet")
An array that contains strings or arrays of strings or arrays of arrays of strings, etc.
Type: Array<(string | NestedStringArrays)>
A builder that displays a widget configured through a fluent interface
Extends ABuilderBasedOnDock
(any)
(any)
With container key
(string)
NewBookmarkBuilderBasedOnDock:
Make bookmark not writable
NewBookmarkBuilderBasedOnDock:
Display the title bar when showing the bookmark
NewBookmarkBuilderBasedOnDock:
Hide the title bar when showing the bookmark
NewBookmarkBuilderBasedOnDock:
Display the hamburger menu on left
NewBookmarkBuilderBasedOnDock:
Display the hamburger menu on right
NewBookmarkBuilderBasedOnDock:
Give a name to the bookmark
(string)
NewBookmarkBuilderBasedOnDock:
Give a style to the bookmark
NewBookmarkBuilderBasedOnDock:
Attach a content server url to the bookmark, in order to have it preselected, to make the 'save as' action easier.
(string)
NewBookmarkBuilderBasedOnDock:
Select the dock actions available on the dock. These actions will displayed in a menu.
NewBookmarkBuilderBasedOnDock:
Select the dock actions available on the dock. These actions will displayed in the title bar next to the menu, if the title bar is shown. Otherwise, they will be inserted first in the menu.
NewBookmarkBuilderBasedOnDock:
Customize the body of the bookmark, that will be transmitted to the widget. This will replace the default body. It is recommended to maintain the default values as much as possible, the default being documented as JSON objects.
(Object)
NewBookmarkBuilderBasedOnDock:
Take as input an already constructed bookmark object, and set it as this builder bookmark underlying value, without merging it to the previous underlying value.
Warning: calling this method after other withSomething() calls will discard the effect of the prior calls, as this reset completely the current bookmark value of this builder, without merging it.
(Object)
the bookmark value to set
NewBookmarkBuilderBasedOnDock:
Create this with NodeMatcherFactory to get a fluent API for matching nodes in a parsed statement. See the NodeMatcherFactory documentation for examples.
Most methods on this object return another NodeMatcher, so you can chain them to perform multiple checks on a node and its children. The results of each match are ANDed together; for OR conditions, use the .or() method.
There are methods to match against attributes of the node, such as .isFunction('Generate'), or against children of the node, such as .subArg(0, firstArgMatcher => firstArgMatcher.isScalar()). If the method you want is not defined, you can match against whatever property of a node you want within a .customMatch call.
At the end of the chain, call .matches() to get a boolean result. If you need more information about the match success or failure, call .matchDetails() on the NodeMatcher.
A NodeMatcher is stateless. You can save a partially-constructed NodeMatcher and construct two different matchers based on it.
Type: Object
(function (): NodeMatcher)
(function (nodeShouldMatchCallback: function ($Subtype<MdxNode>, NodeMatcher): boolean): NodeMatcher)
(function (n: number): NodeMatcher)
(function (n: number): NodeMatcher)
(function (): NodeMatcher)
(function (): NodeMatcher)
(function (): NodeMatcher)
(function (): NodeMatcher)
(function (): NodeMatcher)
(function (): NodeMatcher)
(function (): NodeMatcher)
(function (): NodeMatcher)
(function (): NodeMatcher)
(function (): NodeMatcher)
(function (): NodeMatcher)
(function (): NodeMatcher)
(function (): NodeMatcher)
(function (): boolean)
(function (): NodeMatcher)
(function (argN: number, argMatcherCallback: NodeMatcherTransformer): NodeMatcher)
(function (caseN: number, caseMatcherCallback: NodeMatcherTransformer): NodeMatcher)
(function (elseCaseMatcherCallback: NodeMatcherTransformer): NodeMatcher)
(function (argMatcherCallback: NodeMatcherTransformer): NodeMatcher)
(function (thenMatcherCallback: NodeMatcherTransformer): NodeMatcher)
(function (whenMatcherCallback: NodeMatcherTransformer): NodeMatcher)
Check if the function argument at the given index is satisfied by the matcher returned by the callback.
(number)
the zero-based index of the argument.
(NodeMatcherTransformer)
a function that takes a
NodeMatcher
initialized pointing to the given argument, and returns a NodeMatcher that will be asserted to match that argument.
NodeMatcher
nodeMatcher
.isFunction('()')
.hasNArguments(1)
.subArg(0, argMatcher => argMatcher.isLiteral())
Check if all function arguments are satisfied by the matcher returned by the callback.
(NodeMatcherTransformer)
a function that takes a
NodeMatcher
initialized pointing to one of the given arguments, and returns a NodeMatcher that will be asserted to match that argument.
NodeMatcher
nodeMatcher
.isFunction('OR')
.hasNArguments(2)
.subEveryArg(argMatcher => argMatcher.customMatch(isEmptySimpleMatcher))
Check if the CASE statement WHEN clause at the given index is satisfied by the matcher returned by the callback.
(number)
the zero-based index of the case.
(NodeMatcherTransformer)
a function that takes a
NodeMatcher
initialized pointing to the given
WHEN
clause, and returns a NodeMatcher that will be asserted to match that clause.
NodeMatcher
nodeMatcher
.isCase()
.subCase(0, caseMatcher => caseMatcher.customMatch(node => myCheckForWhenIsEmpty(node)))
Check if the ELSE result expression of a CASE statement is satisfied by the matcher returned by the callback.
(NodeMatcherTransformer)
a function that takes a
NodeMatcher
initialized pointing to the
ELSE
expression, and returns a NodeMatcher that will be asserted to match that expression.
NodeMatcher
nodeMatcher.subElse(elseMatcher => elseMatcher.isScalar())
Check if the WHEN condition expression of a WHEN clause is satisfied by the matcher returned by the callback.
(NodeMatcherTransformer)
a function that takes a
NodeMatcher
initialized pointing to the
WHEN
condition, and returns a NodeMatcher that will be asserted to match that condition.
NodeMatcher
nodeMatcher.subWhenCondition(whenMatcher => whenMatcher.isFunction('<='))
Check if the THEN true result expression of a WHEN clause is satisfied by the matcher returned by the callback.
(NodeMatcherTransformer)
a function that takes a
NodeMatcher
initialized pointing to the
THEN
expression, and returns a NodeMatcher that will be asserted to match that expression.
NodeMatcher
nodeMatcher.subThen(thenMatcher => thenMatcher.isNull())
(function ($Subtype<MdxNode>, NodeMatcher): boolean)
NodeMatcher
nodeMatcher.customMatch((node, matcher) => !matcher.isNull().or().isScalar().matches())
nodeMatcher.customMatch(node => parseInt(node.value) === 0)
Terminate the chain of NodeMatchers by returning whether all of the checks of the MdxNode described so far have passed.
boolean
const someNodeMatcher = activeUI.mdx.nodeMatcher(node).isMeasure();
if (someNodeMatcher.matches()) {
// process the node
} else {
throw new Error('please pass a valid MdxNode');
}
Terminate the chain of NodeMatchers by returning more details about the match. Call .matches() for the simple information of whether the NodeMatcher matches the MdxNode or not.
(any)
: a string if the match failed, or
null
if the match passed
{matchFailReason: (string | null), node: MdxNode}
const someNodeMatcher = activeUI.mdx.nodeMatcher(node).isMeasure();
if (someNodeMatcher.matches()) {
// process the node
} else {
const failureDetails = someNodeMatcher.matchDetails();
console.error('Cannot handle MdxNode', node, 'because the node', failureDetails.node, 'failed a check:', failureDetails.matchFailReason);
}
Combine the preceding and following NodeMatcher checks with OR instead of AND.
NodeMatcher
const nodeMatcher = activeUI.mdx.nodeMatcher(node).isScalar().or().isFunction('Filter').hasNArguments(2);
const result = nodeMatcher.matches();
// result == (node is a scalar OR (node is Filter function AND node has 2 arguments))
Provides a fluent API to match nodes in a parsed statement. Pass an MdxNode to this function to create a NodeMatcher that lets you write tests for the node and its children.
At the end of the chain, call .matches() to get a boolean result. If you need more information about the match success or failure, call .matchDetails() on the NodeMatcher.
Type: function (MdxNode): NodeMatcher
const nodeMatcher = activeUI.mdx.nodeMatcher(node);
const nodeIsAComparingFilterFunction = nodeMatcher
.isFunction("Filter")
.hasNArguments(2)
.subArg(1, conditionMatcher =>
conditionMatcher.isFunction("<", ">", "<=", ">=").hasNArguments(2)
)
.matches();
const isStringOrNullMatcher = activeUI.mdx.nodeMatcher(node).isString().or().isNull();
if (isStringOrNullMatcher.matches()) {
console.log(node, 'is a string or is NULL');
} else {
throw new Error('please pass a valid MdxNode');
}
A function that takes a NodeMatcher and returns a NodeMatcher. Usually a function like this will just call chaining methods on the given NodeMatcher to add checks, and return the new matcher.
Type: function (NodeMatcher): NodeMatcher
A logger that does not log anything. This is to be used CAREFULLY, because it does not even log errors.
Type: Object
{
key: 'noop',
args: {}
}
Type: Object
({}?)
(false?)
Creates a group of columns containing all the levels presenting measures (as opposed to members).
Type: Object
{
key: 'numeric',
args: {}
}
A plugin used when computing numerical scales, in order to customize the mapping of a value on a scale.
Type: Object
Type: Object
Opens a popup with the details of an alert.
Type: Object
{
key: 'open-alert',
args: {}
}
Opens a popup to choose where to display a drillthrough widget containing the result of the drillthrough on the given cell.
Type: Object
{
key: 'open-drillthrough',
args: {}
}
Opens a popup with the details of a message.
Type: Object
{
key: 'open-message',
args: {}
}
Opens a popup with the details of an alert.
Type: Object
{
key: 'open-monitor',
args: {}
}
Color scale of size 9 inspired from http://www.mulinblog.com/a-color-palette-optimized-for-data-visualization/
Type: Object
{
key: 'optimized',
args: {}
}
Type: Object
(TranslationParameters?)
(TranslationPath)
Type: Object
(ReactTranslationParameters?)
(TranslationPath)
Type:
("ASC" | "DESC")
Type: Array<TabularHeaderKey>
An MdxFunctionNode that represents a call to the Order function.
Type: (MdxFunctionNode & Object)
(([ExpressionNode, ExpressionNode, OrderModeLiteralNode] | [ExpressionNode, ExpressionNode]))
("Order")
Type:
("ASC" | "DESC" | "BASC" | "BDESC")
A LiteralNode that represents one of the OrderMode strings.
Type: (LiteralNode & Object)
("STRING")
(OrderMode)
Provide a set of colors given a set of values. Can be used to associate a particular color to a particular value
Type: Object
Type: Object
({}?)
Keeps the headers in the same order than in the data table.
Type: Object
{
key: 'original',
args: {}
}
Type: Object
(ReactTranslationPayload)
: The caption to display next to the UI control.
(string)
: The name of the parameter, that will be written in the plugin parameters.
(string)
: The type of UI control.
Type: Object
(ParameterName)
(Array<PointValue>)
Type: Object
(Array<PointValue>?)
(Array<ParameterReference>?)
(string)
(Array<ParameterFromTo>?)
Type: Object
((ParameterReference | PointValue))
(PointValue)
Type: string
Type: Object
(ParameterName)
(ActiveMonitorPeriod)
(ActiveMonitorPeriod)
({from: ActiveMonitorPeriod, to: ActiveMonitorPeriod})
Type: Object
(Array<PointValue>)
(Array<PointValue>)
(Timestamp)
Type: Object
Type: Object
(function (): Promise<Array<ParameterName>>)
: Gets the name of all parameters ever having a defined point value.
(function (ParameterName, boolean): Promise<Parameter>)
: Gets the definition of a parameter. Optional flag to include pending point values in the definition.
(function (Array<ParameterQuery>, boolean): Promise<Array<ParameterQueryResult>>)
: Gets the changes that occurred for multiple parameters in a given time window. flag to include pending changes in the differencial view.
(function (ParameterName): Promise<void>)
: Delete all values for a parameter. This will use the Repository api that does not trigger any workflow.
(function (): Promise<void>)
: Delete all parameter entries from the repository. This will use the Repository api that does not trigger any workflow.
(function (ParameterName): Promise<void>)
: Delete all values for a parameter. This will use the Repository api that does not trigger any workflow.
(function (ParameterName): Promise<Parameter>)
: Gets the effective definition of a parameter: a parameter definition with only effective point values.
(function (ParameterName): Promise<Array<PointValue>>)
: Gets the history of a parameter as the list of all versions of point values it owns.
(function ((ParameterChanges | Array<ParameterQuery>), boolean?): Promise<(ParameterChanges | Array<ParameterQueryResult>)>)
: Suggests updates for parameters. This will use ActiveMonitor workflows to perform the changes. Second parameter us a useUpdates flag indicating if the change definitions are full parameter definitions
or update definitions to be merged.
(function (): FeedInfo)
Formats axis tick labels into a percentage format. e.g. .1 -> 10%
Type: Object
(number)
: number of decimal points to include in the formatted number.
Integers will have decimal number of 0's appended. e.g. decimal(2) .1 -> 10.00%
{
key: 'percentage',
args: {
decimal: /* number */
}
}
Type: Array<PermissionGroup>
Type: Object
(PermissionGroups)
(PermissionGroups)
Show / Hide the grand total on rows
Type: Object
{
key: 'pivot-table-toggle-grand-total',
args: {}
}
Show / Hide the sub total on rows
Type: Object
{
key: 'pivot-table-toggle-subtotals',
args: {}
}
Type: Object
(function (parameters: PluginParameters<any, any>, activeUI: ActiveUI): {}?)
: Should return an object matching the type of the corresponding plugin properties.
(PluginKey)
: Used to reference this plugin implementation. This key will be used to declare the plugin in the configuration of a component. The couple (type, key) should be unique among your project to avoid any conflicts.
(PluginParametersSerializationFn?)
: Needs to be given when the implementation requires some parameters.
({}?)
: Should be an object matching the type of the corresponding plugin static properties.
A PluginDescription with an additional type property.
Type: (PluginDescription & Object)
(PluginType)
Type: string
The implementation has access to a merged object containing the type and implementations parameters.
Type: (ImplementationParameters & TypeParameters)
Indicates how to serialize and deserialize the parameters of a plugin implementation. For example: s13n => [{name: 'myParameter', sn: s13n.number}]
Type: Function
Type: string
Type: Object
(Timestamp?)
({})
(AuditTimeInfo)
(AuditTimeInfo?)
(Timestamp?)
(number)
(string)
(boolean)
(number)
Type: Object
(function (type: any, callback: function (): void): function (): void)
(function (type: any): void)
Create a popup, to be used in the UI.
Type: Object
(boolean?)
(function (multiBinding: MultiBinding, parameters: any, activeUI: ActiveUI): void?)
(function (multiBinding: MultiBinding, defaultClosePopup: ClosePopup): React.Element<any>)
(function (parameters: any): boolean)
Type: Object
Optional behaviors that can be customized on the popup.
Type: Object
(function (): void?)
: a function to execute after closing the popup
(boolean?)
: if true, closes the popup whenever the user clicks outside of it. Keep the popup open otherise
(ClosePopup?)
: a function to call to close the popup instead of the default one
(function (PopupReactClass): React.ComponentType<any>?)
(PopupSize?)
(boolean?)
(boolean?)
(function (multiBinding: MultiBinding, parameters: any, activeUI: ActiveUI): void?)
Type: Object
(function (): PopupContent)
: register and create the serializable Popup, not allowing for overrides
(function (): PopupContent)
: register and create the serializable Popup as an override
(function (): PopupPluginBuilder)
: auto close when clicking outside of the Popup
(function (cancelCallback: Todo, cancelText: string): PopupPluginBuilder)
: Add action for popup cancel buttoncreate
(function (key: string): PopupPluginBuilder)
: the key for the plugin
(function (PopupClass: Todo): PopupPluginBuilder)
: the React class to use for the content of the Popup
(function (submitCallback: Todo, submitText: string): PopupPluginBuilder)
: Add action for popup submit button
(function (style: {}): PopupPluginBuilder)
: the style for the Popup
(function (title: string): PopupPluginBuilder)
: the title to give to the Popup
(function (shoudRenderFn: function (): boolean): PopupPluginBuilder)
: should the popup render or not, based on the return value of the function
(function (parametersFunction: PluginParametersSerializationFn): PopupPluginBuilder)
: the parameters function
(function (): PopupPluginBuilder)
: Removes the drag feature of the Popup
Type: Class
The PopupBuilder
Type: Object
(function (bindingName: string): PopupWidgetBuilder)
: private
(function (key: string): PopupWidgetBuilder)
: The Popup plugin key
(function (parameters: {}): PopupWidgetBuilder)
: The Popup parameters, deserialized, to pass to the popup factory
(function (parameters: {}): PopupWidgetBuilder)
: The Popup parameters, already serialized, to pass to the popup factory
(function (e: AnyEvent, asPercentage: AsPercentage): PopupWidgetBuilder)
: Set where the popup position should be anchored from. The position is extracted from the mouse event,
meant to be used by the popup to render
(function (): PopupWidgetBuilder)
: Call if the background should become grey behind the popup
(function (): (function (): void | void))
: Create the popup. Return a function to close the popup
(function (string): Promise<void>)
: Start an application and return a promise which will resolve when the application is in a started state
(function (string, string): Promise<void>)
: Stop an application providing its name and the reason of the stop (used for audit purposes). Return a promise which will resolve when the application is in a stopped state
(function (): Promise<void>)
(function (string): CloudApplication)
(function (): Array<CloudApplication>)
Type: (SavedServerParameters & Object)
(ContentServer)
Open a popup to publish a calculated measure, moving its definition from the widget’s MDX to the content server.
Type: Object
{
key: 'publish-calculated-measure',
args: {}
}
API entry point for all queries to remote servers.
Type: Object
(function (): StaticDataQuery)
(QueriesPool)
(ServersPool)
Type: Object
Type: Todo
Open a popup to edit the mdx and context values of the widget
Type: Object
(boolean)
: A flag to make the mdx and context values read-only
{
key: 'query-editor',
args: {
readOnly: /* boolean */
}
}
Type: number
Type:
("QUOTED" | "UNQUOTED" | "AMP_QUOTED")
For a given axis, the actual slice of the server result that will be passed to the client on the network.
Type: Object
Example: for the rows axis, a thresholdPercentage of 0.1 for a chunkSize of 2000 means that the initial table will load the rows 0 to 2000, and when scrolling past row 1800, a new chunk of 2000 rows centered on 1800 will be downloaded from 800 to 2800, and so on.
To disable lazy loading, set chunkSize to -1 and any thresholdPercentage.
Type: Object
For each axis, the actual range of results that is being queried from the server.
Type: Object
On the client side, configure the lazy-loading of featured values, pivot tables and tabular views for each axis, i.e. the ability to defer the download of a subset of the results at the time the user is scrolling through them.
Type: Object
(RangeConfiguration?)
(RangeConfiguration?)
Formats axis tick labels to show just the numerical value without any group separation or other decoration 1,000,000 -> 1000000
Type: Object
{
key: 'raw',
args: {}
}
Type: Object
(function (Query): function (): void)
: Add the query to the list of this container's data sources.
Returns a function to unbind the query.
This should be called synchronously when the container mounts, otherwise it might not be picked up by some widgets on the dashboard (e.g. Mdx Editor).
(function (): {})
(function (): Array<DataSource>)
(function (): ReactContainerBody)
(function (ReactContainerBody): void)
A serializable object.
Type: Object
Type: Object
(ReactContainerApi)
(function (ReactContainerBody): void)
(ReactContainerBody)
Nothing, everything declared in ReactContainerImplementationStaticProperties.
Type: Object
Type: Object
(ContainerCategory?)
: The category of the container. Defaults to 'misc'.
(boolean?)
: Whether the container should appear in the container chooser. Defaults to
true
.
(React.Component<ReactContainerComponentProps>)
: The React component used to render the container.
(PluginKey?)
: The icon of the container. Defaults to 'common.world'.
(ContainerValue<ReactContainerBody>?)
: The initial configuration of the container,
used as default bookmark whenever the container is first created.
If not specified, it will be empty, with just the container key defined.
Type: (React.Element<any> | Array<React.Element<any>>)
Type: Array<(string | React.Element<any> | Array<React.Element<any>>)>
Type: (TranslationParameter | ReactOnlyTranslationParameter)
Parameters used when formatting the template, to be used in arguments of the message (https://formatjs.io/guides/message-syntax/). Can include React elements.
Type: Object<string, ReactTranslationParameter>
An object containing the translation or the options in order to generate a translation. The options may include React elements.
Type: (TranslatedText | OptionsForTranslationSupportingReact)
The formatted string, or an array of strings and objects if some of the parameters provided are React elements.
Type: (ReactOnlyTranslationResult | TranslationResult)
For a root widget, loads the next view
Type: Object
{
key: 'redo',
args: {}
}
Expands a node of a tree, if it is expandable.
Type: Object
(string?)
: The url of the server to refresh, if the action is not used on a tree
from which we can extract the information.
{
key: 'refresh-discovery',
args: {
serverUrl: /* string= */
}
}
Refresh the current query associated with the widget. Only available on widgets with data sources using mdx.
Type: Object
{
key: 'refresh-query',
args: {}
}
A type of MdxNode.
Type: Object
("Refresh")
(string)
Creates a group of columns based on a regexp ran on the column header value.
See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions for regexp documentation.
Type: Object
(string)
: The regexp pattern
(string)
: The regexp flags
(boolean?)
: If true, there will be one group per column. Defaults to false.
{
key: 'regexp',
args: {
pattern: /* string */,
flags: /* string */,
singleCells: /* boolean= */
}
}
An overlay displaying a line following a regression of a given type, calculated from the values
of the measure being used for the y axis. Only available on charts having a x and y axis, and with y being numerical
and x being a continuous axis (numerical or time). Different types of regressions are available through the type
parameter.
Type: Object
(string?)
: The color of the regression line.
(any?)
: A formatter specification understood by d3:
https://github.com/d3/d3-format/blob/master/README.md#api-reference
This formatter is used to format the equation coefs + r^2, and X and Y when the chart scales have no formatters.
((string | any)?)
: some optional parameter for the regression. It is used to pass the degree of the
polynomial regression.
(any?)
: A formatter used for the time in the tooltip, from the types.chartTimeFormatter plugin
(("linear" | "linear-through-origin" | "exponential" | "logarithmic" | "power-law" | "polynomial")?)
: The type of regression to use.
{
key: 'regression',
args: {
color: /* string= */,
formatter: /* *= */,
regressionParam: /* (string|*)= */,
timeFormatter: /* *= */,
type: /* ("linear"|"linear-through-origin"|"exponential"|"logarithmic"|"power-law"|"polynomial")= */
}
}
Renders an cell displaying the time relatively.
Type: Object
{
key: 'relative-time',
args: {}
}
A builder that allows to load a remote bookmark inside a dock.
Extends ABuilderBasedOnDock
Call to pass the content server url
(string)
the content server url from which to fetch the bookmark
RemoteBookmarkBuilderBasedOnDock:
Call to pass the bookmark id on the content server
(string)
RemoteBookmarkBuilderBasedOnDock:
An action to remove the widget from its parent dashboard. Only available when the widget is in a dashboard.
Type: Object
{
key: 'remove-dock',
args: {}
}
A function to call to detach a listener.
Type: function (): void
Opens a popup to rename a server from the serversPool.
Type: Object
{
key: 'rename-server',
args: {}
}
This object is produced after processing the different plugins for generating the columns etc.
Type: Object
(Array<TabularHeaderCaption>)
: the generated captions for the header, which is the output of the caption producer plugin
for that column.
(number)
: The index at which the column is displayed in the table.
(string)
: The key of the column. This is the same as the header value in the data for simple columns,
but it is generated in the case of a grouped column, as a combination of the columnSelector and columnFactory.
(Array<number>)
: The indexes of the columns composing this column in the data. Could be empty when the column
is not backed by data, for example the line numbers column.
(boolean)
Type: Object
(any)
: The chart library, with methods to access the scales etc.
(any)
: The chart api for the given layer on which the overlay is applied.
(number)
: The index of the overlay in the given layer.
(any)
: The data used to render the chart. This object has a different shape than the data
Table
because it supports the grouping per attribute.
Describes what report should be created and how it should be consumed. See https://support.activeviam.com/confluence/display/AP5/Reporting+and+scheduling.
Type: Object
Reset a root widget to its default view
Type: Object
{
key: 'reset-to-default-view',
args: {}
}
Sorts the headers in the reverse order than in the data table.
Type: Object
{
key: 'reverse',
args: {}
}
Type: string
Type: Object
({})
Renders a row action, displayed by default at the end of each row in a table widget.
Type: Object
(function ({columnProps: TabularColumnProps, index: number, rowIndex: number}): string?)
: the icon to use for the row action.
(function ({columnProps: TabularColumnProps, index: number, isDisabled: boolean, rowIndex: number}): Style?)
: the style to apply on the row action.
(function ({columnProps: TabularColumnProps, index: number, rowIndex: number}): boolean?)
: whether the button should be disabled.
(function (e: AnyEvent, {columnProps: TabularColumnProps, index: number, rowIndex: number}): void?)
: the click handler for the row action.
(function (index: number, rowIdx: number, columnProps: TabularColumnProps): React.Element<any>??)
: render the row action. The other properties will not be called if this one is defined.
(function ({columnProps: TabularColumnProps, index: number, rowIndex: number}): TranslationPayload??)
Type: Object
Type: Object
(CellPosition?)
: the cell from which the user started to create a selection range.
The range should go from the anchor to last cell that was navigated to.
(CellPosition?)
: the last cell that the user navigated to.
This property is required to enable navigation and selection using the keyboard.
(number)
(number)
Customizes the style of all the cells in a row.
Type: Object
(function (rowIndex: number, columnsProps: Array<TabularColumnProps>): Style?)
Type: Object
Use https://github.com/punkave/sanitize-html to sanitize HTML.
Allows the img tag on top of the default allowed ones.
Type: Object
{
key: 'sanitized-html',
args: {}
}
Save the changes of the widget.
Type: Object
{
key: 'save',
args: {}
}
Save the current widget in a bookmark. It will display the bookmark popup.
Type: Object
{
key: 'save-as',
args: {}
}
Type: Object
Formats axis tick labels into scientific notation. e.g. 1000 -> 1e+3%
Type: Object
(number)
: number of decimal points to include in the formatted number.
Integers will have x number of 0's appended. e.g. decimal(2) 1000 -> 1.00e+3
{
key: 'scientific',
args: {
decimal: /* number */
}
}
Select the active filters from a statement.
(MdxType.StatementAndDiscovery)
(MdxFilterSelectorImplementationProperties)
the selector to use to filter the returned active filters.
Array<FilterType.AugmentedActiveFilter<any>>
A styler that highlights selected chart elements.
Type: Object
{
key: 'selection-highlight',
args: {}
}
An MdxNode representing a SELECT statement or a subselect.
Type: (SelectStatementNode | SubSelectNode)
An MdxNode representing a SELECT statement.
Type: Object
("Select")
((SubSelectNode | FromClauseNode))
(AxisNode)
(Array<FormulaNode>)
Semantic Version Object
Type: Object
This is a fake action, it is used to separate items in context menus, but does not do anything on execute.
Type: Object
{
key: 'separator',
args: {}
}
The serialized representation of a plugin.
When the key & args form is given, the args will be given as parameters to the plugin when deserializing it.
Type: Object
(function (): string)
(function (): string)
(function (): ServerKey)
(function (): Url)
(function (): Promise<ServerVersion>)
(function (): boolean)
(function (): boolean)
(function (): void)
(function (): Promise<void>)
(function (): void)
(function (): void)
(function (string): void)
(function (): void)
(function (): void)
Type:
("jwt" | "content" | "pivot" | "sentinel" | "reporting" | "portal")
Type: Object
Type: Object
(Array<ServerApiVersion>)
Type:
("pivot" | "monitor" | "content" | "portal")
Type: Object
(function (ActiveMonitorServerParameters): ActiveMonitorServer)
(function (ActivePivotServerParameters): ActivePivotServer)
(function (ContentServerParameters): ContentServer)
(function (Listener<void>, boolean): RemoveListener)
(function (PortalServerParameters): PortalServer)
(function (Url): ActiveMonitorServer)
(function (): Array<ActiveMonitorServer>)
(function (Url): ActivePivotServer)
(function (): Array<ActivePivotServer>)
(function (Url): ContentServer)
(function (): Array<ContentServer>)
(function (Url): PortalServer)
(function (): Array<PortalServer>)
(function (Url): void)
(function (Url): void)
(function (Url): void)
(function (Url): void)
Type: Object
Type: string
Type: string
Settings Manager
Type: Object
(function (key: SettingKey, callback: Listener<SettingValue>, callImmediately: boolean): RemoveListener)
: Listen to the value of the given setting.
If
callImmediately
is set to true, the callback will be called immediately with the current value.
(function (key: SettingKey): boolean)
: Check the origin of the given setting.
If it is a permissions file, then editing the setting is not allowed.
In other words, return
true
if the setting key provided is a user setting, and
false
otherwise.
(function (key: SettingKey, logIfUnexisting: boolean): SettingValue)
: Return the setting value corresponding to the given key if found, undefined otherwise.
Example:
settingsManager.get('component.canEdit')
(function (filteringFunction: function (key: SettingKey): boolean): Array<SettingValue>)
: Return all the setting values for which the filtering function, taking as input a setting key,
has returned true.
(function (key: SettingKey): SettingValue)
: Similar to get, but logs if the setting key does not exist.
(function (key: SettingKey): SettingValue)
: Return the initial default value of a setting.
(function (filteringFunction: function (key: SettingKey): boolean): Array<SettingKey>)
: Return an array of setting keys, for which the filtering function on settings keys has
return true.
(function (): SettingsOrigins)
: Get SettingsOrigins. Example:
{
"widgets.Tabular.multiBinding": "code",
"widgets.SearchableTabular.multiBinding": "code",
"servers": "user/preferences"
}
(function (key: SettingKey): boolean)
: Return
true
if the setting key provided exist in the settings map,
false
otherwise.
(function (): Promise<any>)
: Return a promise that will be resolved when the settings are synchronized with the Content Server.
If the SettingsManager doesn't listen to any Content Server, the promise will be resolved immediately.
(function (key: SettingKey): Promise<any>)
: Remove the setting corresponding to the given setting key.
(function (key: SettingKey, newValue: SettingValue): Promise<any>)
: Set the value of a setting if allowed to.
A setting cannot be overridden if it is defined in a permissions file.
If editing is allowed, the new value will be written synchronously in the settings binding.
If attached to a repository, a request will also be made to change the setting by writing into its
preferences file.
Examples:
settingsManager.set('component.canEdit', true);
settingsManager.set('global.theme', 'dark').then(() => settingsManager.set('global.locale', 'en-US'));
Returns:
(function (): string?)
(function (key: SettingKey): boolean)
(function (key: SettingKey): boolean)
Type: Object<SettingKey, SettingValue>
Type: any
Shade colors are generated by shading or tinting the primary1Color, accent1Color and canvasColor. The disabledTextColor, disabledColor and borderColor are generated by modifying the opacity of the textColor.
This palette can be derived from the CorePalette.
Type: Object
An action to restore the default built-in widgets in the dashboard.
Type: Object
{
key: 'show-default-widgets',
args: {}
}
This caption producer simply returns the caption defined in the caption parameter, or the translated version of a caption defined in the locales files via the captionData and captionPath parameters.
Type: Object
{
key: 'simple',
args: {
caption: /* string */,
captionData: /* * */,
captionPath: /* * */
}
}
Type: Object
Type: Object
Type: Array<SimpleTableCell>
Type: Array<SimpleTooltipEntry>
Type: Object
Type: Object
(SimpleTooltipEntries)
Automatically format a date based on how much details the date contains. If the date contains milliseconds, the date will be formatted in 'minutes:seconds.milliseconds' format. If the date contains seconds, the date will be formatted in 'hours:minutes:seconds' format. If the date contains minutes, the date will be formatted in 'years/month/day hours:minutes:seconds' format. If the date contains hours, the date will be formatted in 'years/month/day hours:minutes' format. Otherwise the date will be formatted in 'years/month/day' format.
Type: Object
{
key: 'simplified',
args: {}
}
A component that displays the values returned by a single mdx query. Accepts either a query object or an mdx in order to create a query automatically.
Extends SingleQueryBuilder
Define the string of the MDX query to use in the built presentation.
(string)
SingleMdxQueryBuilder:
the builder for chained calls.
Defines the server url to use for the mdx query
(string)
SingleMdxQueryBuilder:
the builder for chained calls.
Defines the context values to use for the mdx query
(Object)
SingleMdxQueryBuilder:
the builder for chained calls.
Defines the update mode to use for the query
(String)
SingleMdxQueryBuilder:
the builder for chained calls.
Defines the application name to use for the query
(String)
SingleMdxQueryBuilder:
the builder for chained calls.
Responsible of building a component that displays the values returned by a single query (static or from mdx).
Extends NewBookmarkBuilderBasedOnDock
Define the query to use in the built presentation.
((MdxQuery | StaticDataQuery))
the configurations to use.
SingleQueryBuilder:
the builder for chained calls.
Defines a configuration to be merged into the playground state
(Object)
SingleQueryBuilder:
the builder for chained calls.
Select the coordinates of the cell to read from in the table.
Type: Object
Type: Object
Type: Object
(number)
(Array<TabularHeaderCaption>)
(TabularHeaderKey)
({captions: Array<TabularHeaderCaption>, key: TabularHeaderKey})
Each role is overridden by the following ones.
Type: string
Renders the underlying columns as sparklines, using some of the columns for the color range of the sparklines.
Type: Object
({}?)
(number?)
: The height of the sparkline cells.
{
key: 'sparkline-dynamic-color',
args: {
configuration: /* {}= */,
height: /* number= */
}
}
Renders the underlying columns as sparklines.
Type: Object
({}?)
(number?)
: The height of the sparkline cells.
{
key: 'sparkline-no-color',
args: {
configuration: /* {}= */,
height: /* number= */
}
}
Type: Object
("standalone")
Asks a cloud application to start a server.
Type: Object
A parsed MDX statement and the discovery it is meant to be run with.
Type: Object
(Discovery)
(SelectNode)
: This will usually be a
SelectStatementNode
, but a
SubSelectNode
is valid too.
Type: Object
(function (): QueryId)
(function (): Table)
(function (): void)
(function (): void)
(function (Table): StaticDataQuery)
Asks a cloud application to stop a server.
Type: Object
A function that takes any number of pieces (strings or nested arrays of strings) as arguments and returns the glued string.
Type: function (): string
A type of MdxNode.
Type: Object
Type: CSFile<StructureMetaData, void>
Type: Object
Type: Object<CssProperty, CssValue>
This is a fake action, used to offer sub-menus in context menus.
Type: Object
{
key: 'sub-menu',
args: {
caption: /* TranslationPayload */,
iconSrcKey: /* string */,
menuItems: /* Array.<SerializedPlugin> */
}
}
An MdxNode representing a subselect expression.
Type: Object
("SubSelect")
((SubSelectNode | FromClauseNode))
(boolean)
(AxisNode)
Type:
("Property" | "Function" | "Method" | "Infix" | "Prefix" | "Postfix" | "Parentheses" | "Braces")
Data structure used as the data input for all ActiveUI widgets.
Use TableFromCellSet to create one from a CellSet. Use TableFromDrillthroughDataSet to create one from DrillthroughDataSet.
Type: Object
(TableColumnCount)
(TableContent)
(TableHeaders)
(TableMembersHeaderCount)
(TableRangeData?)
(SourceId)
(TableVersion)
The first and last indexes of the axis range, with the total size of the axis
Type: Object
Type: Object
(TableCellCaption)
: the caption of the cell.
(TableCellValue)
: the content of the cell.
(TableCellColumnValue?)
: the value of this cell projected to the column containing this cell. For cells
created from a CellSet axis member the value is the member unique name and the columnValue is the level discriminator
toString for the level represented by this column.
(Object?)
: properties of the cell. Conveniently stores the MDX cell properties when existing.
(boolean?)
: Whether the cell of the table represents a total regarding its column. In
mdx it means that the cell does not represent a member of the level of the column. The boolean is only present
if it is true.
(TableCell?)
(TableVersion?)
Used to display the value of the cell in the UI.
Type: string
Contains the value of the cell for data manipulation.
The size of cellSet columns axis (i.e. number of positions)
Type: number
Array of tuples with the same length corresponding to the number of columns in the table.
Type: Array<TableTuple>
Type: Object
(TableFromCellSet)
(TableFromDrillthroughDataSet)
Convert a CellSet to a Table data representation. Expect to have at most two axes in the cellSet.
There are two distinct types of columns that appear when looking at a pivot table displaying a cellSet:
ROWS axis headersThe columns containing the ROWS axis are converted to as many columns as there are levels expressed in the members
on the ROWS axis. So even if there is a single hierarchy in the MDX query, the output Table can contain
multiple columns. These columns are level columns, so their TableHeader is of the form:
{
isNumeric: false,
captions: ['theLevelCaption'],
value: 'theLevelUniqueName'
}
The other columns are measures columns. We create one column per column you see in the pivot table.
If some cells of the cellSet are not defined because the underlying measure did not return any value,
the TableCell of the corresponding line will contain an EmptyTableCell at this position.
The TableHeader for this kind of columns is more complex. This is because it needs to represent the MDX
coordinates of the given column.
If there is no CrossJoin on the COLUMNS axis, the header will be straightforward, and be like:
{
isNumeric: true,
captions: ['Count'],
value: '[Measures].[contributors.COUNT]'
}
But if the user CrossJoined the measures with a hierarchy, like Desk with 2 members on the second level
DeskA and DeskB, and then 10 Book members below, we will have 20 columns, with headers like:
{
isNumeric: true,
captions: ['Desk A', '2', 'Count'],
value: '([AllMember].[DeskA].[2],[Measures].[contributors.COUNT])'
}
Type: function (cellSet: CellSet, cubeDiscovery: CubeDiscovery, translator: Translator, sourceId: SourceId, dataVersion: TableVersion): Table
Convert DrillthroughDataSet to a Table. When a column has both its value and caption asked, the two column are merged into a single one.
Type: function (drillthrough: DrillthroughDataSet, columns: DrillthroughColumns, sourceId: SourceId, dataVersion: TableVersion): Table
Type: Object
(Array<TableHeaderCaption>)
: the caption of the header in an array formed by the captions of potentially crossJoined headers.
(boolean)
: Indicates whether the corresponding
TableCell
s have numerical
TableCellValue
.
This is required by the charts library for instance.
(TableHeaderValue)
Type: string
Type: Array<TableHeader>
Used in all the widgets configurations to find the corresponding data column to display. It's thus important to understand how it is computed from the CellSet in order to be able to write your widget configurations correctly.
Type: string
The size of cellSet rows tuple (i.e. containing only members)
Type: number
Type: Array<TableSelectionRange>
Lets projects interact with the core tabular selection.
Type: Object
(function (selection: TableSelection, api: WidgetApi): void?)
: Is called back each time that the selection changes.
(function (selection: TableSelection, api: WidgetApi): TableSelection?)
: Lets you apply a custom selection on the fly, instead of the default one.
Type: Object
Type: Object
(RowOrColumnRange?)
: a selection can be initiated from a parent column header.
In this case, all its children columns are represented by this property and should remain selected during the rest of the user action.
(CellPosition?)
: the cell from which the user started to create a selection range.
The range should go from the anchor to last cell that was navigated to.
(RowOrColumnRange)
: the range of columns over which the selection range spans.
(CellPosition?)
: the last cell that the user navigated to.
This property is required to enable navigation and selection using the keyboard.
(RowOrColumnRange)
: the range of rows over which the selection range spans.
Type: Array<(TableCell | EmptyTableCell)>
Integer that can be incremented to indicate that the data contained in the table has changed.
Type: number
Remove the sorting based on the context that received the click.
Type: Object
{
key: 'tabular-clear-sort',
args: {}
}
A tabular view action that allows to collapse the view on a given member.
Type: Object
{
key: 'tabular-collapse-level',
args: {}
}
A tabular view action that allows to create a calculated measure that computes the difference between two selected columns.
Type: Object
{
key: 'tabular-column-difference',
args: {}
}
Type: Object
(WidgetApi)
: The api of the table (could by a pivot-table, tabular-view, ...).
(function (): {})
(string)
: The key of the column.
(number?)
: The index of the column (equivalent to
renderableTabularHeader.dataIds[0]
). This variable
is only set for columns rendered regularly, not by a
columnsGroup
. For these, it is up to the column factory
to enrich the columnProps with that information.
(Table)
: The data backing the table.
(any)
(number)
: The column width
(Style)
(function (): MultiBinding)
Set the cell as edited in the tabular configuration.
Type: Object
{
key: 'tabular-edit-cell',
args: {}
}
Set the header as edited in the tabular configuration.
Type: Object
{
key: 'tabular-edit-header',
args: {}
}
A tabular view action that allows to expand the view on a given member (opens a popup to choose the level on which to expand).
Type: Object
{
key: 'tabular-expand-level',
args: {}
}
Freezes the column so that it is always visible in the table.
Type: Object
{
key: 'tabular-freeze-header',
args: {}
}
Type: Object
("tabular-handler")
(WidgetApi)
Type: Object
Type: Object
(RenderableTabularHeader)
("header")
Type: string
Type: string
Opens a popup to customize the look of a header.
Type: Object
{
key: 'tabular-header-style',
args: {}
}
An action that allows to remember/forget the order in which levels were expanded in a table.
Type: Object
Type:
("remember" | "forget")
Remove a column from the table. Just hide it if the column is needed for data integrity.
Type: Object
{
key: 'tabular-remove-header',
args: {}
}
Set the cell as selected in the tabular configuration.
Type: Object
{
key: 'tabular-select-cell',
args: {}
}
Set the column as selected in the tabular configuration. Supports the multi-selection when the user uses the keys ctrl or shift while he clicks.
Type: Object
{
key: 'tabular-select-column',
args: {}
}
This action is meant to be used on tabular headers. It adds the tree cell column configuration to the list of column groups of the tabular if it was not there, or removes it if it was already there.
Type: Object
{
key: 'tabular-show-sparklines',
args: {}
}
This action is meant to be used on tabular headers. It adds the tree cell column configuration to the list of column groups of the tabular if it was not there, or removes it if it was already there.
Type: Object
{
key: 'tabular-show-tree-column',
args: {}
}
Apply a sorting based on the context that received the click.
Type: Object
(OrderDirection)
: a parameter used to specify the direction of the sort, but it's breaking/non-breaking behavior
will be read from the tabular configuration (sortingMode: 'breaking' | 'non-breaking').
(OrderMode)
: a parameter used strictly for the direction of the sort to perform.
{
key: 'tabular-sort',
args: {
direction: /* OrderDirection */,
orderMode: /* OrderMode */
}
}
This action is meant to be used on tabular headers. It adds the tree cell column configuration to the list of column groups of the tabular if it was not there, or removes it if it was already there.
Type: Object
{
key: 'tabular-sparkline-add-colors',
args: {}
}
Show a tooltip for the tabular view/pivot table widget.
Type: Object
(number)
: The timeout after which the tooltip should appear.
{
key: 'tabular-tooltip-show',
args: {
timeout: /* number */
}
}
Color scale of size 3 based on the current theme: text, accent and alternate colors
Type: Object
{
key: 'theme-3',
args: {}
}
Type: Object
Customizes the colors used by ActiveUI components. If "fromTheme" is given, all the colors are optionals, otherwise, the palette need to have at least the colors of the CorePalette. All the colors defined in FullPalette can be given to override the default derivation behaviour when creating the full theme.
Type: ({palette: CorePalette} | {fromTheme: SerializedPlugin, palette: {}})
Type: Object
(boolean?)
: If false, the theme will be disabled in the theme selector widget.
Type: Object
(function (): FullPalette)
(function (): Array<ThemeDescription>)
Toggle the title bar of the widget.
Type: Object
{
key: 'toggle-dock-title-bar',
args: {}
}
Toggle the filters area at the top of the widget. This is only available on widgets that use mdx.
Type: Object
{
key: 'toggle-filters',
args: {}
}
Toggle between editing and preview mode for the RichTextEditor container.
Type: Object
{
key: 'toggle-text-editing',
args: {}
}
Toggles the expansion of the node of a tree, if it is expandable.
Type: Object
{
key: 'toggle-tree-node',
args: {}
}
Toggle the wizard. This is only available with the pivot table widget.
Type: Object
{
key: 'toggle-wizard',
args: {}
}
Displays a tooltip (in the UI).
Type: Object
(function (): React.Element<any>)
Type: Object
A table transformer taking as a first argument the table to transform and as a second argument a callback to return the new table transformed.
Type: Object
(string)
Describe all translations
Parameters used when formatting the template, to be used in arguments of the message (https://formatjs.io/guides/message-syntax/)
Type: Object<string, TranslationParameter>
A string symbolizing the path to the translation in the translation tree. For example 'general.cancel'. The different path segments are separated by dots.
Type: string
An object containing the translation or the options in order to generate a translation.
Type: (TranslatedText | OptionsForTranslation)
The formatted string.
Type: string
Contains all translations and configuration for a specific locale
(LocaleConfig)
Type: Object
(function (path: TranslationPath, parameters: TranslationParameters): TranslationResult)
: Gets the translation for a given template. Uses the locale stored in the global state.
(function (time: (Timestamp | Date), options: {}): string)
: Formats a time relatively to now(), using the current locale. Optionally takes some options, as detailed on
https://github.com/yahoo/intl-relativeformat#custom-options
(function (getLocale: function (): Locale, getTranslation: function (Locale): any): void)
(function (path: TranslationPath, parameters: ReactTranslationParameters): ReactTranslationResult)
(function (): LocaleConfig)
(function (): Locale)
(function (locale: Locale): any)
(function (options: (ReactTranslationPayload | void)): (ReactTranslationResult | void))
(function (path: TranslationPath, parameters: TranslationParameters, fallbackText: string): TranslationResult?)
Renders the underlying columns as a tree.
Type: Object
(boolean?)
(boolean?)
(SerializedPlugin?)
: The serialized representation of a plugin of type
OrdinalColorScaleImplementationProperties
({}?)
: A dictionary of level to expand under a given level.
For example
{'[Booking].[Desk].[Desk]': '[Booking].[Desk].[BookId]'}
will expand '
[Booking]
.
[Desk]
.
[BookId]
' right
under the level '
[Booking]
.
[Desk]
.
[Desk]
'. This can be used to pre-configure an expansion path, and mix levels
from different hierarchies.
(boolean?)
(string?)
: will highlight in the cells the characters matching the regexp.
{
key: 'treeCells',
args: {
allowExpandCollapse: /* boolean= */,
automaticExpansion: /* boolean= */,
colors: /* SerializedPlugin= */,
expansionPairs: /* {}= */,
restrictedExpansion: /* boolean= */,
searchTerm: /* string= */
}
}
Type: Object
Type: Object
(T)
: Some data purposedly attached to the node
({caption: string?, captionPath: string?, expandable: boolean, expanded: boolean, iconSrcKey: string?, nodeIndex: number, tooltipContent: Array<any>?})
: The atttributes used for rendering the node, such as the caption
(TreeNodeSourceObject?)
: The object that the node represents, independently of its rendering. It can be for
example the bookmark attached to the node in the bookmark tree, or the representation of the discovery node.
(string?)
(string?)
(boolean)
(boolean)
(string?)
(number)
(Array<any>?)
Show a tooltip for the tree widget, if the node contains information to display.
Type: Object
(number?)
: The timeout after which the tooltip should appear.
{
key: 'tree-tooltip-show',
args: {
timeout: /* number= */
}
}
For a root widget, loads the previous view
Type: Object
{
key: 'undo',
args: {}
}
A CompoundIdentifierNode representing an unknown identifier.
This type is used for any compound identifier node whose type cannot be identified. This is particularly the case for any member but measures when not providing a discovery to the parser. It does apply to members when the dimension is not referenced by the discovery but not to members where the hierarchy is unknown.
Type: Object
Type:
("once" | "realTime" | "refresh-periodically")
Change the query update mode to the next mode of:
Only available on widgets with data sources using mdx.
Type: Object
(number)
: the interval in seconds between two refreshes of the query, when the query is in
'refresh-periodically' mode
{
key: 'update-query-mode',
args: {
modes: /* Array.<string> */,
refreshInterval: /* number */
}
}
Type: string
Matches non server filters with the provided key
Type: Object
{
key: 'user',
args: {}
}
Type: string
A logger that logs everything.
Type: Object
{
key: 'verbose',
args: {}
}
A logger that only logs warnings and errors.
Type: Object
{
key: 'warnings',
args: {}
}
An action to start watching a measure in a table.
Type: Object
{
key: 'watch-measure',
args: {}
}
An MdxNode representing a WHEN clause of a CaseExpressionNode, including the clause’s THEN true result expression.
Type: Object
Type: Todo
Open a popup to export the data of the widget into a csv file. Only available if the underlying table is fully downloaded (i.e. not lazy loaded).
Type: Object
{
key: 'widget-csv-export',
args: {}
}
Type: Object
(function (): Promise<void>)
: A promise returning when all the widgets are loaded with their queries having returned (if any).
Type: Object
(AuditTimeInfo)
(string)
(WorkflowEntityType)
(WorkflowSchemeName)
Type: string
Type: string
Type: Object
(function (WorkflowEntityType): Promise<WorkflowScheme>)
: Gets the definition of a given scheme for a particular entity type.
(function (WorkflowEntityType): Promise<Array<WorkflowEntity>>)
: Gets all existing schemes for a particular entity type.
(function (WorkflowEntityType, WorkflowEntityKey): Promise<WorkflowSchemeName>)
: Gets the scheme of a particular entity.
(function (WorkflowEntityType, WorkflowEntityKey, WorkflowSchemeName): Promise<void>)
Type: Object
Type: string
Type: Function
(PopupReactClass)
The popup class to be wrapped
(string)
the key of the popup plugin class
(PluginParametersSerializationFn)
The function indicating how to serialize and deserialize the parameters of the popup plugin implementation
(function (params: PopupParameters<any>): boolean)
function that return true or false, depending on whether the popup shoud be rendered or not
(PopupOptions)
Optional behaviors that can be customized on the popup.
({})
Optional props passed in to popup.