@adaptabletools/adaptable 10.0.0-canary.0

package/src/Utilities/Services/Interface/IEntitlementService.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/Utilities/Services/Interface/IExpressionService.d.ts

@@ -0,0 +1,26 @@
+import { Observable } from 'rxjs';
+import { IAdaptableService } from './IAdaptableService';
+import { RowNode } from '@ag-grid-community/all-modules';
+import { DataChangedInfo } from '../../../PredefinedConfig/Common/DataChangedInfo';
+export interface IExpressionService extends IAdaptableService {
+    evaluateBooleanExpression(expression: string, rowNode: RowNode): any;
+    evaluateObservableExpression(expression: string): Observable<DataChangedInfo>;
+    evaluateAggregationExpression(expression: string): Observable<DataChangedInfo>;
+    evaluateScalarExpression(expression: string, rowNode: RowNode): any;
+    validateBoolean(expression: string, config?: {
+        force?: boolean;
+    }): {
+        isValid: boolean;
+        errorMessage: string;
+    };
+    validateObservable(expression: string): {
+        isValid: boolean;
+        errorMessage: string;
+    };
+    validateAggregation(expression: string): {
+        isValid: boolean;
+        errorMessage: string;
+    };
+    getColumnsFromExpression(input: string): string[];
+    getNamedQueryNamesFromExpression(input: string): string[];
+}

package/src/Utilities/Services/Interface/IExpressionService.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/Utilities/Services/Interface/ILicenseService.d.ts

@@ -0,0 +1,2 @@
+export interface ILicenseService {
+}

package/src/Utilities/Services/Interface/ILicenseService.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/Utilities/Services/Interface/IMetamodelService.d.ts

@@ -0,0 +1,14 @@
+import { IAdaptableService } from './IAdaptableService';
+export declare type GridInfoOptions = Map<string, {
+    containerLabel: string;
+    items: GridInfoOption[];
+}>;
+export interface GridInfoOption {
+    name: string;
+    value: any;
+    description: string;
+    defaultValue?: any;
+}
+export interface IMetamodelService extends IAdaptableService {
+    getGridInfoOptions(): GridInfoOptions;
+}

package/src/Utilities/Services/Interface/IMetamodelService.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/Utilities/Services/Interface/IModuleService.d.ts

@@ -0,0 +1,16 @@
+import { IModule, ModuleInfo, IModuleCollection } from '../../../Strategy/Interface/IModule';
+import { TeamSharingImportInfo } from '../../../PredefinedConfig/TeamSharingState';
+import { AdaptableObject } from '../../../PredefinedConfig/Common/AdaptableObject';
+import { IAdaptableService } from './IAdaptableService';
+import { AdaptableModule } from '../../../PredefinedConfig/Common/Types';
+export interface IModuleService extends IAdaptableService {
+    isModuleAvailable(adaptableModule: AdaptableModule): boolean;
+    isModuleEditable(adaptableModule: AdaptableModule): boolean;
+    createModuleMenus(): void;
+    getTeamSharingAction(adaptableModule: AdaptableModule): TeamSharingImportInfo<AdaptableObject> | undefined;
+    getModuleById(adaptableModule: AdaptableModule): IModule | undefined;
+    getModuleInfoByModule(adaptableModule: AdaptableModule): ModuleInfo | undefined;
+    getModuleInfoByFriendlyName(friendlyName: string): ModuleInfo | undefined;
+    getModuleDocumentationPageByModule(adaptableModule: AdaptableModule): string;
+    getModuleCollection(): IModuleCollection;
+}

package/src/Utilities/Services/Interface/IModuleService.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/Utilities/Services/Interface/IReportService.d.ts

@@ -0,0 +1,22 @@
+import { Report, ReportData, SystemReportName } from '../../../PredefinedConfig/ExportState';
+import { AdaptableColumn } from '../../../PredefinedConfig/Common/AdaptableColumn';
+import { IAdaptableService } from './IAdaptableService';
+import { RowNode } from '@ag-grid-community/all-modules';
+import { SystemExportDestination } from '../../../types';
+export interface IReportService extends IAdaptableService {
+    CreateSystemReport(systemReportName: SystemReportName): Report;
+    IsSystemReport(reportName: string): boolean;
+    IsSystemReportActive(reportName: SystemReportName): boolean;
+    IsSystemExportDestinationActive(exportDestination: SystemExportDestination): boolean;
+    GetReportColumnScopeShortDescription(report: Report): string;
+    GetReportColumnScopeLongDescription(report: Report): string;
+    GetReportExpressionDescription(Report: Report, cols: AdaptableColumn[]): string;
+    GetReportColumnsForReport(report: Report): AdaptableColumn[];
+    PublishLiveLiveDataChangedEvent(reportDestination: 'OpenFin' | 'ipushpull' | 'Glue42', liveDataChangedTrigger: 'Connected' | 'Disconnected' | 'SnapshotSent' | 'LiveDataStarted' | 'LiveDataStopped' | 'LiveDataUpdated', liveReport?: any): void;
+    getReportData(report: Report, includePrimaryKey?: boolean): ReportData;
+    getReportDataAsArray(report: Report, includePrimaryKey?: boolean): any[][];
+    convertReportDataToArray(reportData: ReportData): any[][];
+    getCellExportValueFromRowNode(rowNode: RowNode, columnId: string): any;
+    getCellExportValueFromRawValue(rawValue: any, columnId: string): any;
+    getReportFileName(reportName: string): string;
+}

package/src/Utilities/Services/Interface/IReportService.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/Utilities/Services/Interface/ITeamSharingService.d.ts

@@ -0,0 +1,14 @@
+import { IAdaptableService } from './IAdaptableService';
+import { AdaptableObject } from '../../../PredefinedConfig/Common/AdaptableObject';
+import { AdaptableModule } from '../../../PredefinedConfig/Common/Types';
+import { SharedEntity, SharedEntityConfig, SharedEntityActiveStatus, TeamSharingImportStep } from '../../../PredefinedConfig/TeamSharingState';
+import { TypeUuid } from '../../../PredefinedConfig/Uuid';
+export interface ITeamSharingService extends IAdaptableService {
+    buildSharedEntityWithDependencies(adaptableObject: AdaptableObject, module: AdaptableModule, configuration: SharedEntityConfig): SharedEntity[];
+    getSharedEntityDependants(sharedEntityId: TypeUuid, sharedEntities: SharedEntity[]): SharedEntity[];
+    updateActiveSharedEntity(changedAdaptableObject: AdaptableObject, userName: string, sharedEntities: SharedEntity[]): [SharedEntity[], SharedEntity[]];
+    buildSharedEntityImportActions(sharedEntity: SharedEntity): [TeamSharingImportStep[], boolean];
+    getSharedEntityLocalAndRemoteRevisions(changedAdaptableObjectId: TypeUuid, remoteSharedEntities: SharedEntity[]): any;
+    getStaleActiveSharedEntities(): SharedEntityActiveStatus;
+    showUpdateNotifications(): void;
+}

package/src/Utilities/Services/Interface/ITeamSharingService.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/Utilities/Services/Interface/IValidationService.d.ts

@@ -0,0 +1,12 @@
+import { DataChangedInfo } from '../../../PredefinedConfig/Common/DataChangedInfo';
+import { AlertDefinition } from '../../../PredefinedConfig/AlertState';
+import { IAdaptableService } from './IAdaptableService';
+export interface IValidationService extends IAdaptableService {
+    getValidationRulesForDataChange(dataChangedInfo: DataChangedInfo): AlertDefinition[];
+    performValidation(dataChangedInfo: DataChangedInfo): boolean;
+    performServerValidation(dataChangedInfo: DataChangedInfo, config: {
+        onServerValidationCompleted: () => void;
+    }): () => boolean;
+    createValidationDescription(alertDefinition: AlertDefinition): string;
+    createValidationMessage(alertDefinition: AlertDefinition): string;
+}

package/src/Utilities/Services/Interface/IValidationService.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/Utilities/Services/LicenseService.d.ts

@@ -0,0 +1,27 @@
+import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
+import { LicenseDetails } from '../license/LicenseDetails';
+import { IAdaptableService } from './Interface/IAdaptableService';
+export declare enum LicenseValidityType {
+    INVALID_LICENSE = "INVALID_LICENSE",
+    NO_LICENSE = "NO_LICENSE",
+    NON_PRODUCTION_VALID = "NON_PRODUCTION_VALID",
+    NON_PRODUCTION_EXPIRED_IN_SCOPE = "NON_PRODUCTION_EXPIRED_IN_SCOPE",
+    NON_PRODUCTION_EXPIRED_OUT_OF_SCOPE = "NON_PRODUCTION_EXPIRED_OUT_OF_SCOPE",
+    COMMERCIAL_VALID = "COMMERCIAL_VALID",
+    COMMERCIAL_EXPIRED_IN_SCOPE = "COMMERCIAL_EXPIRED_IN_SCOPE",
+    COMMERCIAL_EXPIRED_OUT_OF_SCOPE = "COMMERCIAL_EXPIRED_OUT_OF_SCOPE"
+}
+export declare class LicenseService implements IAdaptableService {
+    private adaptable;
+    constructor(adaptable: IAdaptable, licenseKey: string | undefined, packageDetails: {
+        publishedAt: number | Date;
+    });
+    getValidityType(details: LicenseDetails | Error | null, packageDetails: {
+        publishedAt: number | Date;
+    }): LicenseValidityType;
+    handleLicenseValidation(details: LicenseDetails | null | Error, validityType: LicenseValidityType): void;
+    private showNotification;
+    private showWatermark;
+    private disableStatePersistence;
+    destroy(): void;
+}

package/src/Utilities/Services/LicenseService.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LicenseService = exports.LicenseValidityType = void 0;
+const tslib_1 = require("tslib");
+const SystemRedux_1 = require("../../Redux/ActionsReducers/SystemRedux");
+const PopupRedux_1 = require("../../Redux/ActionsReducers/PopupRedux");
+const ObjectFactory_1 = tslib_1.__importDefault(require("../ObjectFactory"));
+const LoggingHelper_1 = require("../Helpers/LoggingHelper");
+const clamp_1 = tslib_1.__importDefault(require("lodash-es/clamp"));
+const DocumentationLinkConstants_1 = require("../Constants/DocumentationLinkConstants");
+const decode_1 = require("../license/decode");
+const EMAIL = 'sales@adaptabletools.com';
+const COMMERCIAL_LICENSE_SHOW_INFO_DAYS_BEFORE_EXPIRE = 10;
+const DAY_IN_MS = 1000 * 60 * 60 * 24;
+var LicenseValidityType;
+(function (LicenseValidityType) {
+    LicenseValidityType["INVALID_LICENSE"] = "INVALID_LICENSE";
+    LicenseValidityType["NO_LICENSE"] = "NO_LICENSE";
+    LicenseValidityType["NON_PRODUCTION_VALID"] = "NON_PRODUCTION_VALID";
+    LicenseValidityType["NON_PRODUCTION_EXPIRED_IN_SCOPE"] = "NON_PRODUCTION_EXPIRED_IN_SCOPE";
+    LicenseValidityType["NON_PRODUCTION_EXPIRED_OUT_OF_SCOPE"] = "NON_PRODUCTION_EXPIRED_OUT_OF_SCOPE";
+    LicenseValidityType["COMMERCIAL_VALID"] = "COMMERCIAL_VALID";
+    LicenseValidityType["COMMERCIAL_EXPIRED_IN_SCOPE"] = "COMMERCIAL_EXPIRED_IN_SCOPE";
+    LicenseValidityType["COMMERCIAL_EXPIRED_OUT_OF_SCOPE"] = "COMMERCIAL_EXPIRED_OUT_OF_SCOPE";
+})(LicenseValidityType = exports.LicenseValidityType || (exports.LicenseValidityType = {}));
+class LicenseService {
+    constructor(adaptable, licenseKey, packageDetails) {
+        this.adaptable = adaptable;
+        this.adaptable = adaptable;
+        let details = null;
+        if (licenseKey)
+            try {
+                details = decode_1.decode(licenseKey);
+            }
+            catch (error) {
+                details = error;
+            }
+        this.handleLicenseValidation(details, this.getValidityType(details, packageDetails));
+    }
+    getValidityType(details, packageDetails) {
+        if (!details) {
+            return LicenseValidityType.NO_LICENSE;
+        }
+        if (details instanceof Error) {
+            return LicenseValidityType.INVALID_LICENSE;
+        }
+        const currentVersionReleaseDate = new Date(packageDetails.publishedAt);
+        const licenseEndDate = new Date(details.end);
+        const currentDate = new Date();
+        const isExpired = licenseEndDate < currentDate;
+        const isTrial = details.trial;
+        const isScope = licenseEndDate > currentVersionReleaseDate;
+        let validityType = null;
+        if (isExpired) {
+            if (isScope) {
+                if (isTrial) {
+                    validityType = LicenseValidityType.NON_PRODUCTION_EXPIRED_IN_SCOPE;
+                }
+                else {
+                    validityType = LicenseValidityType.COMMERCIAL_EXPIRED_IN_SCOPE;
+                }
+            }
+            else {
+                if (isTrial) {
+                    validityType = LicenseValidityType.NON_PRODUCTION_EXPIRED_OUT_OF_SCOPE;
+                }
+                else {
+                    validityType = LicenseValidityType.COMMERCIAL_EXPIRED_OUT_OF_SCOPE;
+                }
+            }
+        }
+        else {
+            if (isTrial) {
+                validityType = LicenseValidityType.NON_PRODUCTION_VALID;
+            }
+            else {
+                validityType = LicenseValidityType.COMMERCIAL_VALID;
+            }
+        }
+        return validityType;
+    }
+    handleLicenseValidation(details, validityType) {
+        var _a;
+        const nowAtMidnight = new Date();
+        nowAtMidnight.setHours(0, 0, 0, 0);
+        let daysLeft = 0;
+        if (!(details instanceof Error) && (details === null || details === void 0 ? void 0 : details.end)) {
+            daysLeft = Math.floor((((_a = details === null || details === void 0 ? void 0 : details.end) === null || _a === void 0 ? void 0 : _a.getTime()) - nowAtMidnight.getTime()) / DAY_IN_MS);
+            daysLeft = clamp_1.default(daysLeft, 0, Infinity);
+        }
+        const annotateMessage = (message, link = DocumentationLinkConstants_1.LicenseDocsLink, email = EMAIL, days = daysLeft) => {
+            return message.replace('[LINK]', link).replace('[EMAIL]', email).replace('[DAYS]', `${days}`);
+        };
+        switch (validityType) {
+            case 'NO_LICENSE':
+            case 'NON_PRODUCTION_EXPIRED_OUT_OF_SCOPE':
+                LoggingHelper_1.ConsoleLogByMessageType(annotateMessage('This instance of AdapTable does not have a license, and some functionality has therefore been removed. In order to use a fully-featured version of AdapTable, please contact [EMAIL]. You can learn more about the different AdapTable license options at [LINK].'), 'Error');
+                this.showNotification('No AdapTable License found.');
+                this.showWatermark('This instance of AdapTable does not have a license, and some functionality has therefore been removed.');
+                this.disableStatePersistence();
+                break;
+            case 'INVALID_LICENSE':
+                LoggingHelper_1.ConsoleLogByMessageType(annotateMessage('This instance of AdapTable seems to use a corrupted License, and some functionality has therefore been removed. In order to use a fully-featured version of AdapTable, please contact [EMAIL]. You can learn more about the different AdapTable license options at [LINK].'), 'Error');
+                this.showNotification('Corrupted AdapTable License found.');
+                this.showWatermark('This instance of AdapTable has a corrupted License, and some functionality has therefore been removed.');
+                this.disableStatePersistence();
+                break;
+            case 'NON_PRODUCTION_VALID':
+                LoggingHelper_1.ConsoleLogByMessageType(annotateMessage('This AdapTable trial license expires in [DAYS] days. Please contact [EMAIL] to upgrade to a commercial version of AdapTable. You can learn more about the different AdapTable license options at [LINK].'), 'Info');
+                break;
+            case 'NON_PRODUCTION_EXPIRED_IN_SCOPE':
+                LoggingHelper_1.ConsoleLogByMessageType(annotateMessage('This AdapTable trial license has now expired. Please contact [EMAIL] to upgrade to a commercial version of AdapTable. You can learn more about the different AdapTable license options at [LINK].'), 'Warning');
+                this.showWatermark('AdapTable License has expired');
+                break;
+            case 'COMMERCIAL_VALID':
+                if (daysLeft <= COMMERCIAL_LICENSE_SHOW_INFO_DAYS_BEFORE_EXPIRE) {
+                    LoggingHelper_1.ConsoleLogByMessageType(annotateMessage(`This AdapTable license expires in [DAYS] days.  Please contact [EMAIL] to renew (giving you access to Support and Updates)`), 'Info');
+                }
+                break;
+            case 'COMMERCIAL_EXPIRED_IN_SCOPE':
+                LoggingHelper_1.ConsoleLogByMessageType(annotateMessage('This AdapTable license has expired.  Please contact [EMAIL] if you wish to renew (giving you access to Support and Updates)'), 'Warning');
+                break;
+            case 'COMMERCIAL_EXPIRED_OUT_OF_SCOPE':
+                LoggingHelper_1.ConsoleLogByMessageType(annotateMessage('This AdapTable license has expired. Adaptable version was published after the license expired. Please contact [EMAIL] if you wish to renew your license.'), 'Error');
+                this.showNotification('Adaptable License has expired');
+                this.showWatermark('Adaptable License has expired');
+                break;
+        }
+    }
+    showNotification(text) {
+        this.adaptable.api.internalApi.dispatchReduxAction(PopupRedux_1.PopupShowAlert({
+            header: 'License Error',
+            message: text,
+            alertDefinition: ObjectFactory_1.default.CreateInternalAlertDefinitionForMessages('Error'),
+        }));
+    }
+    showWatermark(text) {
+        this.adaptable.api.internalApi.dispatchReduxAction(SystemRedux_1.SystemLicenseShowWatermark(text));
+    }
+    disableStatePersistence() {
+        this.adaptable.api.internalApi.dispatchReduxAction(SystemRedux_1.SystemLicenseDisablePersistence());
+    }
+    destroy() { }
+}
+exports.LicenseService = LicenseService;

package/src/Utilities/Services/MetamodelService.d.ts

@@ -0,0 +1,11 @@
+import { GridInfoOptions, IMetamodelService } from './Interface/IMetamodelService';
+import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
+export declare class MetamodelService implements IMetamodelService {
+    private adaptable;
+    private gridInfoOptions;
+    constructor(adaptable: IAdaptable);
+    getGridInfoOptions(): GridInfoOptions;
+    private buildGridInfoOptions;
+    private mapGridInfoContainerItems;
+    destroy(): void;
+}

package/src/Utilities/Services/MetamodelService.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetamodelService = void 0;
+const adaptable_metamodel_1 = require("../../metamodel/adaptable.metamodel");
+const DefaultAdaptableOptions_1 = require("../Defaults/DefaultAdaptableOptions");
+class MetamodelService {
+    constructor(adaptable) {
+        this.adaptable = adaptable;
+        this.gridInfoOptions = new Map();
+        this.adaptable = adaptable;
+        this.gridInfoOptions = this.buildGridInfoOptions();
+    }
+    getGridInfoOptions() {
+        return this.gridInfoOptions;
+    }
+    buildGridInfoOptions() {
+        const gridInfoOptions = new Map();
+        const adaptableMetamodel = adaptable_metamodel_1.ADAPTABLE_METAMODEL;
+        const adaptableOptionsMetamodel = adaptableMetamodel['AdaptableOptions'];
+        const adaptableOptionsValues = this.adaptable.adaptableOptions;
+        const adaptableOptionsDefaultValues = DefaultAdaptableOptions_1.DefaultAdaptableOptions;
+        if (!adaptableOptionsMetamodel) {
+            // should never happen
+            return gridInfoOptions;
+        }
+        // root-level properties are grouped in a syntethic 'Base Options' container
+        const baseOptionsItems = this.mapGridInfoContainerItems(adaptableOptionsMetamodel, adaptableOptionsValues, adaptableOptionsDefaultValues);
+        gridInfoOptions.set('baseOptions', {
+            containerLabel: 'Base Options',
+            items: baseOptionsItems,
+        });
+        // map containers
+        adaptableOptionsMetamodel.properties
+            .filter((optionItem) => optionItem.gridInfo === 'container')
+            .forEach((containerOptionItem) => {
+            const containerMetamodelName = containerOptionItem.reference;
+            const adaptableOptionsName = containerOptionItem.name;
+            const containerOptionsMetamodel = adaptableMetamodel[containerMetamodelName];
+            // @ts-ignore
+            const containerOptionsValues = adaptableOptionsValues[adaptableOptionsName];
+            // @ts-ignore
+            const containerOptionsDefaultValues = adaptableOptionsDefaultValues[adaptableOptionsName];
+            if (!containerOptionsMetamodel ||
+                !containerOptionsValues ||
+                !containerOptionsDefaultValues) {
+                // should never happen
+                return;
+            }
+            const optionItems = this.mapGridInfoContainerItems(containerOptionsMetamodel, containerOptionsValues, containerOptionsDefaultValues);
+            gridInfoOptions.set(containerOptionItem.name, {
+                containerLabel: containerOptionItem.uiLabel,
+                items: optionItems,
+            });
+        });
+        return gridInfoOptions;
+    }
+    mapGridInfoContainerItems(optionItemContainer, adaptableOptionsValues, defaultAdaptableOptionsValues) {
+        var _a;
+        return (_a = optionItemContainer.properties) === null || _a === void 0 ? void 0 : _a.filter((itemProperty) => itemProperty.gridInfo === 'item').map((itemProperty) => {
+            return {
+                name: itemProperty.name,
+                value: adaptableOptionsValues[itemProperty.name],
+                defaultValue: defaultAdaptableOptionsValues[itemProperty.name],
+                description: itemProperty.description,
+            };
+        });
+    }
+    destroy() { }
+}
+exports.MetamodelService = MetamodelService;

package/src/Utilities/Services/ModuleService.d.ts

@@ -0,0 +1,20 @@
+import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
+import { AdaptableModule } from '../../types';
+import { IModule, ModuleInfo, IModuleCollection } from '../../Strategy/Interface/IModule';
+import { TeamSharingImportInfo } from '../../PredefinedConfig/TeamSharingState';
+import { AdaptableObject } from '../../PredefinedConfig/Common/AdaptableObject';
+import { IModuleService } from './Interface/IModuleService';
+export declare class ModuleService implements IModuleService {
+    private adaptable;
+    constructor(adaptable: IAdaptable);
+    createModuleMenus(): void;
+    isModuleAvailable(adaptableModule: AdaptableModule): boolean;
+    isModuleEditable(adaptableModule: AdaptableModule): boolean;
+    getTeamSharingAction(adaptableModule: AdaptableModule): TeamSharingImportInfo<AdaptableObject> | undefined;
+    getModuleById(adaptableModule: AdaptableModule): IModule | undefined;
+    getModuleInfoByModule(adaptableModule: AdaptableModule): ModuleInfo | undefined;
+    getModuleInfoByFriendlyName(friendlyName: string): ModuleInfo | undefined;
+    getModuleCollection(): IModuleCollection;
+    getModuleDocumentationPageByModule(adaptableModule: AdaptableModule): string;
+    destroy(): void;
+}

package/src/Utilities/Services/ModuleService.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleService = void 0;
+const tslib_1 = require("tslib");
+const Helper_1 = tslib_1.__importDefault(require("../Helpers/Helper"));
+const DocumentationLinkConstants_1 = require("../Constants/DocumentationLinkConstants");
+class ModuleService {
+    constructor(adaptable) {
+        this.adaptable = adaptable;
+        this.adaptable = adaptable;
+    }
+    createModuleMenus() {
+        const dropdownMenuItems = [];
+        const butonnMenuItems = [];
+        this.adaptable.modules.forEach((module) => {
+            const dropdownMenuItem = module.addModuleMenuItem('ModuleMenu');
+            if (Helper_1.default.objectExists(dropdownMenuItem)) {
+                if (dropdownMenuItems.findIndex((m) => m.module == dropdownMenuItem.module) == -1) {
+                    dropdownMenuItems.push(dropdownMenuItem);
+                }
+            }
+            const butonnMenuItem = module.addModuleMenuItem('ModuleButton');
+            if (Helper_1.default.objectExists(butonnMenuItem)) {
+                if (butonnMenuItems.findIndex((m) => m.module == butonnMenuItem.module) == -1) {
+                    butonnMenuItems.push(butonnMenuItem);
+                }
+            }
+        });
+        // store the main menu as we will re-use (and it never changes)
+        this.adaptable.api.internalApi.setModuleDropdownMenuItems(dropdownMenuItems);
+        this.adaptable.api.internalApi.setModuleButtonMenuItems(butonnMenuItems);
+    }
+    isModuleAvailable(adaptableModule) {
+        let module = this.adaptable.modules.get(adaptableModule);
+        if (!module) {
+            return false;
+        }
+        return module.isModuleAvailable();
+    }
+    isModuleEditable(adaptableModule) {
+        let module = this.adaptable.modules.get(adaptableModule);
+        if (!module) {
+            return false;
+        }
+        return module.isModuleEditable();
+    }
+    getTeamSharingAction(adaptableModule) {
+        let module = this.adaptable.modules.get(adaptableModule);
+        if (!module) {
+            return undefined;
+        }
+        return module.getTeamSharingAction();
+    }
+    getModuleById(adaptableModule) {
+        return this.adaptable.modules.get(adaptableModule);
+    }
+    getModuleInfoByModule(adaptableModule) {
+        const module = this.getModuleById(adaptableModule);
+        return module ? module.moduleInfo : undefined;
+    }
+    getModuleInfoByFriendlyName(friendlyName) {
+        for (let module of this.adaptable.modules.values()) {
+            let moduleInfo = module.moduleInfo;
+            if (moduleInfo && moduleInfo.FriendlyName == friendlyName) {
+                return moduleInfo;
+            }
+        }
+        return undefined;
+    }
+    getModuleCollection() {
+        return this.adaptable.modules;
+    }
+    getModuleDocumentationPageByModule(adaptableModule) {
+        let url = `${DocumentationLinkConstants_1.HOST_URL_DOCS}/`;
+        let moduleUrl = url + 'adaptable-modules/';
+        let userInterfaceUrl = url + 'user-interface/';
+        let pluginUrl = url + 'plugins/';
+        switch (adaptableModule) {
+            case 'Alert':
+                return moduleUrl + 'alert-module';
+            case 'BulkUpdate':
+                return moduleUrl + 'bulk-update-module';
+            case 'CalculatedColumn':
+                return moduleUrl + 'calculated-column-module';
+            case 'CellSummary':
+                return moduleUrl + 'cell-summary-module';
+            case 'ConditionalStyle':
+                return moduleUrl + 'conditional-style-module';
+            case 'CustomSort':
+                return moduleUrl + 'custom-sort-module';
+            case 'Dashboard':
+                return userInterfaceUrl + 'dashboard';
+            case 'DataSource':
+                return moduleUrl + 'data-source-module';
+            case 'Export':
+                return moduleUrl + 'export-module';
+            case 'Filter':
+                return moduleUrl + 'filter-module';
+            case 'FormatColumn':
+                return moduleUrl + 'format-column-module';
+            case 'FreeTextColumn':
+                return moduleUrl + 'free-text-column-module';
+            case 'GridInfo':
+                return moduleUrl + 'grid-info-module';
+            case 'Layout':
+                return moduleUrl + 'layout-module';
+            case 'PlusMinus':
+                return moduleUrl + 'plus-minus-module';
+            case 'Query':
+                return moduleUrl + 'query-module';
+            case 'QuickSearch':
+                return moduleUrl + 'quick-search-module';
+            case 'Schedule':
+                return moduleUrl + 'schedule-module';
+            case 'Shortcut':
+                return moduleUrl + 'shortcut-module';
+            case 'SmartEdit':
+                return moduleUrl + 'smart-edit-module';
+            case 'StateManagement':
+                return moduleUrl + 'state-management-module';
+            case 'SystemStatus':
+                return moduleUrl + 'system-status-module';
+            case 'TeamSharing':
+                return url + 'key-topics/team-sharing';
+            case 'Theme':
+                return moduleUrl + 'theme-module';
+            case 'ToolPanel':
+                return userInterfaceUrl + 'tool-panel';
+            case 'Chart':
+                return pluginUrl + 'chart/chart-plugin';
+            case 'SparklineColumn':
+                return pluginUrl + 'chart/sparkline-column-module';
+            case 'Glue42':
+                return pluginUrl + 'glue42/glue42-plugin';
+            case 'IPushPull':
+                return pluginUrl + 'ipushpull/ipushpull-plugin';
+            case 'OpenFin':
+                return pluginUrl + 'openfin/openfin-plugin';
+            default:
+                return 'good';
+        }
+    }
+    destroy() {
+        // TO DO
+    }
+}
+exports.ModuleService = ModuleService;

package/src/Utilities/Services/ReportService.d.ts

@@ -0,0 +1,30 @@
+import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
+import { AdaptableColumn } from '../../PredefinedConfig/Common/AdaptableColumn';
+import { Report, ReportData, SystemReportName } from '../../PredefinedConfig/ExportState';
+import { IReportService } from './Interface/IReportService';
+import { RowNode } from '@ag-grid-community/all-modules';
+import { SystemExportDestination } from '../../AdaptableOptions/ExportOptions';
+export declare class ReportService implements IReportService {
+    private adaptable;
+    constructor(adaptable: IAdaptable);
+    CreateSystemReport(systemReportName: SystemReportName): Report;
+    IsSystemReport(reportName: string): boolean;
+    IsSystemReportActive(reportName: SystemReportName): boolean;
+    IsSystemExportDestinationActive(exportDestination: SystemExportDestination): boolean;
+    GetReportColumnScopeShortDescription(report: Report): string;
+    GetReportColumnScopeLongDescription(report: Report): string;
+    GetReportExpressionDescription(report: Report, cols: AdaptableColumn[]): string;
+    GetReportColumnsForReport(report: Report, includePrimaryKey?: boolean): AdaptableColumn[];
+    getReportData(report: Report, includePrimaryKey?: boolean): ReportData;
+    getReportDataAsArray(report: Report, includePrimaryKey?: boolean): any[][];
+    convertReportDataToArray(reportData: ReportData): any[][];
+    getRowObjectForColumnIds(rowNode: RowNode, columnIds: string[]): Record<string, any>;
+    PublishLiveLiveDataChangedEvent(reportDestination: 'ipushpull' | 'Glue42', liveDataTrigger: 'Connected' | 'Disconnected' | 'LiveDataStarted' | 'LiveDataStopped' | 'LiveDataUpdated', liveReport?: any): void;
+    getCellExportValueFromRowNode(rowNode: RowNode, columnId: string): any;
+    getCellExportValueFromRawValue(cellRawValue: any, columnId: string): any;
+    getReportFileName(reportName: string): string;
+    destroy(): void;
+    private getCustomExportDateFormat;
+    private getCellExportValueFromRawValueByType;
+    private computeCellExportValueFormat;
+}