@adaptabletools/adaptable 23.1.0 → 24.0.0-canary.1

package/src/View/Components/ToolPanel/AdaptableToolPanel.js

@@ -1,217 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { kebabCase } from '../../../Utilities/Extensions/StringExtensions';
-import { ACCESS_LEVEL_FULL } from '../../../Utilities/Constants/GeneralConstants';
-import * as ToolPanelRedux from '../../../Redux/ActionsReducers/ToolPanelRedux';
-import { connect } from 'react-redux';
-import { ADAPTABLE_BUTTON_SURFACE_DEFAULTS, AdaptableButtonView } from '../AdaptableButton';
-import ArrayExtensions from '../../../Utilities/Extensions/ArrayExtensions';
-import { Icon } from '../../../components/icons';
-import { CheckBox } from '../../../components/CheckBox';
-import { NewDropdownButton } from '../../../components/DropdownButton';
-import { ALL_TOOL_PANELS, } from '../../../AdaptableState/Common/Types';
-import SimpleButton from '../../../components/SimpleButton';
-import { ButtonConfigure } from '../Buttons/ButtonConfigure';
-import { renderWithAdaptableContext } from '../../renderWithAdaptableContext';
-import { ToolPanelWrapper } from './ToolPanelWrapper';
-import { ToolPanelConfigView } from './ToolPanelPopup';
-import { ToolPanelModuleId } from '../../../Utilities/Constants/ModuleConstants';
-import HelpBlock from '../../../components/HelpBlock';
-import { Flex } from '../../../components/Flex';
-const preventDefault = (e) => e.preventDefault();
-const AdaptableToolPanelComponent = (props) => {
-    const toolPanelsGlyph = _jsx(Icon, { name: 'align-justify' });
-    const moduleService = props.api.internalApi.getModuleService();
-    const adaptableOptions = props.api.optionsApi.getAdaptableOptions();
-    const toolPanelOptions = adaptableOptions.toolPanelOptions;
-    const settingsPanelOptions = adaptableOptions.settingsPanelOptions;
-    if (props.api.entitlementApi.isModuleHiddenEntitlement('ToolPanel')) {
-        return _jsx(HelpBlock, { className: "twa:my-2 twa:p-2 twa:text-3", children: "Not enough rights" });
-    }
-    const availableModuleItems = props.MainMenuItems.filter((menuItem) => menuItem.isVisible);
-    const availableModules = availableModuleItems.map((menuItem) => menuItem.category);
-    if (!props.api.entitlementApi.isModuleHiddenEntitlement('Dashboard')) {
-        availableModules.push('Dashboard');
-    }
-    if (props.api.pluginsApi.getipushpullPluginApi() &&
-        !props.api.entitlementApi.isModuleHiddenEntitlement('IPushPull')) {
-        availableModules.push('IPushPull');
-    }
-    if (props.api.pluginsApi.getOpenFinPluginApi() &&
-        !props.api.entitlementApi.isModuleHiddenEntitlement('OpenFin')) {
-        availableModules.push('OpenFin');
-    }
-    const availableModuleToolPanels = ALL_TOOL_PANELS.filter((moduleToolPanel) => ArrayExtensions.ContainsItem(availableModules, moduleToolPanel));
-    const onStateChange = (toolPanel, visibilityMode) => {
-        if (visibilityMode === 'expanded') {
-            props.onExpandToolPanel(toolPanel);
-        }
-        else {
-            props.onCollapseToolPanel(toolPanel);
-        }
-    };
-    const isToolPanelModuleConfigurable = props.api.internalApi
-        .getModuleService()
-        .getModuleById(ToolPanelModuleId)
-        .isModuleEditable();
-    const visibleToolPanels = [];
-    const visibleToolPanelControls = (props.ToolPanels ?? []).map((toolPanelDefinition) => {
-        const visibilityMode = toolPanelDefinition.VisibilityMode ?? 'collapsed';
-        const customToolPanel = props.api.toolPanelApi.getCustomToolPanelByName(toolPanelDefinition.Name);
-        if (customToolPanel) {
-            visibleToolPanels.push(customToolPanel.name);
-            return (_jsx(ToolPanelWrapper, { customToolPanel: customToolPanel, visibilityMode: visibilityMode, onVisibilityModeChange: (state) => onStateChange(customToolPanel.name, state) }, customToolPanel.name));
-        }
-        if (availableModuleToolPanels.some((module) => module === toolPanelDefinition.Name)) {
-            const moduleToolPanel = toolPanelDefinition.Name;
-            visibleToolPanels.push(moduleToolPanel);
-            return (_jsx(ToolPanelWrapper, { adaptableToolPanel: moduleToolPanel, visibilityMode: visibilityMode, onVisibilityModeChange: (state) => onStateChange(moduleToolPanel, state) }, moduleToolPanel));
-        }
-    });
-    const renderToolPanelDropdowns = () => {
-        if (!toolPanelOptions.showToolPanelsDropdown) {
-            return;
-        }
-        let toolpanelItems = [
-            {
-                closeOnClick: false,
-                tooltip: 'Tool Panels',
-                label: (_jsxs("div", { children: [_jsx("span", { className: "twa:font-bold", children: 'Tool Panels' }), renderToolPanelConfigureButton(ToolPanelConfigView.ToolPanels)] }, "toolPanelTitle")),
-            },
-        ];
-        const isItemVisible = (panelItem) => visibleToolPanels.includes(panelItem);
-        const buildDropdownButtonItem = (toolPanel, label, isVisible) => {
-            return {
-                dataName: String(toolPanel),
-                closeOnClick: false,
-                onClick: () => {
-                    onSetToolPanelVisibility(toolPanel, !isVisible);
-                },
-                tooltip: label,
-                label: (_jsx(CheckBox, { className: "ab-dd-checkbox twa:my-0", value: toolPanel, checked: isVisible, onMouseDown: preventDefault, children: toolPanel }, toolPanel)),
-            };
-        };
-        props.api.toolPanelApi.getCustomToolPanels().forEach((customToolPanel) => {
-            const customToolPanelName = customToolPanel.name;
-            toolpanelItems.push(buildDropdownButtonItem(customToolPanelName, customToolPanelName, isItemVisible(customToolPanelName)));
-        });
-        availableModuleToolPanels.forEach((toolPanel) => {
-            let moduleName = moduleService.getModuleInfoByModule(toolPanel).FriendlyName;
-            toolpanelItems.push(buildDropdownButtonItem(toolPanel, moduleName, isItemVisible(toolPanel)));
-        });
-        toolpanelItems.sort((first, second) => {
-            if (first.label < second.label) {
-                return -1;
-            }
-            if (first.label > second.label) {
-                return 1;
-            }
-            return 0;
-        });
-        return (_jsx(NewDropdownButton, { variant: "text", tone: "none", id: 'dropdown-toolpanels', className: "ab-ToolPanel__toolbars", items: toolpanelItems, tooltip: "Manage Tool Panels", extraWidthChars: 5, children: toolPanelsGlyph }, 'dropdown-toolpanels'));
-    };
-    const renderToolPanelButtons = () => {
-        const toolPanelButtons = [];
-        let moduleButtons = props.ModuleButtons;
-        const shouldAddSettingsPanel = settingsPanelOptions.alwaysShowInToolPanel &&
-            !props.api.entitlementApi.isModuleHiddenEntitlement('SettingsPanel');
-        if (shouldAddSettingsPanel && !moduleButtons.includes('SettingsPanel')) {
-            moduleButtons = ['SettingsPanel', ...moduleButtons];
-        }
-        if (moduleButtons?.length) {
-            toolPanelButtons.push(moduleButtons.map((x) => {
-                let menuItem = props.MainMenuItems.find((y) => y.isVisible && y.category == x);
-                if (menuItem) {
-                    return (_jsx(SimpleButton, { "data-name": menuItem.category, icon: menuItem.icon, tone: "none", variant: "text", className: `ab-ToolPanel__Home__${kebabCase(menuItem.label)}`, tooltip: menuItem.label, onClick: () => props.onClick(menuItem.reduxAction), accessLevel: ACCESS_LEVEL_FULL }, menuItem.label));
-                }
-            }));
-        }
-        return toolPanelButtons;
-    };
-    const renderCustomToolPanelButtons = () => {
-        return props.api.toolPanelApi.getCustomToolPanelButtons().map((button) => {
-            const toolPanelContext = {
-                ...props.api.internalApi.buildBaseContext(),
-                toolPanelState: props.api.toolPanelApi.getToolPanelState(),
-            };
-            const buttonLabel = props.api.internalApi.getLabelForButton(button, toolPanelContext) ?? '';
-            return (_jsx(AdaptableButtonView, { button: button, context: toolPanelContext, api: props.api, defaults: ADAPTABLE_BUTTON_SURFACE_DEFAULTS.toolPanel, rerenderOnClick: false, className: `ab-ToolPanel__Home__${kebabCase(buttonLabel)}` }, buttonLabel || button.Uuid));
-        });
-    };
-    const onSetToolPanelVisibility = (name, checked) => {
-        if (checked) {
-            props.onShowToolPanel(name);
-        }
-        else {
-            props.onHideToolPanel(name);
-        }
-    };
-    const renderToolPanelConfigureButton = (initialTab) => {
-        const moduleParams = initialTab
-            ? { source: 'Other', config: { initialTab } }
-            : undefined;
-        return (_jsx(ButtonConfigure, { iconSize: 16, tone: "none", className: "ab-ToolPanel__configure-button twa:ml-2", tooltip: 'Configure ToolPanels', onClick: () => {
-                props.api.internalApi.showSettingsPanel('ToolPanel', moduleParams);
-            } }));
-    };
-    const toolPanelButtons = renderToolPanelButtons();
-    return (_jsxs(Flex, { className: "ab-ToolPanel twa:p-2 twa:w-full", "data-name": "adaptable-tool-panel", flexDirection: "column", justifyContent: "center", children: [_jsxs(Flex, { className: "ab-ToolPanel__header twa:p-1 twa:w-full twa:justify-start", flexDirection: "row", flexWrap: "wrap", children: [isToolPanelModuleConfigurable && renderToolPanelDropdowns(), toolPanelButtons, isToolPanelModuleConfigurable && renderToolPanelConfigureButton()] }), Boolean(props.api.toolPanelApi.getCustomToolPanelButtons().length) && (_jsx(Flex, { className: "ab-ToolPanel__header__buttons twa:p-1 twa:justify-start", flexDirection: "row", flexWrap: "wrap", children: renderCustomToolPanelButtons() })), visibleToolPanelControls] }));
-};
-function mapStateToProps(state) {
-    return {
-        ToolPanels: state.ToolPanel.ToolPanels,
-        ModuleButtons: state.ToolPanel.ModuleButtons,
-        MainMenuItems: state.Internal.SettingsPanelModuleEntries,
-        Columns: state.Internal.Columns,
-    };
-}
-function mapDispatchToProps(dispatch) {
-    return {
-        onClick: (action) => dispatch(action),
-        onSetToolPanelVisibility: (toolPanels) => dispatch(ToolPanelRedux.ToolPanelSetToolPanels(toolPanels)),
-        onShowToolPanel: (toolPanel) => dispatch(ToolPanelRedux.ToolPanelShowToolPanel(toolPanel)),
-        onHideToolPanel: (toolPanel) => dispatch(ToolPanelRedux.ToolPanelHideToolPanel(toolPanel)),
-        onExpandToolPanel: (toolPanel) => dispatch(ToolPanelRedux.ToolPanelExpandToolPanel(toolPanel)),
-        onCollapseToolPanel: (toolPanel) => dispatch(ToolPanelRedux.ToolPanelCollapseToolPanel(toolPanel)),
-    };
-}
-export const ConnectedAdaptableToolPanel = connect(mapStateToProps, mapDispatchToProps)(AdaptableToolPanelComponent);
-const toolPanelContainerStyle = {
-    width: '100%',
-    overflow: 'auto',
-};
-export const getAdaptableToolPanelAgGridComponent = (adaptable) => {
-    function getContainerId() {
-        return 'adaptable-tool-panel_' + adaptable.adaptableOptions.adaptableId;
-    }
-    if (adaptable.variant === 'react') {
-        return () => {
-            const content = renderWithAdaptableContext(_jsx(ConnectedAdaptableToolPanel, { api: adaptable.api, teamSharingActivated: false }), adaptable);
-            return (_jsx("div", { id: getContainerId(), className: 'ag-adaptable-panel', style: toolPanelContainerStyle, children: content }));
-        };
-    }
-    return class AdaptableToolPanelAgGridComponent {
-        gui;
-        unmountReactRoot;
-        init(params) {
-            const api = adaptable.api;
-            this.gui = document.createElement('div');
-            this.gui.id = getContainerId();
-            this.gui.className = 'ag-adaptable-panel';
-            Object.keys(toolPanelContainerStyle).forEach((key) => {
-                this.gui.style[key] = toolPanelContainerStyle[key];
-            });
-            this.unmountReactRoot = adaptable.renderReactRoot(renderWithAdaptableContext(_jsx(ConnectedAdaptableToolPanel, { api: api, teamSharingActivated: false }), adaptable), this.gui);
-        }
-        getGui() {
-            if (!this.gui) {
-                this.init();
-            }
-            return this.gui;
-        }
-        refresh() {
-        }
-        destroy() {
-            this.unmountReactRoot?.();
-        }
-    };
-};

package/src/View/Components/ToolPanel/CustomToolPanelContent.d.ts

@@ -1,6 +0,0 @@
-import * as React from 'react';
-import { CustomToolPanel } from '../../../AdaptableOptions/ToolPanelOptions';
-export interface CustomToolPanelContentProps {
-    customToolPanel: CustomToolPanel;
-}
-export declare const CustomToolPanelContent: (props: CustomToolPanelContentProps) => React.JSX.Element;

package/src/View/Components/ToolPanel/CustomToolPanelContent.js

@@ -1,51 +0,0 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { useLayoutEffect, useRef, useState } from 'react';
-import { useAdaptable } from '../../AdaptableContext';
-import { ADAPTABLE_BUTTON_SURFACE_DEFAULTS, AdaptableButtonView, } from '../AdaptableButton';
-import { kebabCase } from '../../../Utilities/Extensions/StringExtensions';
-export const CustomToolPanelContent = (props) => {
-    const { customToolPanel } = props;
-    const { api } = useAdaptable();
-    const contentsDivDomRef = useRef(null);
-    const contentsDivId = `ab-ToolPanel__${customToolPanel.name}__contents`;
-    const buttonsDivId = `ab-ToolPanel__${customToolPanel.name}__buttons`;
-    const [contentsHTML, setContentsHTML] = useState('');
-    useLayoutEffect(() => {
-        const element = contentsDivDomRef.current;
-        if (hasCustomRenderFn(customToolPanel)) {
-            const customRenderContext = {
-                phase: 'onMount',
-                element,
-                ...api.internalApi.buildBaseContext(),
-            };
-            const html = customToolPanel.render(customRenderContext);
-            setContentsHTML(html);
-        }
-        else if (hasCustomFrameworkComponent(customToolPanel)) {
-            api.internalApi.createFrameworkComponent(element, customToolPanel.frameworkComponent, 'toolPanel');
-        }
-        return () => {
-            if (hasCustomRenderFn(customToolPanel)) {
-                customToolPanel.render({
-                    phase: 'onDestroy',
-                    element,
-                    ...api.internalApi.buildBaseContext(),
-                });
-            }
-            else if (hasCustomFrameworkComponent(customToolPanel) && !api.isDestroyed()) {
-                api.internalApi.destroyFrameworkComponent(element, customToolPanel.frameworkComponent, 'toolPanel');
-            }
-        };
-    }, []);
-    return (_jsxs(_Fragment, { children: [_jsx("div", { ref: contentsDivDomRef, id: contentsDivId, className: contentsDivId, dangerouslySetInnerHTML: { __html: contentsHTML }, style: { width: '100%' } }), customToolPanel.buttons?.length && (_jsx("div", { id: buttonsDivId, className: `ab-ToolPanel__custom-content__buttons ${buttonsDivId}`, children: customToolPanel.buttons.map((button) => {
-                    const toolPanelContext = {
-                        ...api.internalApi.buildBaseContext(),
-                        toolPanelState: api.toolPanelApi.getToolPanelState(),
-                        customToolPanel: customToolPanel,
-                    };
-                    const buttonLabel = api.internalApi.getLabelForButton(button, toolPanelContext) ?? '';
-                    return (_jsx(AdaptableButtonView, { button: button, context: toolPanelContext, api: api, defaults: ADAPTABLE_BUTTON_SURFACE_DEFAULTS.customToolPanel, rerenderOnClick: false, className: `ab-ToolPanel__Home__${kebabCase(buttonLabel)}` }, buttonLabel || button.Uuid));
-                }) }))] }));
-};
-const hasCustomRenderFn = (customToolPanel) => customToolPanel.render;
-const hasCustomFrameworkComponent = (customToolPanel) => customToolPanel.frameworkComponent;

package/src/View/Components/ToolPanel/ToolPanelPopup.d.ts

@@ -1,20 +0,0 @@
-import * as React from 'react';
-import * as ToolPanelRedux from '../../../Redux/ActionsReducers/ToolPanelRedux';
-import { ModuleViewPopupProps } from '../SharedProps/ModuleViewPopupProps';
-import { InternalState } from '../../../AdaptableState/InternalState';
-import { AdaptableToolPanelDefinition, ToolPanelState } from '../../../AdaptableState/ToolPanelState';
-import { AdaptableModuleButtons } from '../../../AdaptableState/Common/Types';
-interface ToolPanelPopupComponentProps extends ModuleViewPopupProps<ToolPanelPopupComponent> {
-    ToolPanelState: ToolPanelState;
-    InternalState: InternalState;
-    onToolPanelSetModuleButtons: (moduleButtons: AdaptableModuleButtons) => ToolPanelRedux.ToolPanelSetModuleButtonsAction;
-    onToolPanelSetToolPanels: (toolPanels: AdaptableToolPanelDefinition[]) => ToolPanelRedux.ToolPanelSetToolPanelsAction;
-}
-export { ToolPanelConfigView } from './ToolPanelPopupSections';
-declare class ToolPanelPopupComponent extends React.Component<ToolPanelPopupComponentProps> {
-    render(): React.JSX.Element;
-}
-export declare let ToolPanelPopup: import("react-redux").ConnectedComponent<typeof ToolPanelPopupComponent, {
-    context?: React.Context<import("react-redux").ReactReduxContextValue<any, import("redux").UnknownAction>>;
-    store?: import("redux").Store;
-}>;

package/src/View/Components/ToolPanel/ToolPanelPopup.js

@@ -1,27 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import * as React from 'react';
-import { connect } from 'react-redux';
-import * as ToolPanelRedux from '../../../Redux/ActionsReducers/ToolPanelRedux';
-import { PopupPanel } from '../Popups/AdaptablePopup/PopupPanel';
-import { ToolPanelPopupSections, ToolPanelConfigView } from './ToolPanelPopupSections';
-export { ToolPanelConfigView } from './ToolPanelPopupSections';
-class ToolPanelPopupComponent extends React.Component {
-    render() {
-        const initialTab = this.props.popupParams?.config?.initialTab ?? ToolPanelConfigView.ToolPanels;
-        const isToolPanelReadOnly = this.props.api.entitlementApi.isModuleReadOnlyEntitlement('ToolPanel');
-        return (_jsx(PopupPanel, { headerText: "Tool Panel", glyphicon: this.props.moduleInfo.Glyph, infoLink: this.props.moduleInfo.HelpPage, infoLinkDisabled: !this.props.api.internalApi.isDocumentationLinksDisplayed(), scrollable: false, bodyClassName: "twa:gap-3 twa:flex twa:flex-col twa:h-full twa:min-h-0", children: _jsx(ToolPanelPopupSections, { ToolPanelState: this.props.ToolPanelState, InternalState: this.props.InternalState, initialTab: initialTab, isToolPanelReadOnly: isToolPanelReadOnly, onToolPanelSetModuleButtons: this.props.onToolPanelSetModuleButtons, onToolPanelSetToolPanels: this.props.onToolPanelSetToolPanels }) }));
-    }
-}
-function mapStateToProps(state) {
-    return {
-        ToolPanelState: state.ToolPanel,
-        InternalState: state.Internal,
-    };
-}
-function mapDispatchToProps(dispatch) {
-    return {
-        onToolPanelSetModuleButtons: (moduleButtons) => dispatch(ToolPanelRedux.ToolPanelSetModuleButtons(moduleButtons)),
-        onToolPanelSetToolPanels: (toolPanels) => dispatch(ToolPanelRedux.ToolPanelSetToolPanels(toolPanels)),
-    };
-}
-export let ToolPanelPopup = connect(mapStateToProps, mapDispatchToProps)(ToolPanelPopupComponent);

package/src/View/Components/ToolPanel/ToolPanelPopupSections.d.ts

@@ -1,17 +0,0 @@
-import * as React from 'react';
-import { InternalState } from '../../../AdaptableState/InternalState';
-import { AdaptableToolPanelDefinition, ToolPanelState } from '../../../AdaptableState/ToolPanelState';
-import { AdaptableModuleButtons } from '../../../AdaptableState/Common/Types';
-export declare enum ToolPanelConfigView {
-    Buttons = "Buttons",
-    ToolPanels = "ToolPanels"
-}
-export interface ToolPanelPopupSectionsProps {
-    ToolPanelState: ToolPanelState;
-    InternalState: InternalState;
-    initialTab?: ToolPanelConfigView;
-    isToolPanelReadOnly: boolean;
-    onToolPanelSetModuleButtons: (moduleButtons: AdaptableModuleButtons) => void;
-    onToolPanelSetToolPanels: (toolPanels: AdaptableToolPanelDefinition[]) => void;
-}
-export declare const ToolPanelPopupSections: React.FunctionComponent<ToolPanelPopupSectionsProps>;

package/src/View/Components/ToolPanel/ToolPanelPopupSections.js

@@ -1,75 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import * as React from 'react';
-import { ALL_TOOL_PANELS, } from '../../../AdaptableState/Common/Types';
-import ArrayExtensions from '../../../Utilities/Extensions/ArrayExtensions';
-import { ModuleValueSelector } from '../ModuleValueSelector';
-import { Flex } from '../../../components/Flex';
-import { Tag } from '../../../components/Tag';
-import { useAdaptable } from '../../AdaptableContext';
-import { CollapsibleWizardCard, getWizardAccordionSectionClassName, renderCompactColumnTags, useWizardCardAccordion, } from '../../Wizard/CollapsibleWizardCard';
-export var ToolPanelConfigView;
-(function (ToolPanelConfigView) {
-    ToolPanelConfigView["Buttons"] = "Buttons";
-    ToolPanelConfigView["ToolPanels"] = "ToolPanels";
-})(ToolPanelConfigView || (ToolPanelConfigView = {}));
-export const ToolPanelPopupSections = (props) => {
-    const { api } = useAdaptable();
-    const { bindCard, hasExpandedCard, expandedFillsSpace } = useWizardCardAccordion(null);
-    const selectedModuleButtons = [];
-    if (ArrayExtensions.IsNotNullOrEmpty(props.ToolPanelState.ModuleButtons)) {
-        props.ToolPanelState.ModuleButtons.forEach((module) => {
-            const menuItem = props.InternalState.SettingsPanelModuleEntries.find((entry) => entry.category === module);
-            if (menuItem?.isVisible) {
-                selectedModuleButtons.push(module);
-            }
-        });
-    }
-    const allModuleButtons = props.InternalState.SettingsPanelModuleEntries.map((entry) => entry.category);
-    const availableModules = props.InternalState.SettingsPanelModuleEntries.filter((menuItem) => menuItem.isVisible).map((menuItem) => menuItem.category);
-    if (!api.entitlementApi.isModuleHiddenEntitlement('Dashboard')) {
-        availableModules.push('Dashboard');
-    }
-    if (api.pluginsApi.getipushpullPluginApi() &&
-        !api.entitlementApi.isModuleHiddenEntitlement('IPushPull')) {
-        availableModules.push('IPushPull');
-    }
-    if (api.pluginsApi.getOpenFinPluginApi() &&
-        !api.entitlementApi.isModuleHiddenEntitlement('OpenFin')) {
-        availableModules.push('OpenFin');
-    }
-    const availableModuleToolPanels = ALL_TOOL_PANELS.filter((moduleToolPanel) => ArrayExtensions.ContainsItem(availableModules, moduleToolPanel));
-    const availableCustomToolPanels = api.toolPanelApi
-        .getCustomToolPanels()
-        .map((customToolPanel) => customToolPanel.name);
-    const availableToolPanels = [
-        ...availableCustomToolPanels,
-        ...availableModuleToolPanels,
-    ];
-    const selectedToolPanels = props.ToolPanelState.ToolPanels.map((toolPanelDefinition) => toolPanelDefinition.Name).filter((visibleToolPanel) => availableToolPanels.includes(visibleToolPanel));
-    const getToolPanelLabel = React.useCallback((toolPanelId) => {
-        const customToolPanel = api.toolPanelApi.getCustomToolPanelByName(toolPanelId);
-        if (customToolPanel) {
-            return customToolPanel.title ?? customToolPanel.name;
-        }
-        return (api.internalApi.getModuleService().getModuleFriendlyName(toolPanelId) ??
-            toolPanelId);
-    }, [api]);
-    const isModuleCheckboxDisabled = (module) => {
-        if (module === 'SettingsPanel') {
-            return api.optionsApi.getSettingsPanelOptions().alwaysShowInDashboard;
-        }
-        return false;
-    };
-    const handleToolPanelsChanged = (selectedValues) => {
-        const currentSelectedToolPanelDefinitions = props.ToolPanelState.ToolPanels;
-        const newSelectedToolPanelDefinitions = selectedValues.map((selectedToolPanel) => currentSelectedToolPanelDefinitions.find((currentDefinition) => currentDefinition.Name === selectedToolPanel) ?? {
-            Name: selectedToolPanel,
-            VisibilityMode: 'collapsed',
-        });
-        props.onToolPanelSetToolPanels(newSelectedToolPanelDefinitions);
-    };
-    const moduleButtonLabels = selectedModuleButtons.map((module) => api.internalApi.getModuleService().getModuleFriendlyName(module) ?? module);
-    const toolPanelsSummary = selectedToolPanels.length > 0 ? (_jsx(Flex, { flexWrap: "wrap", alignItems: "center", className: "twa:gap-1", children: selectedToolPanels.map((toolPanelId) => (_jsx(Tag, { children: getToolPanelLabel(toolPanelId) }, toolPanelId))) })) : (_jsx(Tag, { children: "No tool panels" }));
-    const moduleButtonsSummary = moduleButtonLabels.length > 0 ? (_jsx(Flex, { flexWrap: "wrap", alignItems: "center", className: "twa:gap-1", children: moduleButtonLabels.map((label) => (_jsx(Tag, { children: label }, label))) })) : (_jsx(Tag, { children: "No Module Buttons" }));
-    return (_jsxs(Flex, { flexDirection: "column", className: getWizardAccordionSectionClassName(hasExpandedCard, expandedFillsSpace), children: [_jsx(CollapsibleWizardCard, { ...bindCard('tool-panels', { fillAvailable: true }), "data-name": "tool-panel-tool-panels", title: "Tool Panels", help: "Select and order the Tool Panels to show in the AdapTable Tool Panel", compactSummary: renderCompactColumnTags(selectedToolPanels.map((toolPanelId) => getToolPanelLabel(toolPanelId)), (label) => label), summary: toolPanelsSummary, className: "twa:overflow-hidden twa:flex twa:flex-col", bodyClassName: "twa:min-h-[240px] twa:overflow-hidden twa:flex twa:flex-col twa:!pt-0 twa:!pb-0 twa:px-1", children: _jsx(ModuleValueSelector, { options: availableToolPanels, value: selectedToolPanels, onChange: handleToolPanelsChanged, disabled: props.isToolPanelReadOnly }) }), _jsx(CollapsibleWizardCard, { ...bindCard('module-buttons', { fillAvailable: true }), "data-name": "tool-panel-module-buttons", title: "Module Buttons", help: "Select and order module buttons shown at the top of the tool panel", compactSummary: renderCompactColumnTags(moduleButtonLabels, (label) => label), summary: moduleButtonsSummary, className: "twa:overflow-hidden twa:flex twa:flex-col", bodyClassName: "twa:min-h-[240px] twa:overflow-hidden twa:flex twa:flex-col twa:!pt-0 twa:!pb-0 twa:px-1", children: _jsx(ModuleValueSelector, { options: allModuleButtons, value: selectedModuleButtons, isOptionDisabled: isModuleCheckboxDisabled, disabled: props.isToolPanelReadOnly, onChange: (selectedValues) => props.onToolPanelSetModuleButtons(selectedValues) }) })] }));
-};

package/src/View/Components/ToolPanel/ToolPanelWrapper.d.ts

@@ -1,16 +0,0 @@
-import * as React from 'react';
-import { AdaptableToolPanel } from '../../../AdaptableState/Common/Types';
-import { CustomToolPanel } from '../../../AdaptableOptions/ToolPanelOptions';
-import { ToolPanelVisibilityMode } from '../../../AdaptableState/ToolPanelState';
-export type ToolPanelWrapperProps = {
-    adaptableToolPanel: AdaptableToolPanel;
-    customToolPanel?: undefined;
-    visibilityMode: ToolPanelVisibilityMode;
-    onVisibilityModeChange: (visibilityMode: ToolPanelVisibilityMode) => void;
-} | {
-    customToolPanel: CustomToolPanel;
-    adaptableToolPanel?: undefined;
-    visibilityMode: ToolPanelVisibilityMode;
-    onVisibilityModeChange: (visibilityMode: ToolPanelVisibilityMode) => void;
-};
-export declare const ToolPanelWrapper: (props: ToolPanelWrapperProps) => React.JSX.Element;

package/src/View/Components/ToolPanel/ToolPanelWrapper.js

@@ -1,55 +0,0 @@
-import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
-import { useAdaptable } from '../../AdaptableContext';
-import { AdaptableViewPanelFactory } from '../../AdaptableViewFactory';
-import { CustomToolPanelContent } from './CustomToolPanelContent';
-import * as ToolPanelRedux from '../../../Redux/ActionsReducers/ToolPanelRedux';
-import { PanelToolPanel } from '../Panels/PanelToolPanel';
-import * as PopupRedux from '../../../Redux/ActionsReducers/PopupRedux';
-import { ToolPanelModuleId } from '../../../Utilities/Constants/ModuleConstants';
-import { Box } from '../../../components/Flex';
-export const ToolPanelWrapper = (props) => {
-    const { adaptableToolPanel, customToolPanel, visibilityMode: visibilityMode, onVisibilityModeChange: onVisibilityModeChange, } = props;
-    const { api } = useAdaptable();
-    const getToolPanelConfiguration = () => {
-        if (adaptableToolPanel) {
-            const accessLevel = api.entitlementApi.getEntitlementAccessLevelForModule(adaptableToolPanel);
-            const moduleInfo = api.internalApi
-                .getModuleService()
-                .getModuleInfoByModule(adaptableToolPanel);
-            const ModuleToolPanel = AdaptableViewPanelFactory.get(adaptableToolPanel);
-            return [
-                adaptableToolPanel,
-                moduleInfo.FriendlyName,
-                ModuleToolPanel ? (_jsx(ModuleToolPanel, { viewType: "ToolPanel", api: api, accessLevel: accessLevel, moduleInfo: moduleInfo })) : null,
-                moduleInfo,
-            ];
-        }
-        else {
-            return [
-                customToolPanel.name,
-                customToolPanel?.title ?? customToolPanel.name,
-                _jsx(CustomToolPanelContent, { customToolPanel: customToolPanel }),
-            ];
-        }
-    };
-    const [toolPanelName, toolPanelHeader, toolPanelContent, moduleInfo] = getToolPanelConfiguration();
-    const isMinimised = visibilityMode === 'collapsed';
-    const isConfigurable = !!moduleInfo && toolPanelName !== 'OpenFin' && toolPanelName !== 'IPushPull';
-    const isToolPanelModuleConfigurable = api.internalApi
-        .getModuleService()
-        .getModuleById(ToolPanelModuleId)
-        .isModuleEditable();
-    return (_jsx(_Fragment, { children: toolPanelContent && (_jsx(Box, { className: `twa:mt-1 ab-ToolPanel__container ab-ToolPanel__container--${toolPanelName}`, children: _jsx(PanelToolPanel, { className: `ab-ToolPanel__${toolPanelName}`, "data-name": `ab-ToolPanel__${toolPanelName}`, headerText: toolPanelHeader, disabled: !isToolPanelModuleConfigurable, onMinimiseChanged: () => {
-                    onVisibilityModeChange(isMinimised ? 'expanded' : 'collapsed');
-                }, isMinimised: isMinimised, onConfigure: isConfigurable
-                    ? () => {
-                        const maxWidth = api.internalApi
-                            .getModuleService()
-                            .getPopupMaxWidth(moduleInfo.ModuleName);
-                        const popupParams = maxWidth
-                            ? { maxWidth, source: 'Toolbar' }
-                            : { source: 'Toolbar' };
-                        api.internalApi.dispatchReduxAction(PopupRedux.PopupShowScreen(moduleInfo.ModuleName, moduleInfo.Popup, popupParams));
-                    }
-                    : null, onClose: () => api.internalApi.dispatchReduxAction(ToolPanelRedux.ToolPanelHideToolPanel(toolPanelName)), children: isMinimised ? null : toolPanelContent }) })) }));
-};

package/src/View/DataChangeHistory/buildActionColumnButton.d.ts

@@ -1,5 +0,0 @@
-import { DataChangeHistoryContext } from '../../AdaptableOptions/DataChangeHistoryOptions';
-import { AdaptableApi, AdaptableButton, DataChangeHistoryOptions } from '../../types';
-import { DataChangeHistoryData } from './dataChangeHistoryHelpers';
-export declare const buildDataChangeHistoryContext: (rowData: DataChangeHistoryData, parentAdapTableApi: AdaptableApi, onUndoChange: (changeKey: string) => void, onClearRow: (changeKey: string) => void) => DataChangeHistoryContext;
-export declare const buildChangeHistoryButtons: (options: DataChangeHistoryOptions, parentAdapTableApi: AdaptableApi, onUndoChange: (changeKey: string) => void, onClearRow: (changeKey: string) => void) => AdaptableButton<DataChangeHistoryContext>[] | null;

package/src/View/DataChangeHistory/buildActionColumnButton.js

@@ -1,74 +0,0 @@
-const STUB_ACTION_COLUMN = {
-    columnId: 'undoActionColumn',
-    actionColumnButton: [],
-};
-export const buildDataChangeHistoryContext = (rowData, parentAdapTableApi, onUndoChange, onClearRow) => {
-    const undoDataChange = () => onUndoChange(rowData.changeKey);
-    const clearRow = () => onClearRow(rowData.changeKey);
-    return {
-        actionColumn: STUB_ACTION_COLUMN,
-        primaryKeyValue: rowData.changeInfo.primaryKeyValue,
-        rowNode: undefined,
-        data: rowData,
-        ...parentAdapTableApi.internalApi.buildBaseContext(),
-        isGroupNode: false,
-        undoDataChange,
-        clearRow,
-        dataChangedInfo: rowData.changeInfo,
-        parentAdapTableApi,
-    };
-};
-export const buildChangeHistoryButtons = (options, parentAdapTableApi, onUndoChange, onClearRow) => {
-    let changeHistoryButtons = options?.changeHistoryButton;
-    if (!changeHistoryButtons ||
-        (Array.isArray(changeHistoryButtons) && changeHistoryButtons.length === 0)) {
-        return null;
-    }
-    if (!Array.isArray(changeHistoryButtons)) {
-        changeHistoryButtons = [changeHistoryButtons];
-    }
-    return changeHistoryButtons.map((actionColumnOption) => ({
-        label: (button, context) => {
-            if (typeof actionColumnOption.label !== 'function') {
-                return actionColumnOption.label;
-            }
-            return actionColumnOption.label(button, context);
-        },
-        buttonStyle: (button, context) => {
-            if (typeof actionColumnOption.buttonStyle !== 'function') {
-                return actionColumnOption.buttonStyle;
-            }
-            return actionColumnOption.buttonStyle(button, context);
-        },
-        tooltip: (button, context) => {
-            if (typeof actionColumnOption.tooltip !== 'function') {
-                return actionColumnOption.tooltip;
-            }
-            return actionColumnOption.tooltip(button, context);
-        },
-        disabled: (button, context) => {
-            if (typeof actionColumnOption.disabled !== 'function') {
-                return actionColumnOption.disabled;
-            }
-            return actionColumnOption.disabled(button, context);
-        },
-        onClick: (button, context) => {
-            if (actionColumnOption.action === 'undo') {
-                context.undoDataChange();
-            }
-            if (actionColumnOption.action === 'clear') {
-                context.clearRow();
-            }
-            if (typeof actionColumnOption.onClick === 'function') {
-                actionColumnOption.onClick(button, context);
-            }
-        },
-        hidden: (button, context) => {
-            if (typeof actionColumnOption.hidden !== 'function') {
-                return actionColumnOption.hidden;
-            }
-            return actionColumnOption.hidden(button, context);
-        },
-        icon: actionColumnOption.icon,
-    }));
-};

package/src/View/DataChangeHistory/dataChangeHistoryHelpers.d.ts

@@ -1,37 +0,0 @@
-import { IRowNode } from 'ag-grid-enterprise';
-import { CellDataChangedInfo } from '../../AdaptableState/Common/CellDataChangedInfo';
-import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
-import { AdaptableColumn } from '../../AdaptableState/Common/AdaptableColumn';
-import { AdaptableApi } from '../../types';
-export interface DataChangeHistoryData {
-    primaryKey: string;
-    changeKey: string;
-    changeTriggerLabel: string;
-    changedColumnLabel: string;
-    changeInfo: CellDataChangedInfo;
-}
-export declare const getColumnHeaderLabel: (columnId: string, mainAdaptableInstance: IAdaptable) => string;
-export declare const getChangeTriggerLabel: (changeInfo: CellDataChangedInfo) => string;
-export declare const isValidChangeHistoryLogEntry: (changeInfo: CellDataChangedInfo | undefined) => changeInfo is CellDataChangedInfo;
-export declare const mapChangeHistoryRowData: (changeHistoryLog: Record<string, CellDataChangedInfo>, mainAdaptableInstance: IAdaptable) => DataChangeHistoryData[];
-export declare const getChangeHistoryRowChangeInfo: (rowData: Partial<DataChangeHistoryData> | undefined) => CellDataChangedInfo | undefined;
-/**
- * Format an old/new value for display in the Data Change History Monitor.
- *
- * If the changed column has a `DisplayFormat` configured (via Format Column),
- * the value is run through the matching formatter so the History Log shows the
- * same rendered text the user sees in the grid (e.g. a timestamp appears as
- * `18:40:34` rather than the underlying `1751469622156`).
- *
- * If no `DisplayFormat` is scoped to the column, we fall back to `String(value)`
- * — which preserves the previous behaviour for columns whose raw value already
- * *is* the display value (e.g. plain numeric or string columns).
- *
- * Note: the `rowNode` passed here is the node captured when the change was
- * recorded. Its data may have moved on since; that only matters for
- * `CustomDisplayFormatters` that read other cells on the row — in which case
- * the formatted value reflects the current state of that row, not the state at
- * the time of the change. Any thrown error inside a formatter is swallowed and
- * the raw value is shown, so the History Monitor never crashes on stale data.
- */
-export declare const formatChangeHistoryCellValue: (value: unknown, column: AdaptableColumn | undefined, rowNode: IRowNode | null | undefined, api: AdaptableApi) => string;