@adaptabletools/adaptable 14.0.0-canary.0 → 14.0.0-canary.2

package/src/Api/{Implementation/InternalApiImpl.d.ts → Internal/AdaptableInternalApi.d.ts}

@@ -1,92 +1,62 @@
-import { ApiBase } from './ApiBase';
-import { InternalApi } from '../InternalApi';
+import { ApiBase } from '../Implementation/ApiBase';
 import { UIConfirmation } from '../../Utilities/Interface/MessagePopups';
 import { SystemState } from '../../PredefinedConfig/SystemState';
 import { Action } from 'redux';
 import { ModuleParams } from '../../View/Components/SharedProps/ModuleViewPopupProps';
 import { AdaptableColumn } from '../../PredefinedConfig/Common/AdaptableColumn';
 import { AdaptableMenuItem } from '../../PredefinedConfig/Common/Menu';
-import { SelectedCellInfo } from '../../PredefinedConfig/Selection/SelectedCellInfo';
-import { SelectedRowInfo } from '../../PredefinedConfig/Selection/SelectedRowInfo';
-import { AdaptableModule, AdaptableQLModule } from '../../PredefinedConfig/Common/Types';
-import { GridCell } from '../../PredefinedConfig/Selection/GridCell';
+import { AdaptableModule } from '../../PredefinedConfig/Common/Types';
 import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
-import { AdaptableCellChangedAlert, AdaptableOptions, AdaptableRowChangedAlert, AdaptableState, AlertFormContext, BaseContext, Layout, LayoutAssociatedObject, SystemStatusMessageInfo, SharedEntity, AdaptableIcon, AdaptableQuery } from '../../types';
+import { AdaptableIcon, AdaptableObjectLookupCriteria, AdaptableOptions, AdaptableQuery, AdaptableState, BaseContext } from '../../types';
 import { IValidationService } from '../../Utilities/Services/Interface/IValidationService';
 import { IModuleService } from '../../Utilities/Services/Interface/IModuleService';
 import { IReportService } from '../../Utilities/Services/Interface/IReportService';
 import { ICalculatedColumnExpressionService } from '../../Utilities/Services/Interface/ICalculatedColumnExpressionService';
-import { AdaptableAlert } from '../../PredefinedConfig/Common/AdaptableAlert';
 import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { IDataService } from '../../Utilities/Services/Interface/IDataService';
 import { IEntitlementService } from '../../Utilities/Services/Interface/IEntitlementService';
 import { IQueryLanguageService } from '../../Utilities/Services/Interface/IQueryLanguageService';
 import { IAlertService } from '../../Utilities/Services/Interface/IAlertService';
-import { AdaptableFlashingCell } from '../../PredefinedConfig/Common/AdaptableFlashingCell';
 import { RowNode } from '@ag-grid-community/core';
 import { ITeamSharingService } from '../../Utilities/Services/Interface/ITeamSharingService';
-import { ColumnValuesComparer } from '../../AdaptableOptions/GeneralOptions';
 import { ButtonStyle } from '../../PredefinedConfig/Common/ButtonStyle';
 import { AdaptableButton } from '../../PredefinedConfig/Common/AdaptableButton';
-import { AdaptableForm } from '../../PredefinedConfig/Common/AdaptableForm';
-import { AlertButtonForm, AlertDefinition } from '../../PredefinedConfig/AlertState';
-import { AdaptableMessageType } from '../../PredefinedConfig/Common/AdaptableMessageType';
 import { AdaptableFrameworkComponent } from '../../AdaptableOptions/AdaptableFrameworkComponent';
 import { IMetamodelService } from '../../Utilities/Services/Interface/IMetamodelService';
 import { IModuleCollection } from '../../Strategy/Interface/IModule';
-import { AdaptableObjectTag } from '../../PredefinedConfig/Common/AdaptableObject';
-import { EditLookUpPermittedValues } from '../../../types';
+import { AdaptableObjectTag, AdaptableObjectWithScope } from '../../PredefinedConfig/Common/AdaptableObject';
 import { IRowEditService } from '../../Utilities/Services/Interface/IRowEditService';
-export declare class InternalApiImpl extends ApiBase implements InternalApi {
+export declare class AdaptableInternalApi extends ApiBase {
     getSystemState(): SystemState;
-    getAdaptableFormFromAlertForm(alertForm: string | AlertButtonForm, context: any, defaultMessageType?: AdaptableMessageType): (Omit<AdaptableForm<AlertFormContext>, 'buttons'> & {
-        buttons?: (Omit<AdaptableButton<AlertFormContext>, 'buttonStyle'> & {
-            buttonStyle?: ButtonStyle;
-        })[];
-    }) | undefined;
-    getAdaptableAlerts(): AdaptableAlert[];
-    getAdaptableCellChangedAlerts(): AdaptableCellChangedAlert[];
-    getAdaptableRowChangedAlerts(): AdaptableRowChangedAlert[];
-    getAdaptableAlertWithHighlightCell(columnId: string, rowNode: RowNode): AdaptableAlert | undefined;
-    getAdaptableAlertWithHighlightRow(rowNode: RowNode): AdaptableAlert | undefined;
-    isAlertDefinitionForAddedRowChangeEvent(alertDefinition: AlertDefinition): boolean;
-    isAlertDefinitionForRemovedRowChangeEvent(alertDefinition: AlertDefinition): boolean;
-    getAdaptableFlashingCellFor(primaryKey: string, columnId?: string): AdaptableFlashingCell | null;
-    addSystemStatusMessageInfo(systemStatusMessageInfo: SystemStatusMessageInfo): void;
-    getSystemStatusMessageInfos(): SystemStatusMessageInfo[];
     showPopupConfirmation(confirmation: UIConfirmation): void;
     showLoadingScreen(): void;
     hideLoadingScreen(): void;
     showPopupScreen(module: AdaptableModule, componentName: string, popupParams?: ModuleParams, popupProps?: {
         [key: string]: any;
     }): void;
+    showPopupWindow(id: string, title: string, icon: string, popupProps: any): void;
     hidePopupScreen(): void;
-    setColumns(columns: AdaptableColumn[]): void;
     setSettingPanelModuleMenuItems(menuItems: AdaptableMenuItem[]): void;
     setModuleButtonMenuItems(menuItems: AdaptableMenuItem[]): void;
-    setSelectedCells(selectedCellInfo: SelectedCellInfo): void;
-    setSelectedRows(selectedRowInfo: SelectedRowInfo): void;
     setPivotModeOn(): void;
     setPivotModeOff(): void;
     isGridInPivotMode(): boolean;
     setTreeModeOn(): void;
     setTreeModeOff(): void;
     isGridInTreeMode(): boolean;
-    addAdaptableColumn(AdaptableColumn: AdaptableColumn): void;
-    addAdaptableColumns(AdaptableColumns: AdaptableColumn[]): void;
-    removeAdaptableColumn(colId: string): void;
-    setGridCells(gridCells: GridCell[]): void;
-    setToolbarTitle(): string;
-    setGridCell(gridCell: GridCell): void;
+    getToolbarTitle(): string;
     buildDataChangedInfo(config: Pick<CellDataChangedInfo, 'newValue' | 'oldValue' | 'column' | 'primaryKeyValue' | 'rowNode' | 'trigger'>): CellDataChangedInfo;
-    private createDataChangedInfoFromGridCell;
-    setLastAppliedShortCut(gridCell: GridCell | undefined): void;
-    updateCurrentDraftLayout(layout: Layout): void;
+    /**
+     * @deprecated use `OptionsApi.getPrimaryKey()`
+     */
     getPrimaryKey(): any;
     getAdaptableInstance(): IAdaptable;
     getAgGridInstance(): any;
     getPredefinedConfig(): any;
     getState(): AdaptableState;
+    /**
+     * @deprecated use OptionsApi.getAdaptableOptions()
+     */
     getAdaptableOptions(): AdaptableOptions;
     getValidationService(): IValidationService;
     getModuleService(): IModuleService;
@@ -101,16 +71,8 @@ export declare class InternalApiImpl extends ApiBase implements InternalApi {
     getRowEditService(): IRowEditService;
     getModules(): IModuleCollection;
     getModuleFriendlyName(adaptableModule: AdaptableModule): string;
-    runModuleInAdaptableQL(adaptableQLModule: AdaptableQLModule): boolean;
-    evaluateExpressionInAdaptableQL(module: AdaptableQLModule, expression?: string): boolean;
     forAllRowNodesDo(func: (rowNode: RowNode) => void): void;
     forAllVisibleRowNodesDo(func: (rowNode: RowNode) => void): void;
-    buildStandaloneColumnHeader(column: AdaptableColumn): AdaptableMenuItem[];
-    clearFlashingCellState(): void;
-    clearUpdatedRowState(): void;
-    clearGradientColumnState(): void;
-    clearPercentBarState(): void;
-    getCustomSortComparer(column: AdaptableColumn): ColumnValuesComparer | undefined;
     getLabelForButton(button: AdaptableButton<BaseContext>, context: BaseContext): string | undefined;
     getTooltipForButton(button: AdaptableButton<BaseContext>, context: BaseContext): string | undefined;
     getStyleForButton(button: AdaptableButton<BaseContext>, context: BaseContext): ButtonStyle | undefined;
@@ -120,8 +82,6 @@ export declare class InternalApiImpl extends ApiBase implements InternalApi {
     }): AdaptableIcon | undefined;
     isDocumentationLinksDisplayed(): boolean;
     getQueryPreviewData(): any;
-    getLocalTeamSharingEntities(): SharedEntity[];
-    waitForTeamSharingImportEnd(): Promise<boolean>;
     createFrameworkComponent(containerDomNode: HTMLElement, frameworkComponent: AdaptableFrameworkComponent, componentType: 'toolPanel' | 'toolbar'): void;
     destroyFrameworkComponent(containerDomNode: HTMLElement, frameworkComponent: AdaptableFrameworkComponent, componentType: 'toolPanel' | 'toolbar'): void;
     initializeDataChangeHistory(): void;
@@ -129,9 +89,6 @@ export declare class InternalApiImpl extends ApiBase implements InternalApi {
     executeWithProgressIndicator(label: string, executeFn: () => void): void;
     hideProgressIndicator(): void;
     getCorrectEnglishVariant(wordToSpell: string): string;
-    hasLayoutSpecificObjects(): boolean;
-    isObjectAvailableInLayout(object: LayoutAssociatedObject, module: AdaptableModule, layout: Layout): boolean;
-    showLayoutNotAssociatedObjects(): boolean;
     shouldDisplayTagSections(): boolean;
     getAvailableTags(): AdaptableObjectTag[] | undefined;
     private getObjectTags;
@@ -140,6 +97,13 @@ export declare class InternalApiImpl extends ApiBase implements InternalApi {
     showSettingsPanel(module: AdaptableModule, moduleParams?: ModuleParams): void;
     getLabelForTag(adaptableObjectTag: AdaptableObjectTag): string;
     getValueForTag(adaptableObjectTag: AdaptableObjectTag): string | number;
-    getEditLookUpValuesForColumn(editLookUpItem: EditLookUpPermittedValues, column: AdaptableColumn, gridCell?: GridCell): any[] | undefined;
     getAdaptableQueryExpressionText(query: Partial<AdaptableQuery>): string;
+    deleteConditionalStyles(conditionalStyles: any[]): void;
+    persistPreviousGroupedColumnsIndex(layoutId: string, columnId: string, columnIndex: number): void;
+    getPreviousGroupedColumnsIndex(layoutId: string): {
+        [key: string]: number;
+    };
+    getValueUsingField(rowData: Record<string, any>, column: AdaptableColumn): any;
+    setValueUsingField(rowData: Record<string, any>, column: AdaptableColumn, newValue: any): Record<string, any>;
+    findAdaptableObjectsByLookupCriteria<T extends AdaptableObjectWithScope>({ scope, tag, ids }: AdaptableObjectLookupCriteria, specificAdaptableObjects: T[]): T[];
 }

package/src/Api/Internal/AdaptableInternalApi.js

@@ -0,0 +1,461 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdaptableInternalApi = void 0;
+const tslib_1 = require("tslib");
+const PopupRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/PopupRedux"));
+const SystemRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/SystemRedux"));
+const SystemRedux_1 = require("../../Redux/ActionsReducers/SystemRedux");
+const GridRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/GridRedux"));
+const DeadRedux = tslib_1.__importStar(require("../../Redux/DeadRedux"));
+const ApiBase_1 = require("../Implementation/ApiBase");
+const StringExtensions_1 = tslib_1.__importDefault(require("../../Utilities/Extensions/StringExtensions"));
+const GeneralConstants_1 = require("../../Utilities/Constants/GeneralConstants");
+const LoggingHelper_1 = require("../../Utilities/Helpers/LoggingHelper");
+const waitForCondition_1 = require("../../Utilities/waitForCondition");
+const AdaptableIconComponent_1 = require("../../components/AdaptableIconComponent");
+class AdaptableInternalApi extends ApiBase_1.ApiBase {
+    getSystemState() {
+        return this.getAdaptableState().System;
+    }
+    // Popup Redux Actions
+    showPopupConfirmation(confirmation) {
+        this.dispatchAction(PopupRedux.PopupShowConfirmation(confirmation));
+    }
+    showLoadingScreen() {
+        this.dispatchAction(PopupRedux.PopupShowLoading());
+    }
+    hideLoadingScreen() {
+        this.dispatchAction(PopupRedux.PopupHideLoading());
+    }
+    showPopupScreen(module, componentName, popupParams, popupProps) {
+        this.dispatchAction(PopupRedux.PopupShowScreen(module, componentName, popupParams, popupProps));
+    }
+    showPopupWindow(id, title, icon, popupProps) {
+        this.dispatchAction(PopupRedux.PopupShowWindow({
+            Id: id,
+            Title: title,
+            Icon: icon,
+            PopupProps: popupProps,
+        }));
+    }
+    hidePopupScreen() {
+        this.dispatchAction(PopupRedux.PopupHideScreen());
+    }
+    setSettingPanelModuleMenuItems(menuItems) {
+        this.dispatchAction(GridRedux.SetSettingPanelModuleMenuItems(menuItems));
+    }
+    setModuleButtonMenuItems(menuItems) {
+        this.dispatchAction(GridRedux.SetModuleButtonMenuItems(menuItems));
+    }
+    setPivotModeOn() {
+        this.dispatchAction(GridRedux.SetPivotModeOn());
+    }
+    setPivotModeOff() {
+        this.dispatchAction(GridRedux.SetPivotModeOff());
+    }
+    isGridInPivotMode() {
+        return this.getAdaptableState().Grid.IsGridInPivotMode;
+    }
+    setTreeModeOn() {
+        this.dispatchAction(GridRedux.SetTreeModeOn());
+    }
+    setTreeModeOff() {
+        this.dispatchAction(GridRedux.SetTreeModeOff());
+    }
+    isGridInTreeMode() {
+        return this.getAdaptableState().Grid.IsGridInTreeMode;
+    }
+    getToolbarTitle() {
+        let toolbarTitle = this.adaptable.api.dashboardApi.getDashboardState().DashboardTitle;
+        if (StringExtensions_1.default.IsNullOrEmpty(toolbarTitle)) {
+            toolbarTitle = this.adaptable.adaptableOptions.adaptableId;
+            if (toolbarTitle == GeneralConstants_1.ADAPTABLE_ID) {
+                toolbarTitle = 'Adaptable ';
+            }
+        }
+        return toolbarTitle;
+    }
+    buildDataChangedInfo(config) {
+        var _a;
+        return Object.assign(Object.assign({}, config), { rowData: (_a = config.rowNode) === null || _a === void 0 ? void 0 : _a.data, changedAt: Date.now() });
+    }
+    /**
+     * @deprecated use `OptionsApi.getPrimaryKey()`
+     */
+    getPrimaryKey() {
+        return this.adaptable.adaptableOptions.primaryKey;
+    }
+    getAdaptableInstance() {
+        return this.adaptable;
+    }
+    getAgGridInstance() {
+        return this.adaptable.adaptableOptions.gridOptions;
+    }
+    getPredefinedConfig() {
+        return this.adaptable.adaptableOptions.predefinedConfig;
+    }
+    getState() {
+        return this.getAdaptableState();
+    }
+    /**
+     * @deprecated use OptionsApi.getAdaptableOptions()
+     */
+    getAdaptableOptions() {
+        return this.getOptions();
+    }
+    getValidationService() {
+        return this.adaptable.ValidationService;
+    }
+    getModuleService() {
+        return this.adaptable.ModuleService;
+    }
+    getDataService() {
+        return this.adaptable.DataService;
+    }
+    getReportService() {
+        return this.adaptable.ReportService;
+    }
+    getCalculatedColumnExpressionService() {
+        return this.adaptable.CalculatedColumnExpressionService;
+    }
+    getEntitlementService() {
+        return this.adaptable.EntitlementService;
+    }
+    getQueryLanguageService() {
+        return this.adaptable.QueryLanguageService;
+    }
+    getAlertService() {
+        return this.adaptable.AlertService;
+    }
+    getTeamSharingService() {
+        return this.adaptable.TeamSharingService;
+    }
+    getMetamodelService() {
+        return this.adaptable.MetamodelService;
+    }
+    getRowEditService() {
+        return this.adaptable.RowEditService;
+    }
+    getModules() {
+        return this.adaptable.adaptableModules;
+    }
+    getModuleFriendlyName(adaptableModule) {
+        var _a, _b;
+        return ((_b = (_a = this.adaptable.ModuleService.getModuleInfoByModule(adaptableModule)) === null || _a === void 0 ? void 0 : _a.FriendlyName) !== null && _b !== void 0 ? _b : adaptableModule);
+    }
+    forAllRowNodesDo(func) {
+        this.adaptable.forAllRowNodesDo(func);
+    }
+    forAllVisibleRowNodesDo(func) {
+        this.adaptable.forAllVisibleRowNodesDo(func);
+    }
+    getLabelForButton(button, context) {
+        if (!button.label) {
+            return '';
+        }
+        if (button.label != null && typeof button.label === 'function') {
+            return button.label(button, context);
+        }
+        else {
+            return button.label;
+        }
+    }
+    getTooltipForButton(button, context) {
+        if (!button.tooltip) {
+            return '';
+        }
+        if (button.tooltip != null && typeof button.tooltip === 'function') {
+            return button.tooltip(button, context);
+        }
+        else {
+            return button.tooltip;
+        }
+    }
+    getStyleForButton(button, context) {
+        if (!button.buttonStyle) {
+            return undefined;
+        }
+        if (button.buttonStyle != null && typeof button.buttonStyle === 'function') {
+            return button.buttonStyle(button, context);
+        }
+        else {
+            return button.buttonStyle;
+        }
+    }
+    getIconForButton(button, context, defaultWidthHeight) {
+        var _a, _b;
+        if (!button.icon) {
+            return;
+        }
+        let buttonIcon;
+        if (button.icon != null && typeof button.icon === 'function') {
+            buttonIcon = button.icon(button, context);
+        }
+        else {
+            buttonIcon = button.icon;
+        }
+        if (!buttonIcon) {
+            return;
+        }
+        if ((0, AdaptableIconComponent_1.isAdaptableInternalIcon)(buttonIcon) || (0, AdaptableIconComponent_1.isAdaptableExternalIcon)(buttonIcon)) {
+            const defaultIconWidth = (_a = defaultWidthHeight === null || defaultWidthHeight === void 0 ? void 0 : defaultWidthHeight.width) !== null && _a !== void 0 ? _a : 'var(--ab-cmp-simple-button__width)';
+            const defaultIconHeight = (_b = defaultWidthHeight === null || defaultWidthHeight === void 0 ? void 0 : defaultWidthHeight.height) !== null && _b !== void 0 ? _b : 'var(--ab-cmp-simple-button__height)';
+            const buttonIconStyle = Object.assign({}, { width: defaultIconWidth, height: defaultIconHeight }, buttonIcon.style);
+            buttonIcon.style = buttonIconStyle;
+        }
+        return buttonIcon;
+    }
+    isDocumentationLinksDisplayed() {
+        return this.adaptable.adaptableOptions.userInterfaceOptions.showDocumentationLinks;
+    }
+    // the row data which is used to preview the expression evaluation (usually the first row data)
+    getQueryPreviewData() {
+        var _a;
+        const firstRowNode = this.adaptable.api.gridApi.getFirstRowNode();
+        if (firstRowNode == undefined) {
+            return {};
+        }
+        const firstRowData = (_a = Object.assign({}, firstRowNode === null || firstRowNode === void 0 ? void 0 : firstRowNode.data)) !== null && _a !== void 0 ? _a : {};
+        // handle CalcCols which are not persisted in the rowModel
+        this.adaptable.api.calculatedColumnApi.getCalculatedColumns().forEach((calculatedColumn) => {
+            const columnRawValue = this.adaptable.api.gridApi.getRawValueFromRowNode(firstRowNode, calculatedColumn.ColumnId);
+            firstRowData[calculatedColumn.ColumnId] = columnRawValue;
+        });
+        // handle FreeTextCols which are not persisted in the rowModel
+        this.adaptable.api.freeTextColumnApi.getFreeTextColumns().forEach((freeTextColumn) => {
+            const columnRawValue = this.adaptable.api.gridApi.getRawValueFromRowNode(firstRowNode, freeTextColumn.ColumnId);
+            firstRowData[freeTextColumn.ColumnId] = columnRawValue;
+        });
+        return firstRowData;
+    }
+    createFrameworkComponent(containerDomNode, frameworkComponent, componentType) {
+        const createComponentFn = () => 
+        // delegate the logic to framework wrapper
+        this.adaptable._emit('FrameworkComponentChange', {
+            command: 'create',
+            containerDomNode,
+            frameworkComponent,
+            componentType,
+        });
+        if (this.adaptable.isInitialised) {
+            createComponentFn();
+        }
+        else {
+            // adaptable may not be initialized yet if the framework component is part of the initial render
+            // AFL 2021.10.14 - not really sure if this is necessary anymore?! (see the other changes in this commit)
+            (0, waitForCondition_1.waitForCondition)(() => this.adaptable.isInitialised).then(() => {
+                createComponentFn();
+            });
+        }
+    }
+    destroyFrameworkComponent(containerDomNode, frameworkComponent, componentType) {
+        this.adaptable._emit('FrameworkComponentChange', {
+            command: 'destroy',
+            containerDomNode,
+            frameworkComponent,
+            componentType,
+        });
+    }
+    initializeDataChangeHistory() {
+        if (this.adaptable.adaptableOptions.dataChangeHistoryOptions.activeByDefault) {
+            this.dispatchAction(SystemRedux.SystemDataChangeHistoryEnable());
+        }
+        else {
+            this.dispatchAction(SystemRedux.SystemDataChangeHistoryDisable());
+        }
+    }
+    isTextComparisonCaseSensitive() {
+        return this.adaptable.adaptableOptions.adaptableQLOptions.caseSensitiveTextComparisons;
+    }
+    executeWithProgressIndicator(label, executeFn) {
+        this.dispatchReduxAction((0, SystemRedux_1.SystemProgressIndicatorShow)(label));
+        // setTimeout required to give the ProgressIndicator rendering a head-start (see RAF in ProgressIndicator implementation)
+        setTimeout(() => {
+            try {
+                executeFn();
+            }
+            catch (error) {
+                this.hideProgressIndicator();
+                (0, LoggingHelper_1.LogAdaptableError)('Unexpected error while executing a function with a progress indicator', error);
+            }
+        }, 16);
+    }
+    hideProgressIndicator() {
+        this.dispatchReduxAction((0, SystemRedux_1.SystemProgressIndicatorHide)());
+    }
+    getCorrectEnglishVariant(wordToSpell) {
+        if (wordToSpell.includes('our')) {
+            return this.getGeneralOptions().englishVariant == 'GB'
+                ? wordToSpell
+                : wordToSpell.replace('our', 'or');
+        }
+        return wordToSpell;
+    }
+    shouldDisplayTagSections() {
+        return this.getAvailableTags() != undefined;
+    }
+    getAvailableTags() {
+        const layoutTags = this.getLayoutTags();
+        const objectTags = this.getObjectTags();
+        if (!layoutTags && !objectTags) {
+            return;
+        }
+        return [...(layoutTags || []), ...(objectTags || [])];
+    }
+    getObjectTags() {
+        if (!this.adaptable.adaptableOptions.userInterfaceOptions.objectTags) {
+            return;
+        }
+        if (Array.isArray(this.adaptable.adaptableOptions.userInterfaceOptions.objectTags)) {
+            return this.adaptable.adaptableOptions.userInterfaceOptions.objectTags;
+        }
+        if (typeof this.adaptable.adaptableOptions.userInterfaceOptions.objectTags === 'function') {
+            // sanitize the provided tags, just to be sure that the user does NOT break the UI
+            return this.adaptable.adaptableOptions.userInterfaceOptions
+                .objectTags({
+                adaptableApi: this.adaptable.api,
+            })
+                .filter((tag) => typeof tag === 'string');
+        }
+    }
+    getLayoutTags() {
+        var _a;
+        if (!((_a = this.adaptable.adaptableOptions.layoutOptions.layoutTagOptions) === null || _a === void 0 ? void 0 : _a.autoGenerateTagsForLayouts)) {
+            return;
+        }
+        if (this.adaptable.adaptableOptions.layoutOptions.layoutTagOptions.autoGenerateTagsForLayouts ===
+            true) {
+            return this.adaptable.api.layoutApi.getLayouts().map((layout) => {
+                return layout.Name;
+            });
+        }
+        if (typeof this.adaptable.adaptableOptions.layoutOptions.layoutTagOptions
+            .autoGenerateTagsForLayouts === 'function') {
+            const autoGenerateTagsForLayoutsContext = {
+                layouts: this.adaptable.api.layoutApi.getLayouts(),
+                objectTags: this.getAdaptableApi().userInterfaceApi.getAdaptableObjectTags(),
+                adaptableApi: this.adaptable.api,
+            };
+            const customGeneratedTags = this.adaptable.adaptableOptions.layoutOptions.layoutTagOptions.autoGenerateTagsForLayouts(autoGenerateTagsForLayoutsContext);
+            // sanitize the provided tags, just to be sure that the user does NOT break the UI
+            return customGeneratedTags.filter((tag) => typeof tag === 'string');
+        }
+    }
+    // General way to get to store from inside Adaptable...
+    dispatchReduxAction(action) {
+        this.dispatchAction(action);
+    }
+    // doing it this way to avoid having to expose Module Params which is internal
+    showSettingsPanel(module, moduleParams) {
+        this.showModulePopup(module, moduleParams);
+    }
+    getLabelForTag(adaptableObjectTag) {
+        // not very interesting right now, but useful later when tag is not only a plain string
+        return adaptableObjectTag;
+    }
+    getValueForTag(adaptableObjectTag) {
+        // not very interesting right now, but useful later when tag is not only a plain string
+        return adaptableObjectTag;
+    }
+    getAdaptableQueryExpressionText(query) {
+        var _a;
+        if (!query) {
+            return '';
+        }
+        const displayColumnFriendlyNames = (_a = this.adaptable.adaptableOptions.adaptableQLOptions) === null || _a === void 0 ? void 0 : _a.displayColumnFriendlyNamesForExpressions;
+        return displayColumnFriendlyNames
+            ? this.adaptable.api.queryLanguageApi.getAdaptableQueryExpressionWithColumnFriendlyNames(query)
+            : this.adaptable.api.queryLanguageApi.getAdaptableQueryExpression(query);
+    }
+    deleteConditionalStyles(conditionalStyles) {
+        conditionalStyles.forEach((cs) => {
+            this.dispatchAction(DeadRedux.ConditionalStyleDelete(cs));
+        });
+    }
+    persistPreviousGroupedColumnsIndex(layoutId, columnId, columnIndex) {
+        this.dispatchAction(SystemRedux.SystemSetPreviousGroupedColumnsIndex(layoutId, columnId, columnIndex));
+    }
+    getPreviousGroupedColumnsIndex(layoutId) {
+        var _a;
+        return (_a = SystemRedux.SystemPreviousGroupedColumnsSelector(this.getAdaptableState().System)) === null || _a === void 0 ? void 0 : _a[layoutId];
+    }
+    // "borrowed" from https://github.com/ag-grid/ag-grid/blob/v28.2.1/community-modules/core/src/ts/utils/object.ts#L205
+    getValueUsingField(rowData, column) {
+        var _a;
+        if (!rowData || !column) {
+            return;
+        }
+        const columnValueKey = (_a = column.field) !== null && _a !== void 0 ? _a : column.columnId;
+        const isColumnValueKeyContainsDots = columnValueKey === null || columnValueKey === void 0 ? void 0 : columnValueKey.includes('.');
+        // if no '.', then it's not a deep value
+        if (!isColumnValueKeyContainsDots) {
+            return rowData[columnValueKey];
+        }
+        // otherwise it is a deep value, so need to dig for it
+        const fields = columnValueKey.split('.');
+        let currentObject = rowData;
+        for (let i = 0; i < fields.length; i++) {
+            if (currentObject == null) {
+                return undefined;
+            }
+            currentObject = currentObject[fields[i]];
+        }
+        return currentObject;
+    }
+    // "borrowed" from https://github.com/ag-grid/ag-grid/blob/v28.2.1/community-modules/core/src/ts/valueService/valueService.ts#L236
+    setValueUsingField(rowData, column, newValue) {
+        var _a;
+        if (!rowData || !column) {
+            return;
+        }
+        const columnValueKey = (_a = column.field) !== null && _a !== void 0 ? _a : column.columnId;
+        const isColumnValueKeyContainsDots = columnValueKey === null || columnValueKey === void 0 ? void 0 : columnValueKey.includes('.');
+        let valuesAreSame = false;
+        if (!isColumnValueKeyContainsDots) {
+            // soft comparison to match strings and numbers
+            valuesAreSame = rowData[columnValueKey] == newValue;
+            if (!valuesAreSame) {
+                rowData[columnValueKey] = newValue;
+            }
+        }
+        else {
+            // otherwise it is a deep value, so need to dig for it
+            const fieldPieces = columnValueKey.split('.');
+            let currentObject = rowData;
+            while (fieldPieces.length > 0 && currentObject) {
+                const fieldPiece = fieldPieces.shift();
+                if (fieldPieces.length === 0) {
+                    // soft comparison to match strings and numbers
+                    valuesAreSame = currentObject[fieldPiece] == newValue;
+                    if (!valuesAreSame) {
+                        currentObject[fieldPiece] = newValue;
+                    }
+                }
+                else {
+                    currentObject = currentObject[fieldPiece];
+                }
+            }
+        }
+        return rowData;
+    }
+    findAdaptableObjectsByLookupCriteria({ scope, tag, ids }, specificAdaptableObjects) {
+        if (!(ids === null || ids === void 0 ? void 0 : ids.length) && !tag && !scope) {
+            return [];
+        }
+        let locatedAdaptableObjects = [...specificAdaptableObjects];
+        // IDs are the most specific locators
+        if (ids === null || ids === void 0 ? void 0 : ids.length) {
+            locatedAdaptableObjects = locatedAdaptableObjects.filter((adaptableObject) => ids.includes(adaptableObject.Uuid));
+        }
+        // secondly filter by Tags
+        if (tag) {
+            locatedAdaptableObjects = locatedAdaptableObjects.filter((adaptableObject) => { var _a; return (_a = adaptableObject.Tags) === null || _a === void 0 ? void 0 : _a.includes(tag); });
+        }
+        // lastly filter by scope
+        if (scope) {
+            locatedAdaptableObjects = locatedAdaptableObjects.filter((adaptableObject) => this.getAdaptableApi().scopeApi.isScopeInScope(adaptableObject.Scope, scope));
+        }
+        return locatedAdaptableObjects;
+    }
+}
+exports.AdaptableInternalApi = AdaptableInternalApi;