@adaptabletools/adaptable-cjs 17.0.0-canary.1

package/src/Utilities/license/decode.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decode = exports.fieldsToLicenseDetails = exports.GENERIC_APP_NAME = void 0;
+const hashing_1 = require("./hashing");
+const getGenericError = () => new Error('Invalid License');
+exports.GENERIC_APP_NAME = 'GenericAdaptableApp';
+const fieldsToLicenseDetails = (fields) => {
+    var _a;
+    const fieldsMap = fields.reduce((acc, field) => {
+        acc.set(field.name, field.value);
+        return acc;
+    }, new Map());
+    const details = {
+        start: new Date(fieldsMap.get('StartDate')),
+        end: new Date(fieldsMap.get('EndDate')),
+        owner: fieldsMap.get('Owner'),
+        appName: fieldsMap.get('AppName') || exports.GENERIC_APP_NAME,
+        timestamp: fieldsMap.get('TS') ? Number(fieldsMap.get('TS')) : 0,
+        trial: fieldsMap.get('Trial') === 'true' ? true : false,
+        ref: (_a = fieldsMap.get('Ref')) !== null && _a !== void 0 ? _a : '',
+    };
+    if (!details.start ||
+        !details.end ||
+        !details.owner ||
+        typeof details.trial !== 'boolean' ||
+        !details.ref) {
+        throw getGenericError();
+    }
+    return details;
+};
+exports.fieldsToLicenseDetails = fieldsToLicenseDetails;
+const decode = (licenseKey) => {
+    let crc = '';
+    let fields = licenseKey.split('|').map((part) => {
+        let [name, value] = part.split('=');
+        if (name === 'C') {
+            crc = value;
+        }
+        return {
+            name,
+            value,
+        };
+    });
+    if (!crc) {
+        throw getGenericError();
+    }
+    const crcParts = crc.split(',').reverse();
+    const overallCrc = crcParts.pop();
+    crcParts.forEach((fieldCrc, index) => {
+        const field = fields[index];
+        if ((0, hashing_1.compute_string)(field.value) !== fieldCrc) {
+            throw getGenericError();
+        }
+    });
+    const fieldsWithoutC = [...fields];
+    fieldsWithoutC.pop();
+    const fieldsWithoutCString = fieldsWithoutC
+        .map((field) => {
+        return `${field.name}=${field.value}`;
+    })
+        .join('|');
+    if ((0, hashing_1.compute_string)(fieldsWithoutCString) !== overallCrc) {
+        throw getGenericError();
+    }
+    fields = fields.map((f) => {
+        return Object.assign(Object.assign({}, f), { value: decodeURI(f.value) });
+    });
+    return (0, exports.fieldsToLicenseDetails)(fields);
+};
+exports.decode = decode;

package/src/Utilities/license/hashing.d.ts

@@ -0,0 +1 @@
+export declare function compute_string(str: string, reversedPolynomial?: number): string;

package/src/Utilities/license/hashing.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compute_string = void 0;
+const DEFAULT_ReversedPolynomial = 0xedb88320;
+/*
+ * CRC-32 implementation
+ */
+function generate(reversedPolynomial = DEFAULT_ReversedPolynomial) {
+    var table = new Array();
+    var i, j, n;
+    for (i = 0; i < 256; i++) {
+        n = i;
+        for (j = 8; j > 0; j--) {
+            if ((n & 1) == 1) {
+                n = (n >>> 1) ^ reversedPolynomial;
+            }
+            else {
+                n = n >>> 1;
+            }
+        }
+        table[i] = n;
+    }
+    return table;
+}
+function crc32_initial() {
+    return 0xffffffff;
+}
+function crc32_add_byte(table, crc, byte) {
+    crc = (crc >>> 8) ^ table[byte ^ (crc & 0x000000ff)];
+    return crc;
+}
+function crc32_final(crc) {
+    crc = ~crc;
+    crc = crc < 0 ? 0xffffffff + crc + 1 : crc;
+    return crc;
+}
+function compute_string(str, reversedPolynomial = DEFAULT_ReversedPolynomial) {
+    var table = generate(reversedPolynomial);
+    var crc = 0;
+    var i;
+    crc = crc32_initial();
+    for (i = 0; i < str.length; i++)
+        crc = crc32_add_byte(table, crc, str.charCodeAt(i));
+    crc = crc32_final(crc);
+    return `${crc}`;
+}
+exports.compute_string = compute_string;

package/src/Utilities/logDeprecation.d.ts

@@ -0,0 +1,6 @@
+import { AdaptableLogger } from '../agGrid/AdaptableLogger';
+type StringKey<T> = Extract<keyof T, string>;
+export declare const logDeprecation: <T>(logger: AdaptableLogger, typeName: string, oldProp: Extract<keyof T, string>, newProp?: Extract<keyof T, string>, message?: string) => void;
+export declare const logDeprecationExternal: <OLD_TYPE, NEW_TYPE>(logger: AdaptableLogger, oldTypeName: string, oldProp: Extract<keyof OLD_TYPE, string>, newTypeName: string, newProp: Extract<keyof NEW_TYPE, string>, message?: string) => void;
+export declare const logDeprecationInternal: <T>(logger: AdaptableLogger, typeName: string, oldProp: Extract<keyof T, string>) => void;
+export {};

package/src/Utilities/logDeprecation.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logDeprecationInternal = exports.logDeprecationExternal = exports.logDeprecation = void 0;
+const doOnceFlags = {};
+/**
+ * If the key was passed before, then do NOT execute the func
+ */
+const doOnce = (func, key) => {
+    if (doOnceFlags[key]) {
+        return;
+    }
+    func();
+    doOnceFlags[key] = true;
+};
+const logDeprecation = (logger, typeName, oldProp, newProp, message) => {
+    const newPropMsg = newProp ? `Please use '${typeName}.${newProp}()' instead. ` : '';
+    doOnce(() => logger.consoleWarn(`'${typeName}.${oldProp}()' is deprecated. ${newPropMsg}${message !== null && message !== void 0 ? message : ''}`), `Deprecated_${oldProp}`);
+};
+exports.logDeprecation = logDeprecation;
+const logDeprecationExternal = (logger, oldTypeName, oldProp, newTypeName, newProp, message) => {
+    const newPropMsg = newProp ? `Please use '${newTypeName}.${newProp}()' instead. ` : '';
+    doOnce(() => logger.consoleWarn(`'${oldTypeName}.${oldProp}()' is deprecated. ${newPropMsg}${message !== null && message !== void 0 ? message : ''}`), `Deprecated_${oldProp}`);
+};
+exports.logDeprecationExternal = logDeprecationExternal;
+const logDeprecationInternal = (logger, typeName, oldProp) => {
+    doOnce(() => logger.consoleWarn(`'${typeName}.${oldProp}()' is deprecated. The method will be removed in the next major release.
+        Please contact support if you need the missing functionality.`), `Deprecated_${oldProp}`);
+};
+exports.logDeprecationInternal = logDeprecationInternal;

package/src/Utilities/reorder.d.ts

@@ -0,0 +1 @@
+export declare const reorder: (list: any[], startIndex: number, endIndex: number) => any[];

package/src/Utilities/reorder.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reorder = void 0;
+const reorder = (list, startIndex, endIndex) => {
+    const result = [...list];
+    if (startIndex > list.length - 1) {
+        // not much that we can do if the dragged item is out of bounds...
+        return result;
+    }
+    if (endIndex > list.length - 1) {
+        endIndex = list.length - 1;
+    }
+    const [removed] = result.splice(startIndex, 1);
+    result.splice(endIndex, 0, removed);
+    return result;
+};
+exports.reorder = reorder;

package/src/Utilities/runIfNotResolvedIn.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Calls the callback if the promise does not resolve in a amount of time.
+ *
+ * @param promise
+ * @param callback Called if promise does not resolve in the time defined by 'delay'
+ * @param delay Time after which if the promise was not resolved the callback (fn) is called.
+ */
+export declare const runIfNotResolvedIn: <T>(promise: Promise<T>, callback: () => void, delay?: number) => Promise<T>;

package/src/Utilities/runIfNotResolvedIn.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runIfNotResolvedIn = void 0;
+/**
+ * Calls the callback if the promise does not resolve in a amount of time.
+ *
+ * @param promise
+ * @param callback Called if promise does not resolve in the time defined by 'delay'
+ * @param delay Time after which if the promise was not resolved the callback (fn) is called.
+ */
+const runIfNotResolvedIn = async (promise, callback, delay = 100) => {
+    let isFulfilled = false;
+    promise === null || promise === void 0 ? void 0 : promise.then(() => {
+        isFulfilled = true;
+    });
+    (async () => {
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        if (!isFulfilled) {
+            callback();
+        }
+    })();
+    return promise;
+};
+exports.runIfNotResolvedIn = runIfNotResolvedIn;

package/src/Utilities/sortWithOrder.d.ts

@@ -0,0 +1,11 @@
+export declare function sortWithOrderArray<T>(arr: T[], order: T[], 
+/**
+ *
+ * The array can contain items which are not listed in the order array.
+ * So sortUnorderedItems decides whether to leave these items untouched
+ * in the current order in which they are in the array (sortUnorderedItems: false)
+ * or to sort them using normal comparison rules
+ */
+{ sortUnorderedItems: sortUnorderedItems }: {
+    sortUnorderedItems: boolean;
+}): T[];

package/src/Utilities/sortWithOrder.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortWithOrderArray = void 0;
+function sortWithOrderArray(arr, order, 
+/**
+ *
+ * The array can contain items which are not listed in the order array.
+ * So sortUnorderedItems decides whether to leave these items untouched
+ * in the current order in which they are in the array (sortUnorderedItems: false)
+ * or to sort them using normal comparison rules
+ */
+{ sortUnorderedItems: sortUnorderedItems }) {
+    const itemsToIndex = arr.reduce((acc, x, i) => {
+        acc.set(x, i);
+        return acc;
+    }, new Map());
+    const orderItemsToIndex = order.reduce((acc, x, i) => {
+        acc.set(x, i);
+        return acc;
+    }, new Map());
+    function compareItemsOfCustomSort(valueA, valueB) {
+        const orderContainsFirstElement = orderItemsToIndex.has(valueA);
+        const indexInOrderOfFirstElement = orderContainsFirstElement
+            ? orderItemsToIndex.get(valueA)
+            : -1;
+        const orderContainsSecondElement = orderItemsToIndex.has(valueB);
+        const indexInOrderSecondElement = orderContainsSecondElement
+            ? orderItemsToIndex.get(valueB)
+            : -1;
+        //if none of the element are in the order list we just return normal compare
+        if (!orderContainsFirstElement && !orderContainsSecondElement) {
+            if (!sortUnorderedItems) {
+                // keep the original order
+                return itemsToIndex.get(valueA) - itemsToIndex.get(valueB);
+            }
+            if (valueA == valueB) {
+                return 0;
+            }
+            return valueA < valueB ? -1 : 1;
+        }
+        //if first item not in the list make sure we put it after the second item
+        if (!orderContainsFirstElement) {
+            return 1;
+        }
+        //if second item not in the list make sure we put it after the first item
+        if (!orderContainsSecondElement) {
+            return -1;
+        }
+        //return the comparison from the list if the two items are in the list
+        return indexInOrderOfFirstElement - indexInOrderSecondElement;
+    }
+    return [].concat(arr).sort(compareItemsOfCustomSort);
+}
+exports.sortWithOrderArray = sortWithOrderArray;

package/src/Utilities/waitForCondition.d.ts

@@ -0,0 +1 @@
+export declare const waitForCondition: (isReady: () => boolean, timeout?: number) => Promise<void>;

package/src/Utilities/waitForCondition.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForCondition = void 0;
+const waitForCondition = (isReady, timeout = 5000) => {
+    const startTime = Date.now();
+    const ready = isReady();
+    if (ready) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+        const wait = (callback) => {
+            const ready = isReady();
+            if (Date.now() - startTime > timeout) {
+                reject('Wait time expired');
+                return;
+            }
+            if (!ready) {
+                setTimeout(() => {
+                    wait(callback);
+                }, 16);
+            }
+            else {
+                callback();
+            }
+        };
+        wait(resolve);
+    });
+};
+exports.waitForCondition = waitForCondition;

package/src/Utilities/waitForTimeout.d.ts

@@ -0,0 +1 @@
+export declare function waitForTimeout(ms: number): Promise<void>;

package/src/Utilities/waitForTimeout.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForTimeout = void 0;
+// waits for the given ms milliseconds
+function waitForTimeout(ms) {
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            resolve();
+        }, ms);
+    });
+}
+exports.waitForTimeout = waitForTimeout;

package/src/View/AdaptableContext.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+import { IAdaptable } from '../AdaptableInterfaces/IAdaptable';
+declare const AdaptableContext: React.Context<IAdaptable>;
+export default AdaptableContext;
+export declare const useAdaptable: () => IAdaptable;

package/src/View/AdaptableContext.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAdaptable = void 0;
+const tslib_1 = require("tslib");
+const React = tslib_1.__importStar(require("react"));
+const AdaptableContext = React.createContext(null);
+exports.default = AdaptableContext;
+const useAdaptable = () => {
+    const context = React.useContext(AdaptableContext);
+    return context;
+};
+exports.useAdaptable = useAdaptable;

package/src/View/AdaptablePopover/index.d.ts

@@ -0,0 +1,23 @@
+import * as React from 'react';
+import { AdaptableMessageType } from '../../PredefinedConfig/Common/AdaptableMessageType';
+import { OverlayShowParams } from '../../components/InfiniteTable';
+export interface AdaptablePopoverProps extends React.ClassAttributes<React.PropsWithChildren<AdaptablePopover>> {
+    headerText?: string;
+    showEvent?: string;
+    hideEvent?: string;
+    className?: string;
+    bodyText: any[];
+    showIcon?: boolean;
+    MessageType?: AdaptableMessageType;
+    triggerAction?: string;
+    useButton?: boolean;
+    tooltipText?: string;
+    popoverMinWidth?: number;
+    popoverMaxWidth?: number;
+    popupPadding?: number;
+    alignPosition?: OverlayShowParams['alignPosition'];
+    visible?: boolean;
+}
+export declare class AdaptablePopover extends React.Component<React.PropsWithChildren<AdaptablePopoverProps>, {}> {
+    render(): JSX.Element;
+}

package/src/View/AdaptablePopover/index.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdaptablePopover = void 0;
+const tslib_1 = require("tslib");
+const React = tslib_1.__importStar(require("react"));
+const StringExtensions_1 = require("../../Utilities/Extensions/StringExtensions");
+const UIHelper_1 = require("../UIHelper");
+const ButtonInfo_1 = require("../Components/Buttons/ButtonInfo");
+const icons_1 = require("../../components/icons");
+const OverlayTrigger_1 = tslib_1.__importDefault(require("../../components/OverlayTrigger"));
+const rebass_1 = require("rebass");
+class AdaptablePopover extends React.Component {
+    render() {
+        var _a, _b, _c;
+        let messageType = this.props.MessageType != null ? this.props.MessageType : 'Info';
+        const showIcon = (_a = this.props.showIcon) !== null && _a !== void 0 ? _a : true;
+        let useButton = this.props.useButton != null ? this.props.useButton : false;
+        let popoverMinWidth = this.props.popoverMinWidth != null ? this.props.popoverMinWidth.toString() + 'px' : 'auto';
+        const title = StringExtensions_1.StringExtensions.IsNotNullOrEmpty(this.props.headerText)
+            ? this.props.headerText
+            : '';
+        const popoverClickRootClose = (React.createElement(rebass_1.Box, { className: "ab-Popover", style: {
+                margin: '0px',
+                padding: '0px',
+                minWidth: popoverMinWidth,
+                maxWidth: (_b = this.props.popoverMaxWidth) !== null && _b !== void 0 ? _b : 300,
+            } },
+            title ? (React.createElement(rebass_1.Text, { fontSize: 4, padding: 2 }, title)) : null,
+            React.createElement(rebass_1.Box, { className: "ab-Popover__body", padding: (_c = this.props.popupPadding) !== null && _c !== void 0 ? _c : 2 }, this.props.bodyText.map((textOrHTML, index) => (React.createElement("span", { key: index }, textOrHTML))))));
+        const icon = 'info'; // - think this is wrong - UIHelper.getGlyphByMessageType(messageType);
+        const color = UIHelper_1.UIHelper.getColorByMessageType(messageType);
+        const iconStyle = {
+            color,
+            fill: 'currentColor',
+        };
+        return (React.createElement(rebass_1.Flex, { alignItems: "center", className: this.props.className },
+            React.createElement(OverlayTrigger_1.default
+            // showTriangle
+            , { 
+                // showTriangle
+                visible: this.props.visible, render: () => popoverClickRootClose, showEvent: (this.props.showEvent || 'mouseenter'), hideEvent: (this.props.hideEvent || 'mouseleave'), style: {
+                    overflow: 'visible',
+                }, defaultZIndex: 100000, alignPosition: this.props.alignPosition }, useButton ? (React.createElement(ButtonInfo_1.ButtonInfo, { style: iconStyle, variant: "text", onClick: () => null, icon: showIcon && icon, tooltip: this.props.tooltipText }, this.props.children)) : (React.createElement("div", { title: this.props.tooltipText, tabIndex: 0, style: { cursor: 'pointer', display: 'inline-block' } },
+                this.props.children,
+                showIcon && React.createElement(icons_1.Icon, { name: icon, style: iconStyle }))))));
+    }
+}
+exports.AdaptablePopover = AdaptablePopover;

package/src/View/AdaptableView.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+import { IAdaptable } from '../AdaptableInterfaces/IAdaptable';
+export declare const AdaptableApp: React.FunctionComponent<{
+    Adaptable: IAdaptable;
+}>;

package/src/View/AdaptableView.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdaptableApp = void 0;
+const tslib_1 = require("tslib");
+const React = tslib_1.__importStar(require("react"));
+const react_redux_1 = require("react-redux");
+const ProgressIndicator_1 = require("../components/ProgressIndicator/ProgressIndicator");
+const Toastify_1 = require("../components/Toastify");
+const PopupRedux = tslib_1.__importStar(require("../Redux/ActionsReducers/PopupRedux"));
+const AdaptableLoadingScreen_1 = require("./Components/Popups/AdaptableLoadingScreen");
+const AdaptablePopup_1 = require("./Components/Popups/AdaptablePopup");
+const AdaptablePopupConfirmation_1 = require("./Components/Popups/AdaptablePopupConfirmation");
+const AdaptablePopupPrompt_1 = require("./Components/Popups/AdaptablePopupPrompt");
+const FormPopups_1 = require("./Components/Popups/FormPopups/FormPopups");
+const WindowPopups_1 = require("./Components/Popups/WindowPopups/WindowPopups");
+const Dashboard_1 = require("./Dashboard/Dashboard");
+const License_1 = require("./License");
+const NotesPopup_1 = require("./Notes/NotesPopup");
+const FloatingQuickSearch_1 = require("./QuickSearch/FloatingQuickSearch/FloatingQuickSearch");
+const renderWithAdaptableContext_1 = require("./renderWithAdaptableContext");
+class AdaptableView extends React.Component {
+    render() {
+        var _a, _b, _c, _d;
+        const watermark = (_d = (_c = (_b = (_a = this.props.AdaptableApi) === null || _a === void 0 ? void 0 : _a.internalApi) === null || _b === void 0 ? void 0 : _b.getSystemState()) === null || _c === void 0 ? void 0 : _c.License) === null || _d === void 0 ? void 0 : _d.watermark;
+        const adaptableOptions = this.props.AdaptableApi.optionsApi.getAdaptableOptions();
+        return (React.createElement("div", null,
+            React.createElement(NotesPopup_1.NotePopup, null),
+            React.createElement(FloatingQuickSearch_1.QuickSearchDrawer, null),
+            this.props.AdaptableApi.internalApi.getModuleService().isModuleAvailable('Dashboard') && (React.createElement(Dashboard_1.Dashboard, { api: this.props.AdaptableApi })),
+            this.props.AdaptableApi.optionsApi.getUserInterfaceOptions().showLoadingScreen && (React.createElement(AdaptableLoadingScreen_1.AdaptableLoadingScreen, { onClose: this.props.onCloseLoadingPopup, showLoadingScreen: this.props.PopupState.LoadingPopup.ShowLoadingPopup })),
+            this.props.PopupState.PromptPopup.ShowPromptPopup && (React.createElement(AdaptablePopupPrompt_1.AdaptablePopupPrompt, { message: this.props.PopupState.PromptPopup.Message, header: this.props.PopupState.PromptPopup.Header, onClose: this.props.onClosePromptPopup, onConfirm: this.props.onConfirmPromptPopup, onConfirmActionCreator: this.props.PopupState.PromptPopup.ConfirmActionCreator, defaultValue: this.props.PopupState.PromptPopup.DefaultValue })),
+            Boolean(this.props.PopupState.ConfirmationPopup.ShowConfirmationPopup) && (React.createElement(AdaptablePopupConfirmation_1.AdaptablePopupConfirmation, { header: this.props.PopupState.ConfirmationPopup.Header, messsage: this.props.PopupState.ConfirmationPopup.Msg, showPopup: this.props.PopupState.ConfirmationPopup.ShowConfirmationPopup, cancelButtonText: this.props.PopupState.ConfirmationPopup.CancelButtonText, confirmButtonText: this.props.PopupState.ConfirmationPopup.ConfirmButtonText, onCancel: this.props.onCancelConfirmationPopup, onConfirm: this.props.onConfirmConfirmationPopup, showInputBox: this.props.PopupState.ConfirmationPopup.ShowInputBox, messageType: this.props.PopupState.ConfirmationPopup.MessageType, api: this.props.AdaptableApi })),
+            Boolean(this.props.PopupState.ScreenPopup.ShowScreenPopup) && (React.createElement(AdaptablePopup_1.AdaptablePopup, { componentName: this.props.PopupState.ScreenPopup.ComponentName, componentModule: this.props.PopupState.ScreenPopup.ComponentModule, onHide: this.props.onCloseScreenPopup, api: this.props.AdaptableApi, onClearParams: () => this.props.onClearPopupParams(), moduleParams: this.props.PopupState.ScreenPopup.Params, moduleProps: this.props.PopupState.ScreenPopup.PopupProps })),
+            React.createElement(Toastify_1.ToastContainer
+            // we NEEEEED!!!! this containerId, otherwise, toastify will have memory leaks when the adaptable
+            // instance is destroyed and re-created many times
+            , { 
+                // we NEEEEED!!!! this containerId, otherwise, toastify will have memory leaks when the adaptable
+                // instance is destroyed and re-created many times
+                containerId: adaptableOptions.adaptableId, enableMultiContainer: true, limit: adaptableOptions.notificationsOptions.maxNotifications, closeButton: false, icon: false, theme: "colored" }),
+            (watermark === null || watermark === void 0 ? void 0 : watermark.show) && React.createElement(License_1.LicenseWatermark, null, watermark === null || watermark === void 0 ? void 0 : watermark.text),
+            React.createElement(WindowPopups_1.WindowPopups, null),
+            React.createElement(FormPopups_1.FormPopups, null),
+            React.createElement(ProgressIndicator_1.ProgressIndicator, null)));
+    }
+}
+function mapStateToProps(state, ownProps) {
+    return {
+        PopupState: state.Popup,
+        SystemState: state.System,
+        AdaptableApi: ownProps.Adaptable.api,
+    };
+}
+function mapDispatchToProps(dispatch) {
+    return {
+        onCloseScreenPopup: () => dispatch(PopupRedux.PopupHideScreen()),
+        onClosePromptPopup: () => dispatch(PopupRedux.PopupHidePrompt()),
+        onConfirmPromptPopup: (inputText) => dispatch(PopupRedux.PopupConfirmPrompt(inputText)),
+        onConfirmConfirmationPopup: (comment) => dispatch(PopupRedux.PopupConfirmConfirmation(comment)),
+        onCancelConfirmationPopup: () => dispatch(PopupRedux.PopupCancelConfirmation()),
+        showPopup: (componentModule, componentName, params) => dispatch(PopupRedux.PopupShowScreen(componentModule, componentName, params)),
+        onClearPopupParams: () => dispatch(PopupRedux.PopupClearParam()),
+    };
+}
+let AdaptableWrapper = (0, react_redux_1.connect)(mapStateToProps, mapDispatchToProps)(AdaptableView);
+const AdaptableApp = ({ Adaptable }) => (0, renderWithAdaptableContext_1.renderWithAdaptableContext)(React.createElement(AdaptableWrapper, { Adaptable: Adaptable }), Adaptable);
+exports.AdaptableApp = AdaptableApp;

package/src/View/AdaptableViewFactory.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { ConnectedComponent } from 'react-redux';
+import { AdaptableModule } from '../PredefinedConfig/Common/Types';
+export declare const AdaptableViewFactory: IAdaptableViewFactory;
+export declare const AdaptableViewPanelFactory: Map<AdaptableModule, React.FunctionComponent<any> | ConnectedComponent<any, any>>;
+export interface IAdaptableViewFactory {
+    [key: string]: any;
+}

package/src/View/AdaptableViewFactory.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdaptableViewPanelFactory = exports.AdaptableViewFactory = void 0;
+const tslib_1 = require("tslib");
+const SmartEditPopup_1 = require("./SmartEdit/SmartEditPopup");
+const QuickSearchPopup_1 = require("./QuickSearch/QuickSearchPopup");
+const ThemePopup_1 = require("./Theme/ThemePopup");
+const ToolPanelPopup_1 = require("./Components/ToolPanel/ToolPanelPopup");
+const GridInfoPopup_1 = require("./GridInfo/GridInfoPopup/GridInfoPopup");
+const DashboardPopup_1 = require("./Dashboard/DashboardPopup");
+const StateManagementPopup_1 = require("./StateManagement/StateManagementPopup");
+const ModuleConstants = tslib_1.__importStar(require("../Utilities/Constants/ModuleConstants"));
+const BulkUpdatePopup_1 = require("./BulkUpdate/BulkUpdatePopup");
+const CellSummaryPopup_1 = require("./CellSummary/CellSummaryPopup");
+const SystemStatusPopup_1 = require("./SystemStatus/SystemStatusPopup");
+const AlertViewPanel_1 = require("./Alert/AlertViewPanel");
+const BulkUpdateViewPanel_1 = require("./BulkUpdate/BulkUpdateViewPanel");
+const CellSummaryViewPanel_1 = require("./CellSummary/CellSummaryViewPanel");
+const FilterViewPanel_1 = require("./Filter/FilterViewPanel");
+const DashboardViewPanel_1 = require("./Dashboard/DashboardViewPanel");
+const ExportViewPanel_1 = require("./Export/ExportViewPanel");
+const LayoutViewPanel_1 = require("./Layout/LayoutViewPanel");
+const GridFilterViewPanel_1 = require("./GridFilter/GridFilterViewPanel");
+const QuickSearchViewPanel_1 = require("./QuickSearch/QuickSearchViewPanel");
+const SmartEditViewPanel_1 = require("./SmartEdit/SmartEditViewPanel");
+const SystemStatusViewPanel_1 = require("./SystemStatus/SystemStatusViewPanel");
+const ThemeViewPanel_1 = require("./Theme/ThemeViewPanel");
+const DataSetViewPanel_1 = require("./DataSet/DataSetViewPanel");
+const DataChangeHistoryPopup_1 = require("./DataChangeHistory/DataChangeHistoryPopup");
+const DataChangeHistoryViewPanel_1 = require("./DataChangeHistory/DataChangeHistoryViewPanel");
+const StateManagementViewPanel_1 = require("./StateManagement/StateManagementViewPanel");
+const StatusBarPopup_1 = require("./StatusBar/StatusBarPopup");
+const ChartingViewPanel_1 = require("./Charting/ChartingViewPanel");
+const GridFilterPopup_1 = require("./GridFilter/GridFilterPopup");
+const ColumnInfoPopup_1 = require("./ColumnInfo/ColumnInfoPopup");
+const NotesListing_1 = require("./Notes/NotesListing");
+const DataImportPopup_1 = require("./DataImport/DataImportPopup");
+exports.AdaptableViewFactory = {
+    BulkUpdatePopup: BulkUpdatePopup_1.BulkUpdatePopup,
+    DashboardPopup: DashboardPopup_1.DashboardPopup,
+    StateManagementPopup: StateManagementPopup_1.StateManagementPopup,
+    GridInfoPopup: GridInfoPopup_1.GridInfoPopup,
+    ColumnInfoPopup: ColumnInfoPopup_1.ColumnInfoPopup,
+    StatusBarPopup: StatusBarPopup_1.StatusBarPopup,
+    QuickSearchPopup: QuickSearchPopup_1.QuickSearchPopup,
+    CellSummaryPopup: CellSummaryPopup_1.CellSummaryPopup,
+    SmartEditPopup: SmartEditPopup_1.SmartEditPopup,
+    ThemePopup: ThemePopup_1.ThemePopup,
+    ToolPanelPopup: ToolPanelPopup_1.ToolPanelPopup,
+    SystemStatusPopup: SystemStatusPopup_1.SystemStatusPopup,
+    DataChangeHistoryPopup: DataChangeHistoryPopup_1.DataChangeHistoryPopup,
+    NotesPopup: NotesListing_1.NotesListing,
+    DataImportPopup: DataImportPopup_1.DataImportPopup,
+    GridFilterPopup: GridFilterPopup_1.GridFilterPopup,
+};
+exports.AdaptableViewPanelFactory = new Map([
+    [ModuleConstants.AlertModuleId, AlertViewPanel_1.AlertViewPanelControl],
+    [ModuleConstants.BulkUpdateModuleId, BulkUpdateViewPanel_1.BulkUpdateViewPanelControl],
+    [ModuleConstants.CellSummaryModuleId, CellSummaryViewPanel_1.CellSummaryViewPanelControl],
+    [ModuleConstants.ColumnFilterModuleId, FilterViewPanel_1.FilterViewPanelControl],
+    [ModuleConstants.DashboardModuleId, DashboardViewPanel_1.DashboardViewPanelControl],
+    [ModuleConstants.ExportModuleId, ExportViewPanel_1.ExportViewPanelControl],
+    [ModuleConstants.LayoutModuleId, LayoutViewPanel_1.LayoutViewPanelControl],
+    [ModuleConstants.GridFilterModuleId, GridFilterViewPanel_1.GridFilterPanelControl],
+    [ModuleConstants.QuickSearchModuleId, QuickSearchViewPanel_1.QuickSearchViewPanelControl],
+    [ModuleConstants.SmartEditModuleId, SmartEditViewPanel_1.SmartEditViewPanelControl],
+    [ModuleConstants.SystemStatusModuleId, SystemStatusViewPanel_1.SystemStatusViewPanel],
+    [ModuleConstants.ThemeModuleId, ThemeViewPanel_1.ThemeViewPanelControl],
+    [ModuleConstants.DataSetModuleId, DataSetViewPanel_1.DataSetViewPanelControl],
+    [ModuleConstants.DataChangeHistoryModuleId, DataChangeHistoryViewPanel_1.DataChangeHistoryViewPanelControl],
+    [ModuleConstants.StateManagementModuleId, StateManagementViewPanel_1.StateManagementViewPanel],
+    [ModuleConstants.ChartingModuleId, ChartingViewPanel_1.ChartingViewPanel],
+]);

package/src/View/AdaptableWizardView/AdaptableConfigurationDialog/AdaptableConfig.d.ts

@@ -0,0 +1,15 @@
+import { AdaptableOptions } from '../../../AdaptableOptions/AdaptableOptions';
+import { GridOptions } from '@ag-grid-community/core';
+/**
+ * Config used by No Code Plugin to set up AdapTable
+ */
+export interface AdaptableConfig {
+    /**
+     * Adaptable Options object
+     */
+    adaptableOptions: AdaptableOptions;
+    /**
+     * AG Grid Grid Options object
+     */
+    gridOptions: GridOptions;
+}

package/src/View/AdaptableWizardView/AdaptableConfigurationDialog/AdaptableConfig.js

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

package/src/View/AdaptableWizardView/AdaptableConfigurationDialog/AdaptableOptionsForm.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+import { AdaptableOptions } from '../../../types';
+export declare const AdaptableOptionsForm: React.FunctionComponent<{
+    adaptableOptions: AdaptableOptions;
+    onChangedAdaptableOptions: (adaptableOptions: AdaptableOptions) => void;
+}>;