@adaptabletools/adaptable 24.0.0-canary.8 → 24.0.0

package/src/Api/ColumnScopeApi.d.ts

@@ -2,122 +2,144 @@ import { AdaptableColumn } from '../AdaptableState/Common/AdaptableColumn';
 import { ColumnScope, ScopeDataType } from '../AdaptableState/Common/ColumnScope';
 import { CellColorRange } from '../AdaptableState/StyledColumns/Common/NumericStyledColumn';
 /**
- * Provides access to a suite of functions related to the `Column Scope` object
+ * Whether a column is inside a Column Scope, and the columns, types and data types a scope contains.
  */
 export interface ColumnScopeApi {
     /**
      * True if Column is in given Scope
      * @param column Column to check
      * @param scope   The Scope to check
+     * @returns True if Column is in given Scope
      */
     isColumnInScope(column: AdaptableColumn | undefined, scope: ColumnScope): boolean;
     /**
      * Returns list of all Columns in the given Scope
      * @param scope the Scope to check
+     * @returns List of all Columns in the given Scope
      */
     getColumnsInScope(scope: ColumnScope): AdaptableColumn[];
     /**
      * True if Scope is empty
      * @param scope Scope to check
+     * @returns True if Scope is empty
      */
     scopeIsEmpty(scope: ColumnScope): boolean;
     /**
      * True if Scope is 'All'
      * @param scope Scope to check
+     * @returns True if Scope is 'All'
      */
     scopeIsAll(scope: ColumnScope): boolean;
     /**
      * True if Scope contains DataTypes
      * @param scope Scope to check
+     * @returns True if Scope contains DataTypes
      */
     scopeHasDataType(scope: ColumnScope): boolean;
     /**
      * True if Scope contains ColumnTypes
      * @param scope Scope to check
+     * @returns True if Scope contains ColumnTypes
      */
     scopeHasColumnType(scope: ColumnScope): boolean;
     /**
      * True if Scope is DataTypes and contains just 'Boolean'
      * @param scope Scope to check
+     * @returns True if Scope is DataTypes and contains just 'Boolean'
      */
     scopeHasOnlyBooleanDataType(scope: ColumnScope): boolean;
     /**
      * True if Scope contains just 1 ColumnId
      * @param scope Scope to check
+     * @returns True if Scope contains just 1 ColumnId
      */
     isSingleColumnScope(scope: ColumnScope): boolean;
     /**
      * Gets the only Column in given Scope
      * @param scope Scope to check
+     * @returns The only Column in given Scope
      */
     getSingleColumnInScope(scope: ColumnScope): string | undefined;
     /**
      * True if Scope contains just 1 numeric Column
      * @param scope Scope to check
+     * @returns True if Scope contains just 1 numeric Column
      */
     isSingleNumericColumnScope(scope: ColumnScope): boolean;
     /**
      * True if Scope contains just 1 boolean Column
      * @param scope Scope to check
+     * @returns True if Scope contains just 1 boolean Column
      */
     isSingleBooleanColumnScope(scope: ColumnScope): boolean;
     /**
      * True if all selected columns are boolean
      * @param scope Scope to check
+     * @returns True if all selected columns are boolean
      */
     areAllBooleanColumnsInScope(scope: ColumnScope): boolean;
     /**
      * True if Scope contains ColumnIds
      * @param scope Scope to check
+     * @returns True if Scope contains ColumnIds
      */
     scopeHasColumns(scope: ColumnScope): boolean;
     /**
      * Gets string representation of the Scope
      * @param scope Scope to check
+     * @returns String representation of the Scope
      */
     getScopeToString(scope: ColumnScope): string;
     /**
      * Whether PK column is included in Scope's column section
      * @param scope Scope to check
+     * @returns `true` when PK column is included in Scope's column section
      */
     isPrimaryKeyColumnInScopeColumns(scope: ColumnScope): boolean;
     /**
      * True if Column is in Scope's 'ColumnIds' section
      * @param column Column to check
      * @param scope Scope to check
+     * @returns True if Column is in Scope's 'ColumnIds' section
      */
     isColumnInScopeColumns(column: AdaptableColumn, scope: ColumnScope): boolean;
     /**
      * Returns all the ColumnIds in the Scope
      * @param scope Scope to check
+     * @returns All the ColumnIds in the Scope
      */
     getColumnIdsInScope(scope: ColumnScope): string[] | undefined;
     /**
      * Returns all the ColumnTypes in the Scope
      * @param scope Scope to check
+     * @returns All the ColumnTypes in the Scope
      */
     getColumnTypesInScope(scope: ColumnScope): string[] | undefined;
     /**
      * Returns all the DataTypes in the Scope
      * @param scope Scope to check
+     * @returns All the DataTypes in the Scope
      */
     getDataTypesInScope(scope: ColumnScope): ScopeDataType[] | undefined;
     /**
      * True if Scope has Numeric DataType containing Column
      * @param column Column to check
      * @param scope Scope to check
+     * @returns True if Scope has Numeric DataType containing Column
      */
     isColumnInNumericScope(column: AdaptableColumn, scope: ColumnScope): boolean;
     /**
      * True if Scope has text DataType containing Column
      * @param column Column to check
      * @param scope Scope to check
+     * @returns True if Scope has text DataType containing Column
      */
     isColumnInTextScope(column: AdaptableColumn, scope: ColumnScope): boolean;
     /**
      * True if Scope has Data DataType which contains Column
      * @param column Column to check
      * @param scope Scope to check
+     * @returns True if Scope has Data DataType which contains Column
      */
     isColumnInDateScope(column: AdaptableColumn, scope: ColumnScope): boolean;
     /**
@@ -134,11 +156,13 @@ export interface ColumnScopeApi {
      *
      * @param scopeA first Scope
      * @param scopeB second Scope
+     * @returns True if first scope is in second Scope Scope A | Scope B | Result =========================================================================== All * true * All true DataTypes DataTypes all DataTypes from A should be in B ColumnIds ColumnIds all ColumnIds from A should be in B ColumnIds DataTypes all DataTypes of ColumnIds from A should be in B DataTypes ColumnIds false
      */
     isScopeInScope(scopeA: ColumnScope, scopeB: ColumnScope): boolean;
     /**
      * Provides a description for the Scope
      * @param scope The Scope to check
+     * @returns A description of the scope
      */
     getScopeDescription(scope: ColumnScope): string;
     /**
@@ -148,11 +172,13 @@ export interface ColumnScopeApi {
      * sample values yet, returns one `0` → `0` gray range.
      *
      * @param scope Scope to use (must resolve to a single column for range sampling)
+     * @returns A single `CellColorRange` for Styled Column wizards (Gradient, Percent Bar, Bullet Chart): `Col-Min` → `Col-Max` with neutral gray, matching the colour used when adding a range in the Ranges UI. If the column has no sample values yet, returns one `0` → `0` gray range
      */
     createCellColorRangesForScope(scope: ColumnScope): CellColorRange[];
     /**
      * Gets any ColumnId from the Scope
      * @param scope Scope to check
+     * @returns Any ColumnId from the Scope
      */
     getAnyColumnIdForScope(scope: ColumnScope): string | undefined;
 }

package/src/Api/CommentApi.d.ts

@@ -1,14 +1,14 @@
 import { CommentThread } from '../AdaptableState/CommentState';
 import { AdaptableComment, CellAddress } from '../types';
 /**
- * Provides run-time access to Comment Module and related State
+ * Comments on cells. A thread holds the comments for one cell.
  */
 export interface CommentApi {
     /**
      * Add a Comment to a Comment Thread
      *
-     * @param comment comment
-     * @param cellAddress cell where comment is added
+     * @param commentText Text of the comment
+     * @param cellAddress Cell the comment is added to
      */
     addComment(commentText: string, cellAddress: CellAddress): void;
     /**
@@ -20,27 +20,30 @@ export interface CommentApi {
     editComment(comment: AdaptableComment, cellAddress?: CellAddress): void;
     /**
      * Delete a Comment
-     * @param address Location of the comment, if not provided all comments will be traversed to find the comment
+     * @param comment Comment to delete
+     * @param cellAddress Cell the comment belongs to
      */
     deleteComment(comment: AdaptableComment, cellAddress: CellAddress): void;
     /**
      * Create a new Comment Thread
      *
-     * @param commentThread
+     * @param commentThread Thread to create, including the cell it belongs to
      */
     addCommentThread(commentThread: CommentThread): void;
     /**
      *  Delete all Comments for a particular cell
-     * @param cellAddress
+     * @param cellAddress Cell whose comments are deleted
      */
     deleteCommentThread(cellAddress: CellAddress): void;
     /**
      * Return the Comment Thread for a particular cell
-     * @param cellAddress
+     * @param cellAddress Cell to read
+     * @returns Return the Comment Thread for a particular cell
      */
     getCommentThreadForCell(cellAddress: CellAddress): CommentThread | undefined;
     /**
      * Return all Comment Threads in the grid
+     * @returns Return all Comment Threads in the grid
      */
     getAllComments(): CommentThread[];
     /**

package/src/Api/ContextMenuApi.d.ts

@@ -1,6 +1,6 @@
 import { CustomContextMenuContext, AdaptableSystemContextMenuItem, AdaptableContextMenuItemName, MenuCategory, AdaptableIcon, CustomContextMenuItem, CustomGroupContextMenuItem } from '../types';
 /**
- * Provides run-time access to Context Menu
+ * The right-click menu: the default items, and adding or removing items.
  */
 export interface ContextMenuApi {
     /**
@@ -10,54 +10,63 @@ export interface ContextMenuApi {
     /**
      * Creates default menu structure; useful as final line in custom implementation
      * @param context Current Menu Context
+     * @returns The default menu: the AG Grid items, a separator, then the AdapTable items
      */
     createDefaultMenuStructure(context: CustomContextMenuContext): any;
     /**
      * Gets all Menu Items in a given category
      * @param category Category to filter on
      * @param context Current Menu Context
+     * @returns All Menu Items in a given category
      */
     getContextMenuItemsByCategory(category: MenuCategory, context: CustomContextMenuContext): AdaptableSystemContextMenuItem<AdaptableContextMenuItemName>[];
     /**
      * Gets all Menu Items in given categories
      * @param categories Categories to filter on
      * @param context Current Menu Context
+     * @returns All Menu Items in given categories
      */
     getContextMenuItemsByCategories(categories: MenuCategory[], context: CustomContextMenuContext): AdaptableSystemContextMenuItem<AdaptableContextMenuItemName>[];
     /**
      * Returns the Menu Item with given name
      * @param menuItemName Menu Item to filter on
      * @param context Current Menu Context
+     * @returns The Menu Item with given name
      */
     getContextMenuItemByName(menuItemName: AdaptableContextMenuItemName, context: CustomContextMenuContext): AdaptableSystemContextMenuItem<AdaptableContextMenuItemName>;
     /**
      * Returns the Menu Items with given names
      * @param menuItemNames Menu Items to filter on
      * @param context Current Menu Context
+     * @returns The Menu Items with given names
      */
     getContextMenuItemsByNames(menuItemNames: AdaptableContextMenuItemName[], context: CustomContextMenuContext): AdaptableSystemContextMenuItem<AdaptableContextMenuItemName>[];
     /**
      * Returns Menu Item with given label
      * @param label Label to filter on
      * @param context Current Menu Context
+     * @returns Menu Item with given label
      */
     getContextMenuItemByLabel(label: string, context: CustomContextMenuContext): AdaptableSystemContextMenuItem<AdaptableContextMenuItemName>;
     /**
      * Returns Menu Items with given labels
      * @param labels Labels to filter on
      * @param context Current Menu Context
+     * @returns Menu Items with given labels
      */
     getContextMenuItemsByLabels(labels: string[], context: CustomContextMenuContext): AdaptableSystemContextMenuItem<AdaptableContextMenuItemName>[];
     /**
      * Removes Menu Item with given name
      * @param menuItemName name of Menu Item to remove
      * @param context Current Menu Context
+     * @returns The menu items that remain
      */
     removeAdaptableContextMenuItemByName(menuItemName: AdaptableContextMenuItemName, context: CustomContextMenuContext): any;
     /**
      * Removes Menu Items with given names
      * @param menuItemNames names of Menu Items to remove
      * @param context Current Menu Context
+     * @returns The menu items that remain
      */
     removeAdaptableContextMenuItemsByNames(menuItemNames: AdaptableContextMenuItemName[], context: CustomContextMenuContext): any;
     /**
@@ -66,6 +75,7 @@ export interface ContextMenuApi {
      * @param subMenuItems Menu Items to place in Group
      * @param disabled whether group is disabled
      * @param icon icon for the Group Menu Item
+     * @returns The group menu item
      */
     createGroupMenu(label: string, subMenuItems: CustomContextMenuItem[], disabled?: boolean, icon?: AdaptableIcon): CustomGroupContextMenuItem;
 }

package/src/Api/CustomSortApi.d.ts

@@ -1,15 +1,17 @@
 import { ColumnValuesComparer } from '../AdaptableOptions/CustomSortOptions';
 import { CustomSortState, CustomSort } from '../AdaptableState/CustomSortState';
 /**
- *  Provides run-time access to the Custom Sort function
+ * Custom sort orders for columns: the values to show first, and which sorts are active.
  */
 export interface CustomSortApi {
     /**
      * Retrieves Custom Sort section from Adaptable State
+     * @returns Custom Sort section from Adaptable State
      */
     getCustomSortState(): CustomSortState;
     /**
      * Retrieves all Custom Sorts in Adaptable State
+     * @returns All Custom Sorts in Adaptable State
      */
     getCustomSorts(): CustomSort[];
     /**
@@ -31,6 +33,7 @@ export interface CustomSortApi {
     getLiveCustomSorts(): CustomSort[];
     /**
      * Returns all Custom Sort Comparers in Custom Sort Options that are currently applied
+     * @returns All Custom Sort Comparers in Custom Sort Options that are currently applied
      */
     getLiveCustomSortComparers(): ColumnValuesComparer[];
     /**
@@ -75,11 +78,12 @@ export interface CustomSortApi {
     /**
      * Edits a Custom Sort
      * @param customSort Custom Sort to Edit
+     * @returns The Custom Sort after it is saved
      */
     editCustomSort(customSort: CustomSort): CustomSort;
     /**
      * Removes Custom Sort for a given ColumnId
-     * @param column columnId on which to delete the Custom Sort
+     * @param columnId Column whose Custom Sort is removed
      */
     deleteCustomSort(columnId: string): void;
     /**

package/src/Api/DashboardApi.d.ts

@@ -8,19 +8,23 @@ import { CustomToolbar, DashboardButtonContext } from '../AdaptableOptions/Dashb
 export interface DashboardApi {
     /**
      * Retrieves Dashboard section from Adaptable State
+     * @returns Dashboard section from Adaptable State
      */
     getDashboardState(): DashboardState;
     /**
      * Retrieves all Custom Toolbars
+     * @returns All Custom Toolbars
      */
     getCustomToolbars(): CustomToolbar[];
     /**
      * Retrieves all Custom Buttons
+     * @returns All Custom Buttons
      */
     getCustomDashboardButtons(): AdaptableButton<DashboardButtonContext>[];
     /**
      * Retrieves first Custom Button with given Label
      * @param buttonLabel the label of the Custom Button to retrieve
+     * @returns First Custom Button with given Label
      */
     getCustomDashboardButtonByLabel(buttonLabel: string): AdaptableButton<DashboardButtonContext> | undefined;
     /**
@@ -29,13 +33,15 @@ export interface DashboardApi {
      */
     setModuleButtons(moduleButtons: AdaptableModuleButtons): void;
     /**
-     * Sets title of Dashboard Header
+     * Sets the title shown in the Dashboard header.
+     * @param title Title to display
      */
     setDashboardTitle(title: string): void;
     /**
      * Returns the HTML Element for the given Custom Toolbar. This should only be used in Vanilla AdapTable for toolbars created via a `render` function.
      * @param customToolbarName the name of the Custom Toolbar
      *
+     * @returns The HTML Element for the given Custom Toolbar. This should only be used in Vanilla AdapTable for toolbars created via a `render` function
      */
     getCustomToolbarHTMLElement(customToolbarName: string): HTMLElement | null;
     /**
@@ -48,6 +54,7 @@ export interface DashboardApi {
     /**
      * Returns Custom Toolbar with the given name
      * @param customToolbarName the name of the Custom Toolbar
+     * @returns Custom Toolbar with the given name
      */
     getCustomToolbarByName(customToolbarName: string): CustomToolbar;
     /**
@@ -93,30 +100,34 @@ export interface DashboardApi {
     showDashboard(): void;
     /**
      * Returns current Active Tab index (if there is one)
+     * @returns Current Active Tab index (if there is one)
      */
     getActiveTabIndex(): number | undefined;
     /**
      * Returns current Active Tab (if there is one)
+     * @returns Current Active Tab (if there is one)
      */
     getActiveTab(): DashboardTab | undefined;
     /**
-     * Sets Active Tab in Dashboard
+     * Selects the Dashboard tab at this index.
      *
-     * @param tabIndex the tab index to set
+     * @param tabIndex Zero-based index of the tab
      */
     setActiveTabIndex(tabIndex: number): void;
     /**
-     * Sets Active Tab in Dashboard
-     * @param tabName name of tab to set
+     * Selects the Dashboard tab with this name.
+     * @param tabName Name of the tab
      */
     setActiveTab(tabName: string): void;
     /**
      * Retrieves all Toolbars in Active Tab
+     * @returns All Toolbars in Active Tab
      */
     getCurrentToolbars(): AdaptableDashboardToolbars | string[];
     /**
      * Checks if a given Toolbar is visible
      * @param toolbar toolbar to check visibility for
+     * @returns `true` when a given Toolbar is visible
      */
     isToolbarVisible(toolbar: AdaptableDashboardToolbar | string): boolean;
     /**
@@ -126,52 +137,62 @@ export interface DashboardApi {
     /**
      * Retrieves the Tab from State that matches inputted name
      * @param tabName the tab to check
+     * @returns The Tab from State that matches inputted name
      */
     getTabByName(tabName: string): DashboardTab;
     /**
      * Is Dashboard Collapsed
+     * @returns `true` when dashboard Collapsed
      */
     isDashboardCollapsed(): boolean;
     /**
      * Is Dashboard Expanded
+     * @returns `true` when dashboard Expanded
      */
     isDashboardExpanded(): boolean;
     /**
      * Is Dashboard Floating
+     * @returns `true` when dashboard Floating
      */
     isDashboardFloating(): boolean;
     /**
      * Is Dashboard Docked
+     * @returns `true` when dashboard Docked
      */
     isDashboardDocked(): boolean;
     /**
      * Is Dashboard Hidden
+     * @returns `true` when dashboard Hidden
      */
     isDashboardHidden(): boolean;
     /**
      * Is Dashboard Visible
+     * @returns `true` when dashboard Visible
      */
     isDashboardVisible(): boolean;
     /**
-     * Updates the Tabs in the Dashboard
-     * @param Tabs
+     * Replaces the tabs shown in the Dashboard.
+     * @param Tabs Tabs to set, in order
      */
     setTabs(Tabs: DashboardTab[]): void;
     /**
      * Retrieves the Tabs in the Dashboard
+     * @returns The Tabs in the Dashboard
      */
     getTabs(): DashboardTab[];
     /**
      * Retrieves the Module Buttons in the Dashboard
+     * @returns The Module Buttons in the Dashboard
      */
     getModuleButtons(): AdaptableModuleButtons;
     /**
-     * Sets pinned toolbars
-     * @param toolbars
+     * Pins toolbars so they stay visible when the active tab changes.
+     * @param toolbars Toolbars to pin
      */
     setPinnedToolbars(toolbars: AdaptableDashboardToolbars | string[]): void;
     /**
      * Retrieves pinned toolbars
+     * @returns Pinned toolbars
      */
     getPinnedToolbars(): AdaptableDashboardToolbars | string[];
 }

package/src/Api/DataChangeHistoryApi.d.ts

@@ -1,11 +1,12 @@
 import { CellDataChangedInfo } from '../AdaptableState/Common/CellDataChangedInfo';
 import { GridCell } from '../types';
 /**
- * Provides run-time access to the Data Change History Module
- **/
+ * The history of cell value changes: the log, the latest change for a cell, and undo.
+ */
 export interface DataChangeHistoryApi {
     /**
      * Retrieves current Data Change History mode: 'ACTIVE', 'INACTIVE', 'SUSPENDED'
+     * @returns Current Data Change History mode: 'ACTIVE', 'INACTIVE', 'SUSPENDED'
      */
     getDataChangeHistoryMode(): 'ACTIVE' | 'INACTIVE' | 'SUSPENDED';
     /**
@@ -24,10 +25,13 @@ export interface DataChangeHistoryApi {
     suspendDataChangeHistory(): void;
     /**
      * Retrieves all data changes which are currently available
+     * @returns All data changes which are currently available
      */
     getDataChangeHistoryLog(): CellDataChangedInfo[];
     /**
-     * Retrieves last data change for a given Cell
+     * The most recent change recorded for a cell.
+     * @param gridCell Cell to look up
+     * @returns The most recent change recorded for a cell
      */
     getDataChangeForGridCell(gridCell: GridCell): CellDataChangedInfo | undefined;
     /**
@@ -40,11 +44,13 @@ export interface DataChangeHistoryApi {
      * Reverts provided data change to its previous value and returns GridCell that was undone
      *
      * @param dataChangeInfo the change to be undone
+     * @returns Reverts provided data change to its previous value and returns GridCell that was undone
      */
     undoDataChangeHistoryEntry(dataChangeInfo: CellDataChangedInfo): GridCell | undefined;
     /**
      * Reverts all data changes to previous values and returns GridCells that were undone
      *
+     * @returns Reverts all data changes to previous values and returns GridCells that were undone
      */
     undoAllDataChangeHistoryEntries(): GridCell[];
     /**

package/src/Api/DataImportApi.d.ts

@@ -1,5 +1,5 @@
 /**
- * Provides run-time access to the Settings Panel
+ * Data Import. Opens the wizard that imports rows into the grid.
  **/
 export interface DataImportApi {
     /**

package/src/Api/EntitlementApi.d.ts

@@ -1,31 +1,36 @@
 import { AdaptableModule, AccessLevel, AdaptableObject } from '../types';
 /**
- * Provides functions for Entitlements and Permissions
+ * Whether a module is hidden, read-only or fully available, and whether an object is read-only.
  **/
 export interface EntitlementApi {
     /**
      * Returns Access Level of a Module
      * @param adaptableModule Module to Check
+     * @returns Access Level of a Module
      */
     getEntitlementAccessLevelForModule(adaptableModule: AdaptableModule): AccessLevel;
     /**
      * Is the Adaptable Object ReadOnly
      * @param object Object to Check
+     * @returns `true` when the Adaptable Object ReadOnly
      */
     isObjectReadonly(object: AdaptableObject): boolean;
     /**
      * Is Module Hidden
      * @param adaptableModule Module to Check
+     * @returns `true` when module Hidden
      */
     isModuleHiddenEntitlement(adaptableModule: AdaptableModule): boolean;
     /**
      * Is Module Full
      * @param adaptableModule Module to Check
+     * @returns `true` when module Full
      */
     isModuleFullEntitlement(adaptableModule: AdaptableModule): boolean;
     /**
      * Is Module ReadOnly
      * @param adaptableModule Module to Check
+     * @returns `true` when module ReadOnly
      */
     isModuleReadOnlyEntitlement(adaptableModule: AdaptableModule): boolean;
 }