@adaptabletools/adaptable-cjs 17.0.0-canary.1

package/src/Api/Implementation/Fdc3ApiImpl.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Fdc3ApiImpl = void 0;
+const ApiBase_1 = require("./ApiBase");
+const Fdc3InternalApi_1 = require("../Internal/Fdc3InternalApi");
+const Fdc3Context_1 = require("../../PredefinedConfig/Common/Fdc3Context");
+const Fdc3Intent_1 = require("../../PredefinedConfig/Common/Fdc3Intent");
+class Fdc3ApiImpl extends ApiBase_1.ApiBase {
+    constructor(adaptable) {
+        super(adaptable);
+        this.internalApi = new Fdc3InternalApi_1.Fdc3InternalApi(adaptable);
+    }
+    getDesktopAgent() {
+        return this.getFdc3Service().getDesktopAgent();
+    }
+    buildContextDataFromRow(contextType, rowNode) {
+        return this.internalApi.mapRowToContextData(contextType, rowNode);
+    }
+    buildContextDataForPrimaryKey(contextType, primaryKeyValue) {
+        const rowNode = this.getGridApi().getRowNodeForPrimaryKey(primaryKeyValue);
+        if (!rowNode) {
+            this.logWarn(`No row found for primary key value '${primaryKeyValue}'`);
+            return undefined;
+        }
+        return this.buildContextDataFromRow(contextType, rowNode);
+    }
+    getPossibleContextTypes(intent) {
+        var _a;
+        const compatibleContexts = (_a = Fdc3Intent_1.Fdc3IntentConfiguration[intent]) === null || _a === void 0 ? void 0 : _a.contexts;
+        return compatibleContexts ? [...compatibleContexts] : [];
+    }
+    isContextCompatibleWithIntent(contextType, intent) {
+        return this.getPossibleContextTypes(intent).includes(contextType);
+    }
+    raiseIntentFromPrimaryKey(primaryKeyValue, intent, contextType, appIdentifier) {
+        const rowNode = this.getGridApi().getRowNodeForPrimaryKey(primaryKeyValue);
+        if (!rowNode) {
+            this.logWarn(`No row found for primary key value '${primaryKeyValue}'`);
+            return undefined;
+        }
+        return this.raiseIntentFromRow(rowNode, intent, contextType, appIdentifier);
+    }
+    raiseIntentFromRow(rowNode, intent, contextType, appIdentifier) {
+        const contextData = this.buildContextDataFromRow(contextType, rowNode);
+        return this.getFdc3Service().raiseIntent(intent, contextData, appIdentifier);
+    }
+    raiseIntentForContextFromRow(rowNode, contextType, appIdentifier) {
+        const contextData = this.buildContextDataFromRow(contextType, rowNode);
+        return this.getFdc3Service().raiseIntentForContext(contextData, appIdentifier);
+    }
+    raiseIntentForContextFromPrimaryKey(primaryKeyValue, contextType, appIdentifier) {
+        const rowNode = this.getGridApi().getRowNodeForPrimaryKey(primaryKeyValue);
+        if (!rowNode) {
+            this.logWarn(`No row found for primary key value '${primaryKeyValue}'`);
+            return undefined;
+        }
+        return this.raiseIntentForContextFromRow(rowNode, contextType, appIdentifier);
+    }
+    broadcastFromRow(rowNode, contextType) {
+        const contextData = this.buildContextDataFromRow(contextType, rowNode);
+        return this.getFdc3Service().broadcast(contextData);
+    }
+    broadcastFromPrimaryKey(primaryKeyValue, contextType) {
+        const rowNode = this.getGridApi().getRowNodeForPrimaryKey(primaryKeyValue);
+        if (!rowNode) {
+            this.logWarn(`No row found for primary key value '${primaryKeyValue}'`);
+            return undefined;
+        }
+        return this.broadcastFromRow(rowNode, contextType);
+    }
+    getContextLabel(contextType) {
+        var _a, _b;
+        return (_b = (_a = Fdc3Context_1.ContextConfiguration[contextType]) === null || _a === void 0 ? void 0 : _a.label) !== null && _b !== void 0 ? _b : contextType;
+    }
+    isStandardContextType(contextType) {
+        return this.internalApi.isStandardContextType(contextType);
+    }
+    isStandardIntentType(intentType) {
+        return this.internalApi.isStandardIntentType(intentType);
+    }
+    getFdc3Service() {
+        return this.adaptable.api.internalApi.getFdc3Service();
+    }
+}
+exports.Fdc3ApiImpl = Fdc3ApiImpl;

package/src/Api/Implementation/FlashingCellApiImpl.d.ts

@@ -0,0 +1,30 @@
+import { ApiBase, LayoutAssociatedObjectLoadConfig } from './ApiBase';
+import { AdaptableFlashingCell } from '../../PredefinedConfig/Common/AdaptableFlashingCell';
+import { FlashingCellApi } from '../FlashingCellApi';
+import { FlashingCellDefinition, FlashingCellState } from '../../PredefinedConfig/FlashingCellState';
+import { AdaptablePredicateDef } from '../../PredefinedConfig/Common/AdaptablePredicate';
+import { AdaptableScope } from '../../PredefinedConfig/Common/AdaptableScope';
+import { FlashingCellInternalApi } from '../Internal/FlashingCellInternalApi';
+import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
+import { AdaptableObjectLookupCriteria } from '../../types';
+export declare class FlashingCellApiImpl extends ApiBase implements FlashingCellApi {
+    internalApi: FlashingCellInternalApi;
+    constructor(adaptable: IAdaptable);
+    getFlashingCellState(): FlashingCellState;
+    getFlashingCellDefinitions(config?: LayoutAssociatedObjectLoadConfig): FlashingCellDefinition[];
+    getFlashingCellDefinitionById(id: FlashingCellDefinition['Uuid']): FlashingCellDefinition;
+    getActiveFlashingCellDefinitions(): FlashingCellDefinition[];
+    getFlashingCellFlashTarget(flashingCellDefinition: FlashingCellDefinition): FlashingCellDefinition['FlashTarget'];
+    showFlashingCell(flashingCellToShow: AdaptableFlashingCell): void;
+    addFlashingCellDefinition(flashingCellDefinition: FlashingCellDefinition): FlashingCellDefinition;
+    setFlashingCellDefinitions(flashingCellDefinitions: FlashingCellDefinition[]): void;
+    editFlashingCellDefinition(flashingCellDefinition: FlashingCellDefinition): FlashingCellDefinition;
+    suspendFlashingCellDefinition(flashingCellDefinition: FlashingCellDefinition): FlashingCellDefinition;
+    unSuspendFlashingCellDefinition(flashingCellDefinition: FlashingCellDefinition): FlashingCellDefinition;
+    addFlashingCellDefinitions(flashingCellDefinitions: FlashingCellDefinition[]): FlashingCellDefinition[];
+    editFlashingCellDefinitions(flashingCellDefinitions: FlashingCellDefinition[]): FlashingCellDefinition[];
+    getFlashingCellPredicateDefsForScope(scope: AdaptableScope): AdaptablePredicateDef[];
+    clearAllFlashingCells(): void;
+    isAnyFlashingCellActive(): boolean;
+    findFlashingCellDefinitions(criteria: AdaptableObjectLookupCriteria): FlashingCellDefinition[];
+}

package/src/Api/Implementation/FlashingCellApiImpl.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlashingCellApiImpl = void 0;
+const tslib_1 = require("tslib");
+const SystemRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/SystemRedux"));
+const FlashingCellRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/FlashingCellRedux"));
+const ApiBase_1 = require("./ApiBase");
+const FlashingCellInternalApi_1 = require("../Internal/FlashingCellInternalApi");
+class FlashingCellApiImpl extends ApiBase_1.ApiBase {
+    constructor(adaptable) {
+        super(adaptable);
+        this.internalApi = new FlashingCellInternalApi_1.FlashingCellInternalApi(adaptable);
+    }
+    getFlashingCellState() {
+        return this.getAdaptableState().FlashingCell;
+    }
+    getFlashingCellDefinitions(config) {
+        var _a;
+        const flashingCellDefinitions = (_a = this.handleLayoutAssociatedObjects(this.getFlashingCellState().FlashingCellDefinitions, 'FlashingCell', config)) !== null && _a !== void 0 ? _a : [];
+        return flashingCellDefinitions.map((flashingCellDefinition) => {
+            return this.internalApi.mergeFlashingCellDefinitionWithDefaults(flashingCellDefinition);
+        });
+    }
+    getFlashingCellDefinitionById(id) {
+        var _a;
+        return (_a = this.getFlashingCellDefinitions()) === null || _a === void 0 ? void 0 : _a.find((fc) => (fc === null || fc === void 0 ? void 0 : fc.Uuid) === id);
+    }
+    getActiveFlashingCellDefinitions() {
+        return this.getFlashingCellDefinitions().filter((fc) => !fc.IsSuspended);
+    }
+    getFlashingCellFlashTarget(flashingCellDefinition) {
+        var _a;
+        return (_a = flashingCellDefinition.FlashTarget) !== null && _a !== void 0 ? _a : 'cell';
+    }
+    showFlashingCell(flashingCellToShow) {
+        this.addUidToAdaptableObject(flashingCellToShow);
+        const flashingCellFiredInfo = {
+            adaptableApi: this.adaptable.api,
+            flashingCell: flashingCellToShow,
+            userName: this.adaptable.api.optionsApi.getUserName(),
+            adaptableId: this.adaptable.api.optionsApi.getAdaptableId(),
+        };
+        const results = this.adaptable.api.eventApi.emitSync('FlashingCellDisplayed', flashingCellFiredInfo);
+        const shouldShow = results.reduce((endResult, aResult) => {
+            return endResult && aResult !== false;
+        }, true);
+        if (shouldShow) {
+            this.dispatchAction(SystemRedux.SystemFlashingCellAdd(flashingCellToShow));
+            const { FlashDuration: FlashDuration } = flashingCellToShow.flashingCellDefinition;
+            if (FlashDuration && FlashDuration !== 'always') {
+                setTimeout(() => {
+                    this.dispatchAction(SystemRedux.SystemFlashingCellDelete(flashingCellToShow));
+                }, FlashDuration);
+            }
+        }
+    }
+    addFlashingCellDefinition(flashingCellDefinition) {
+        this.dispatchAction(FlashingCellRedux.FlashingCellDefinitionAdd(flashingCellDefinition));
+        return this.getFlashingCellDefinitionById(flashingCellDefinition.Uuid);
+    }
+    setFlashingCellDefinitions(flashingCellDefinitions) {
+        this.dispatchAction(FlashingCellRedux.FlashingCellDefinitionSet(flashingCellDefinitions));
+    }
+    editFlashingCellDefinition(flashingCellDefinition) {
+        this.dispatchAction(FlashingCellRedux.FlashingCellDefinitionEdit(flashingCellDefinition));
+        return this.getFlashingCellDefinitionById(flashingCellDefinition.Uuid);
+    }
+    suspendFlashingCellDefinition(flashingCellDefinition) {
+        this.dispatchAction(FlashingCellRedux.FlashingCellDefinitionSuspend(flashingCellDefinition));
+        return this.getFlashingCellDefinitionById(flashingCellDefinition.Uuid);
+    }
+    unSuspendFlashingCellDefinition(flashingCellDefinition) {
+        this.dispatchAction(FlashingCellRedux.FlashingCellDefinitionUnSuspend(flashingCellDefinition));
+        return this.getFlashingCellDefinitionById(flashingCellDefinition.Uuid);
+    }
+    addFlashingCellDefinitions(flashingCellDefinitions) {
+        flashingCellDefinitions.forEach((fad) => {
+            this.addFlashingCellDefinition(fad);
+        });
+        return flashingCellDefinitions === null || flashingCellDefinitions === void 0 ? void 0 : flashingCellDefinitions.map((flashingCell) => this.getFlashingCellDefinitionById(flashingCell === null || flashingCell === void 0 ? void 0 : flashingCell.Uuid));
+    }
+    editFlashingCellDefinitions(flashingCellDefinitions) {
+        flashingCellDefinitions.forEach((fad) => {
+            this.editFlashingCellDefinition(fad);
+        });
+        return flashingCellDefinitions === null || flashingCellDefinitions === void 0 ? void 0 : flashingCellDefinitions.map((flashingCell) => this.getFlashingCellDefinitionById(flashingCell === null || flashingCell === void 0 ? void 0 : flashingCell.Uuid));
+    }
+    getFlashingCellPredicateDefsForScope(scope) {
+        return this.getAdaptableApi()
+            .predicateApi.internalApi.getFlashingCellPredicateDefs(scope)
+            .filter((predicateDef) => this.adaptable.api.scopeApi.isScopeInScope(scope, predicateDef.columnScope));
+    }
+    clearAllFlashingCells() {
+        this.dispatchAction(SystemRedux.SystemFlashingCellDeleteAll());
+    }
+    isAnyFlashingCellActive() {
+        const currentFlashingCells = this.getAdaptableState().System.AdaptableFlashingCells;
+        return currentFlashingCells.keys != null;
+    }
+    findFlashingCellDefinitions(criteria) {
+        return this.getAdaptableApi().internalApi.findAdaptableObjectsByLookupCriteria(criteria, this.getFlashingCellDefinitions({
+            includeLayoutNotAssociatedObjects: true,
+        }));
+    }
+}
+exports.FlashingCellApiImpl = FlashingCellApiImpl;

package/src/Api/Implementation/FormatColumnApiImpl.d.ts

@@ -0,0 +1,46 @@
+import { AdaptableStyle } from '../../PredefinedConfig/Common/AdaptableStyle';
+import { ApiBase } from './ApiBase';
+import { FormatColumnApi } from '../FormatColumnApi';
+import { FormatColumn, FormatColumnState } from '../../PredefinedConfig/FormatColumnState';
+import { AdaptableColumn } from '../../PredefinedConfig/Common/AdaptableColumn';
+import { AdaptableObjectLookupCriteria } from '../../../types';
+import { FormatColumnInternalApi } from '../Internal/FormatColumnInternalApi';
+import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
+export declare class FormatColumnApiImpl extends ApiBase implements FormatColumnApi {
+    internalApi: FormatColumnInternalApi;
+    constructor(adaptable: IAdaptable);
+    getFormatColumnState(): FormatColumnState;
+    getFormatColumns(config?: {
+        includeLayoutNotAssociatedObjects?: boolean;
+    }): FormatColumn[];
+    getFormatColumnById(id: FormatColumn['Uuid']): FormatColumn;
+    getActiveFormatColumns(config?: {
+        includeLayoutNotAssociatedObjects?: boolean;
+    }): FormatColumn[];
+    getSuspendedFormatColumns(config?: {
+        includeLayoutNotAssociatedObjects?: boolean;
+    }): FormatColumn[];
+    addFormatColumn(formatColumn: FormatColumn): FormatColumn;
+    addFormatColumns(formatColumns: FormatColumn[]): FormatColumn[];
+    editFormatColumn(formatColumn: FormatColumn): FormatColumn;
+    addFormatColumnStyle(formatColumn: FormatColumn, style: AdaptableStyle): void;
+    updateFormatColumnStyle(formatColumn: FormatColumn, style: AdaptableStyle): void;
+    deleteFormatColumn(formatColumn: FormatColumn): void;
+    deleteAllFormatColumns(): void;
+    suspendFormatColumn(formatColumn: FormatColumn): FormatColumn;
+    unSuspendFormatColumn(formatColumn: FormatColumn): FormatColumn;
+    getFormatColumnsForColumn(column: AdaptableColumn, config?: {
+        includeSuspended?: boolean;
+    }): FormatColumn[];
+    getFormatColumnsForColumnId(columnId: string, config?: {
+        includeSuspended?: boolean;
+    }): FormatColumn[];
+    openFormatColumnSettingsPanel(): void;
+    getFormatColumnsWithAllScope(formatColumns: FormatColumn[]): FormatColumn[] | undefined;
+    getFormatColumnsWithDataTypeScope(formatColumns: FormatColumn[]): FormatColumn[] | undefined;
+    getFormatColumnsWithColumnScope(formatColumns: FormatColumn[]): FormatColumn[] | undefined;
+    hasCustomDisplayFormatter(formatColumn: FormatColumn): boolean;
+    incrementFormatColumnPrecedence(formatColumn: FormatColumn): void;
+    decrementFormatColumnPrecedence(formatColumn: FormatColumn): void;
+    findFormatColumns(criteria: AdaptableObjectLookupCriteria): FormatColumn[];
+}

package/src/Api/Implementation/FormatColumnApiImpl.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormatColumnApiImpl = void 0;
+const tslib_1 = require("tslib");
+const FormatColumnRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/FormatColumnRedux"));
+const ApiBase_1 = require("./ApiBase");
+const ModuleConstants = tslib_1.__importStar(require("../../Utilities/Constants/ModuleConstants"));
+const FormatColumnInternalApi_1 = require("../Internal/FormatColumnInternalApi");
+class FormatColumnApiImpl extends ApiBase_1.ApiBase {
+    constructor(adaptable) {
+        super(adaptable);
+        this.internalApi = new FormatColumnInternalApi_1.FormatColumnInternalApi(adaptable);
+    }
+    getFormatColumnState() {
+        return this.getAdaptableState().FormatColumn;
+    }
+    getFormatColumns(config) {
+        var _a;
+        return ((_a = this.handleLayoutAssociatedObjects(this.getFormatColumnState().FormatColumns, 'FormatColumn', config)) !== null && _a !== void 0 ? _a : []);
+    }
+    getFormatColumnById(id) {
+        return this.getFormatColumns({ includeLayoutNotAssociatedObjects: true }).find((formatColumn) => formatColumn.Uuid === id);
+    }
+    getActiveFormatColumns(config) {
+        return this.getFormatColumns(config).filter((formatColumn) => !formatColumn.IsSuspended);
+    }
+    getSuspendedFormatColumns(config) {
+        return this.getFormatColumns(config).filter((formatColumn) => formatColumn.IsSuspended);
+    }
+    addFormatColumn(formatColumn) {
+        this.addUidToAdaptableObject(formatColumn);
+        this.dispatchAction(FormatColumnRedux.FormatColumnAdd(formatColumn));
+        return this.getFormatColumnById(formatColumn.Uuid);
+    }
+    addFormatColumns(formatColumns) {
+        formatColumns.forEach((fc) => {
+            this.addFormatColumn(fc);
+        });
+        return formatColumns === null || formatColumns === void 0 ? void 0 : formatColumns.map((formatColumn) => this.getFormatColumnById(formatColumn.Uuid));
+    }
+    editFormatColumn(formatColumn) {
+        this.dispatchAction(FormatColumnRedux.FormatColumnEdit(formatColumn));
+        return this.getFormatColumnById(formatColumn.Uuid);
+    }
+    addFormatColumnStyle(formatColumn, style) {
+        formatColumn.Style = style;
+        this.addFormatColumn(formatColumn);
+    }
+    updateFormatColumnStyle(formatColumn, style) {
+        formatColumn.Style = style;
+        this.dispatchAction(FormatColumnRedux.FormatColumnEdit(formatColumn));
+    }
+    deleteFormatColumn(formatColumn) {
+        this.dispatchAction(FormatColumnRedux.FormatColumnDelete(formatColumn));
+    }
+    deleteAllFormatColumns() {
+        this.dispatchAction(FormatColumnRedux.FormatColumnDeleteAll());
+    }
+    suspendFormatColumn(formatColumn) {
+        this.dispatchAction(FormatColumnRedux.FormatColumnSuspend(formatColumn));
+        return this.getFormatColumnById(formatColumn.Uuid);
+    }
+    unSuspendFormatColumn(formatColumn) {
+        this.dispatchAction(FormatColumnRedux.FormatColumnUnSuspend(formatColumn));
+        return this.getFormatColumnById(formatColumn.Uuid);
+    }
+    getFormatColumnsForColumn(column, config) {
+        const formatColumns = this.getFormatColumns().filter((formatColumn) => (config === null || config === void 0 ? void 0 : config.includeSuspended) || !formatColumn.IsSuspended);
+        return this.internalApi.getFormatColumnWithColumnInScope(formatColumns, column);
+    }
+    getFormatColumnsForColumnId(columnId, config) {
+        const abColumn = this.adaptable.api.columnApi.getColumnWithColumnId(columnId);
+        if (!abColumn) {
+            return [];
+        }
+        return this.getFormatColumnsForColumn(abColumn, config);
+    }
+    openFormatColumnSettingsPanel() {
+        this.showModulePopup(ModuleConstants.FormatColumnModuleId);
+    }
+    getFormatColumnsWithAllScope(formatColumns) {
+        return formatColumns.filter((fc) => this.adaptable.api.scopeApi.scopeIsAll(fc.Scope));
+    }
+    getFormatColumnsWithDataTypeScope(formatColumns) {
+        return formatColumns.filter((fc) => this.adaptable.api.scopeApi.scopeHasDataType(fc.Scope));
+    }
+    getFormatColumnsWithColumnScope(formatColumns) {
+        return formatColumns.filter((fc) => this.adaptable.api.scopeApi.scopeHasColumns(fc.Scope));
+    }
+    hasCustomDisplayFormatter(formatColumn) {
+        var _a;
+        if (!formatColumn || !formatColumn.DisplayFormat || !formatColumn.DisplayFormat.Options) {
+            return false;
+        }
+        const options = formatColumn.DisplayFormat.Options;
+        const columnCustomFormatters = (_a = options === null || options === void 0 ? void 0 : options.CustomDisplayFormats) !== null && _a !== void 0 ? _a : [];
+        if (!(columnCustomFormatters === null || columnCustomFormatters === void 0 ? void 0 : columnCustomFormatters.length)) {
+            return false;
+        }
+        return true;
+    }
+    incrementFormatColumnPrecedence(formatColumn) {
+        this.dispatchAction(FormatColumnRedux.FormatColumnMoveUp(formatColumn));
+    }
+    decrementFormatColumnPrecedence(formatColumn) {
+        this.dispatchAction(FormatColumnRedux.FormatColumnMoveDown(formatColumn));
+    }
+    findFormatColumns(criteria) {
+        return this.getAdaptableApi().internalApi.findAdaptableObjectsByLookupCriteria(criteria, this.getFormatColumns({
+            includeLayoutNotAssociatedObjects: true,
+        }));
+    }
+}
+exports.FormatColumnApiImpl = FormatColumnApiImpl;

package/src/Api/Implementation/FreeTextColumnApiImpl.d.ts

@@ -0,0 +1,21 @@
+import { ApiBase } from './ApiBase';
+import { FreeTextColumnApi } from '../FreeTextColumnApi';
+import { FreeTextColumn, FreeTextColumnState, FreeTextStoredValue } from '../../PredefinedConfig/FreeTextColumnState';
+import { IRowNode } from '@ag-grid-community/core';
+import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
+import { FreeTextColumnInternalApi } from '../Internal/FreeTextColumnInternalApi';
+export declare class FreeTextColumnApiImpl extends ApiBase implements FreeTextColumnApi {
+    internalApi: FreeTextColumnInternalApi;
+    constructor(adaptable: IAdaptable);
+    getFreeTextColumnState(): FreeTextColumnState;
+    getFreeTextColumns(): FreeTextColumn[];
+    getFreeTextColumnById(technicalId: FreeTextColumn['Uuid']): FreeTextColumn | undefined;
+    getFreeTextColumnForColumnId(columnId: string): FreeTextColumn | undefined;
+    addFreeTextColumn(freeTextColumn: FreeTextColumn): FreeTextColumn;
+    editFreeTextColumn(freeTextColumn: FreeTextColumn): FreeTextColumn;
+    setStoredValue(columnId: string, storedValue: FreeTextStoredValue): FreeTextColumn;
+    setStoredValues(columnId: string, storedValues: FreeTextStoredValue[], replaceAction: 'All' | 'Conflicting' | 'None'): void;
+    deleteFreeTextColumn(columnId: string): void;
+    openFreeTextColumnSettingsPanel(): void;
+    getFreeTextColumnValueForRowNode(freeTextColumn: FreeTextColumn, rowNode: IRowNode): any;
+}

package/src/Api/Implementation/FreeTextColumnApiImpl.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FreeTextColumnApiImpl = void 0;
+const tslib_1 = require("tslib");
+const FreeTextColumnRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/FreeTextColumnRedux"));
+const ApiBase_1 = require("./ApiBase");
+const ModuleConstants = tslib_1.__importStar(require("../../Utilities/Constants/ModuleConstants"));
+const ArrayExtensions_1 = tslib_1.__importDefault(require("../../Utilities/Extensions/ArrayExtensions"));
+const FreeTextColumnInternalApi_1 = require("../Internal/FreeTextColumnInternalApi");
+class FreeTextColumnApiImpl extends ApiBase_1.ApiBase {
+    constructor(adaptable) {
+        super(adaptable);
+        this.internalApi = new FreeTextColumnInternalApi_1.FreeTextColumnInternalApi(adaptable);
+    }
+    getFreeTextColumnState() {
+        return this.getAdaptableState().FreeTextColumn;
+    }
+    getFreeTextColumns() {
+        var _a;
+        return (_a = this.getFreeTextColumnState().FreeTextColumns) !== null && _a !== void 0 ? _a : [];
+    }
+    getFreeTextColumnById(technicalId) {
+        return this.getFreeTextColumns().find((ftc) => ftc.Uuid === technicalId);
+    }
+    getFreeTextColumnForColumnId(columnId) {
+        return this.getFreeTextColumns().find((ftc) => ftc.ColumnId === columnId);
+    }
+    addFreeTextColumn(freeTextColumn) {
+        this.addUidToAdaptableObject(freeTextColumn);
+        this.dispatchAction(FreeTextColumnRedux.FreeTextColumnAdd(freeTextColumn));
+        return this.getFreeTextColumnById(freeTextColumn === null || freeTextColumn === void 0 ? void 0 : freeTextColumn.Uuid);
+    }
+    editFreeTextColumn(freeTextColumn) {
+        this.dispatchAction(FreeTextColumnRedux.FreeTextColumnEdit(freeTextColumn));
+        return this.getFreeTextColumnById(freeTextColumn === null || freeTextColumn === void 0 ? void 0 : freeTextColumn.Uuid);
+    }
+    setStoredValue(columnId, storedValue) {
+        const freeTextColumn = this.getFreeTextColumnForColumnId(columnId);
+        if (!freeTextColumn) {
+            this.logWarn(`No FreeTextColumn with columnId=${columnId} was found!`);
+            return;
+        }
+        this.dispatchAction(FreeTextColumnRedux.FreeTextColumnAddEditStoredValue(freeTextColumn, storedValue));
+        return this.getFreeTextColumnById(freeTextColumn === null || freeTextColumn === void 0 ? void 0 : freeTextColumn.Uuid);
+    }
+    setStoredValues(columnId, storedValues, replaceAction) {
+        const freeTextColumn = this.getFreeTextColumnForColumnId(columnId);
+        if (freeTextColumn) {
+            if (replaceAction == 'All') {
+                freeTextColumn.FreeTextStoredValues = storedValues;
+            }
+            else {
+                const existingPKValues = ArrayExtensions_1.default.IsNotNullOrEmpty(freeTextColumn.FreeTextStoredValues)
+                    ? freeTextColumn.FreeTextStoredValues.map((fts) => {
+                        return fts.PrimaryKey;
+                    })
+                    : [];
+                storedValues.forEach((sv) => {
+                    // do summat
+                    const isExistingPKValue = existingPKValues.find((epk) => epk == sv.PrimaryKey);
+                    if (isExistingPKValue) {
+                        if (replaceAction == 'Conflicting') {
+                            let existingItem = freeTextColumn.FreeTextStoredValues.find((fsv) => fsv.PrimaryKey == sv.PrimaryKey);
+                            if (existingItem) {
+                                existingItem.FreeText = sv.FreeText;
+                            }
+                        }
+                        else {
+                            freeTextColumn.FreeTextStoredValues.push(sv);
+                        }
+                    }
+                    else {
+                        // no existing value so just add it
+                        freeTextColumn.FreeTextStoredValues.push(sv);
+                    }
+                });
+            }
+            this.dispatchAction(FreeTextColumnRedux.FreeTextColumnEdit(freeTextColumn));
+        }
+    }
+    deleteFreeTextColumn(columnId) {
+        let freeTextColumn = this.getFreeTextColumns().find((ftc) => ftc.ColumnId == columnId);
+        if (this.checkItemExists(freeTextColumn, columnId, ModuleConstants.FreeTextColumnModuleId)) {
+            this.dispatchAction(FreeTextColumnRedux.FreeTextColumnDelete(freeTextColumn));
+        }
+    }
+    openFreeTextColumnSettingsPanel() {
+        this.showModulePopup(ModuleConstants.FreeTextColumnModuleId);
+    }
+    getFreeTextColumnValueForRowNode(freeTextColumn, rowNode) {
+        try {
+            if (this.adaptable.api.gridApi.isGroupRowNode(rowNode)) {
+                return null;
+            }
+            if (ArrayExtensions_1.default.IsNotNullOrEmpty(freeTextColumn.FreeTextStoredValues)) {
+                let pkValue = this.adaptable.getPrimaryKeyValueFromRowNode(rowNode);
+                let freeTextStoredValue = freeTextColumn.FreeTextStoredValues.find((fdx) => fdx.PrimaryKey == pkValue);
+                if (freeTextStoredValue) {
+                    return freeTextStoredValue.FreeText;
+                }
+            }
+            return freeTextColumn.DefaultValue;
+        }
+        catch (e) {
+            this.logError(e);
+            return null;
+        }
+    }
+}
+exports.FreeTextColumnApiImpl = FreeTextColumnApiImpl;

package/src/Api/Implementation/GridApiImpl.d.ts

@@ -0,0 +1,134 @@
+import { ApiBase } from './ApiBase';
+import { GridApi } from '../GridApi';
+import { GridState } from '../../PredefinedConfig/GridState';
+import { SelectedCellInfo } from '../../PredefinedConfig/Selection/SelectedCellInfo';
+import { SelectedRowInfo } from '../../PredefinedConfig/Selection/SelectedRowInfo';
+import { CellUpdateRequest, GridCell } from '../../PredefinedConfig/Selection/GridCell';
+import { ColumnSort } from '../../PredefinedConfig/Common/ColumnSort';
+import { DataUpdateConfig } from '../../PredefinedConfig/Common/DataUpdateConfig';
+import { CellHighlightInfo } from '../../PredefinedConfig/Common/CellHighlightInfo';
+import { RowHighlightInfo } from '../../PredefinedConfig/Common/RowHighlightInfo';
+import { GridOptions, IRowNode, RowModelType } from '@ag-grid-community/core';
+import { GridCellRange } from '../../PredefinedConfig/Selection/GridCellRange';
+import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
+import { RowsHighlightInfo } from '../../PredefinedConfig/Common/RowsHighlightInfo';
+import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
+import { GridInternalApi } from '../Internal/GridInternalApi';
+export declare class GridApiImpl extends ApiBase implements GridApi {
+    internalApi: GridInternalApi;
+    constructor(adaptable: IAdaptable);
+    getGridState(): GridState;
+    resetGridData(dataSource: any[]): void;
+    setInitialGridData(data: any): void;
+    getGridData(): any[];
+    getFilteredData(): any[];
+    updateGridData(dataRows: any[], dataUpdateConfig?: DataUpdateConfig): Promise<IRowNode[]>;
+    addOrUpdateGridData(dataRows: any[], dataUpdateConfig?: DataUpdateConfig): Promise<{
+        addedRows: IRowNode[];
+        updatedRows: IRowNode[];
+    }>;
+    addGridData(dataRows: any[], dataUpdateConfig?: DataUpdateConfig): Promise<IRowNode[]>;
+    undoCellEdit(cellDataChangedInfo: CellDataChangedInfo): boolean;
+    deleteGridData(dataRows: any[], dataUpdateConfig?: DataUpdateConfig): Promise<IRowNode[]>;
+    setCellValue(cellUpdateRequest: CellUpdateRequest): void;
+    setCellValues(cellUpdateRequests: CellUpdateRequest[]): void;
+    getSelectedCellInfo(): SelectedCellInfo;
+    getSelectedRowInfo(): SelectedRowInfo;
+    getCellDisplayValue(primaryKeyValue: any, columnId: string): any | undefined;
+    getCellRawValue(primaryKeyValue: any, columnId: string): any | undefined;
+    getCellNormalisedValue(primaryKeyValue: any, columnId: string): any | undefined;
+    hideFilterForm(): void;
+    applyGridFiltering(): void;
+    clearGridFiltering(): void;
+    getAgGridInstance(): GridOptions;
+    getColumnSorts(): ColumnSort[];
+    getColumnSortForColumn(columnId: string): ColumnSort | undefined;
+    setAdaptableSorting(columnSorts: ColumnSort[]): void;
+    clearAdaptableSorting(): void;
+    setColumnSorts(columnSorts: ColumnSort[]): void;
+    private clearColumnSorts;
+    selectRow(primaryKeyValue: any, clearSelection: boolean): void;
+    selectRows(primaryKeyValues: any[], clearSelection: boolean): void;
+    selectNode(rowNode: IRowNode, clearSelection: boolean): void;
+    selectNodes(rowNodes: IRowNode[], clearSelection: boolean): void;
+    deSelectRow(primaryKeyValue: any, clearSelection: boolean): void;
+    deSelectRows(primaryKeyValues: any[], clearSelection: boolean): void;
+    deSelectNode(rowNode: IRowNode, clearSelection: boolean): void;
+    deSelectNodes(rowNodes: IRowNode[], clearSelection: boolean): void;
+    private getSelectionStartEndNodes;
+    selectCellRange(gridCellRange: GridCellRange, clearSelection?: boolean): void;
+    selectCellRangeByQuery(query: string, gridCellRange?: GridCellRange, clearSelection?: boolean): void;
+    selectColumn(columnId: string): void;
+    selectColumns(columnIds: string[]): void;
+    getFirstRowNode(): IRowNode;
+    getFirstDisplayedRowNode(): IRowNode;
+    getVisibleRowNodes(config?: {
+        includeGroupRows?: boolean;
+        filterFn?: (rowNode: IRowNode) => boolean;
+    }): IRowNode[];
+    getAllRowNodes(config?: {
+        includeGroupRows?: boolean;
+        filterFn?: (rowNode: IRowNode) => boolean;
+    }): IRowNode[];
+    getGroupRowNodes(config?: {
+        filterFn?: (rowNode: IRowNode) => boolean;
+    }): IRowNode[];
+    getGridCellFromRowNode(rowNode: IRowNode, columnId: string): GridCell | undefined;
+    getRawValueFromRowNode(rowNode: IRowNode, columnId: string): any | undefined;
+    getDisplayValueFromRowNode(rowNode: IRowNode, columnId: string): any | undefined;
+    getDisplayValueFromRawValue(rowNode: IRowNode, columnId: string, rawValue: any): string | undefined;
+    getNormalisedValueFromRowNode(rowNode: IRowNode, columnId: string): any | undefined;
+    getRowNodesForPrimaryKeys(primaryKeyValues: any[]): IRowNode[];
+    getRowNodeForPrimaryKey(primaryKeyValue: any): IRowNode;
+    getPrimaryKeyValueForRowNode(rowNode: IRowNode): any;
+    getRowNodeForIndex(index: number): IRowNode<any>;
+    getPrimaryKeyValuesForRowNodes(rowNodes: IRowNode[]): any[];
+    setRowGroupColumns(columnIds: string[]): void;
+    clearRowGroupColumns(): void;
+    expandAllRowGroups(): void;
+    collapseAllRowGroups(): void;
+    getExpandRowGroupsKeys(): any[];
+    expandRowGroupsForValues(columnValues: any[]): void;
+    isGridPivotable(): boolean;
+    isGridGroupable(): boolean;
+    isGridSelectable(): boolean;
+    isGridRowGrouped(): boolean;
+    isGroupRowNode(rowNode: IRowNode): boolean;
+    isQuickFilterAvailable(): boolean;
+    redrawGrid(): void;
+    getGridCellsForRawValue(columnId: string, rawValue: any): GridCell[] | undefined;
+    getCellRawValueCount(columnId: string, rawValue: any): number;
+    getGridCellsForDisplayValue(columnId: string, displayValue: any): GridCell[] | undefined;
+    getCellDisplayValueCount(columnId: string, displayValue: any): number;
+    jumpToRow(primaryKeyValue: any): void;
+    jumpToColumn(columnId: string): void;
+    jumpToCell(primaryKeyValue: any, columnId: string): void;
+    highlightCell(cellHighlightInfo: CellHighlightInfo): void;
+    unHighlightCell(primaryKeyValue: CellHighlightInfo['primaryKeyValue'], columnId: CellHighlightInfo['columnId']): void;
+    unHighlightAllCells(): void;
+    highlightRow(rowHighlightInfo: RowHighlightInfo): void;
+    highlightRows(rowHighlightInfos: RowsHighlightInfo): void;
+    unHighlightRow(primaryKeyValue: RowHighlightInfo['primaryKeyValue']): void;
+    unHighlightRows(primaryKeyValues: RowsHighlightInfo['primaryKeyValues']): void;
+    unHighlightAllRows(): void;
+    refreshCells(rowNodes: IRowNode[], columnIds: string[]): void;
+    refreshColumn(columnId: string): void;
+    refreshColumns(columnIds: string[]): void;
+    refreshRowByPrimaryKey(primaryKey: any): void;
+    refreshRowNode(rowNode: IRowNode): void;
+    refreshRowNodes(rowNodes: IRowNode[]): void;
+    refreshGroupRowNodes(): void;
+    isCellEditable(gridCell: GridCell): boolean;
+    isEveryCellEditable(gridCells: GridCell[]): boolean;
+    getRowCount(): number;
+    getVisibleRowCount(): number;
+    getRowsInViewport(): IRowNode[];
+    getColumnCount(): number;
+    getVisibleColumnCount(): number;
+    selectAll(): void;
+    deselectAll(): void;
+    destroy(): void;
+    getGridContainerElement(): HTMLElement | null;
+    openGridInfoSettingsPanel(): void;
+    getAgGridRowModelType(): RowModelType;
+}