@adaptabletools/adaptable 23.1.0 → 24.0.0-canary.0

package/src/components/ExpressionEditor/BaseEditorInput.d.ts

@@ -1,29 +0,0 @@
-import * as React from 'react';
-import { ExpressionFunction, ExpressionFunctionMap } from '../../parser/src/types';
-import { AdaptableApi } from '../../Api/AdaptableApi';
-import { CSSProperties } from 'react';
-import { ColumnScope } from '../../types';
-interface BaseEditorInputProps {
-    type: 'main' | 'secondary';
-    value: string;
-    onChange: (value: string) => void;
-    disabled?: boolean;
-    onSelectedFunctionChange: (expressionFunction: ExpressionFunction | null) => void;
-    expressionFunctions: ExpressionFunctionMap<string>;
-    editorButtons: OperatorEditorButton[];
-    testData: any;
-    placeholder?: string;
-    isFullExpression?: boolean;
-    hideResultPreview?: boolean;
-    api: AdaptableApi;
-    style?: CSSProperties;
-    columnScope?: ColumnScope;
-}
-export interface OperatorEditorButton {
-    functionName: string;
-    data: string;
-    icon?: string;
-    text?: string;
-}
-export declare function BaseEditorInput(props: BaseEditorInputProps): React.JSX.Element;
-export {};

package/src/components/ExpressionEditor/BaseEditorInput.js

@@ -1,227 +0,0 @@
-import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import * as parser from '../../parser/src';
-import { cn } from '../../lib/utils';
-import * as React from 'react';
-import ErrorBox from '../ErrorBox';
-import { useSelectionRange } from '../utils/useSelectionRange';
-import EditorButton from './EditorButton';
-import HelpBlock from '../HelpBlock';
-import OverlayTrigger from '../OverlayTrigger';
-import SimpleButton from '../SimpleButton';
-import Textarea from '../Textarea';
-import { useEffect, useMemo } from 'react';
-import { ExpressionEvaluationError } from '../../parser/src/ExpressionEvaluationError';
-import { ButtonInfo } from '../../View/Components/Buttons/ButtonInfo';
-import { ExpressionEditorDocsLink } from '../../Utilities/Constants/DocumentationLinkConstants';
-import { Icon } from '../icons';
-import { useAdaptable } from '../../View/AdaptableContext';
-import join from '../utils/join';
-import { ExpressionFunctionDocumentation } from './ExpressionFunctionDocumentation';
-import { Tag } from '../Tag';
-import StringExtensions from '../../Utilities/Extensions/StringExtensions';
-import Radio from '../Radio';
-import { Box, Flex } from '../Flex';
-import { AdaptableFormControlTextClear } from '../../View/Components/Forms/AdaptableFormControlTextClear';
-const filterableCategories = [
-    'dates',
-    'logical',
-    'maths',
-    'strings',
-    'changes',
-    'comparison',
-    'observable',
-    'aggregation',
-    'cumulative',
-];
-const getCategoryOrder = (category) => {
-    const predefinedOrder = {
-        special: 1,
-        conditional: 2,
-        logical: 3,
-        comparison: 4,
-        strings: 5,
-        maths: 6,
-        dates: 7,
-        changes: 8,
-    };
-    return predefinedOrder[category] || 0;
-};
-const VarEditorButton = ({ className }) => {
-    const adaptable = useAdaptable();
-    const customQueryVariables = adaptable.api.optionsApi.getExpressionOptions()?.customQueryVariables;
-    if (!customQueryVariables || Object.keys(customQueryVariables).length === 0) {
-        return _jsx(_Fragment, {});
-    }
-    return (_jsx(_Fragment, { children: Object.keys(customQueryVariables).map((varOption) => {
-            const varString = `VAR('${varOption}')`;
-            return (_jsx(EditorButton, { data: varString, className: className, children: varString }, varOption));
-        }) }));
-};
-const FunctionsDropdown = ({ expressionFunctions, baseClassName }) => {
-    const [currentFunctionCategory, setCurrentFunctionCategory] = React.useState('all');
-    const dropdownRef = React.useRef(null);
-    const [overFunction, setOverFunction] = React.useState();
-    React.useEffect(() => {
-        setOverFunction(null);
-    }, [currentFunctionCategory]);
-    const groupedFunctions = React.useMemo(() => {
-        return Object.keys(expressionFunctions).reduce((acc, key) => {
-            const functionDef = expressionFunctions[key];
-            if (currentFunctionCategory !== 'all' && functionDef.category !== currentFunctionCategory) {
-                return acc;
-            }
-            if (functionDef.category) {
-                acc[functionDef.category] = {
-                    ...acc[functionDef.category],
-                    [key]: functionDef,
-                };
-            }
-            else {
-                acc.noCategory[key] = functionDef;
-            }
-            return acc;
-        }, { noCategory: {} });
-    }, [currentFunctionCategory]);
-    const orderedGroupNames = React.useMemo(() => {
-        return Object.keys(groupedFunctions).sort((first, second) => getCategoryOrder(first) - getCategoryOrder(second));
-    }, [groupedFunctions]);
-    const handleFunctionCategoryChange = React.useCallback((type) => (event) => {
-        setCurrentFunctionCategory(type);
-    }, [currentFunctionCategory]);
-    const categoryOptions = React.useMemo(() => {
-        const categoryOptions = Object.keys(expressionFunctions)
-            .reduce((acc, functionName) => {
-            const functionExpression = expressionFunctions[functionName];
-            if (!acc.includes(functionExpression.category)) {
-                acc.push(functionExpression.category);
-            }
-            return acc;
-        }, [])
-            .filter((category) => filterableCategories.includes(category))
-            .sort((first, second) => getCategoryOrder(first) - getCategoryOrder(second))
-            .map((category) => ({
-            label: StringExtensions.Humanize(category),
-            value: category,
-        }));
-        return [{ label: 'All', value: 'all' }, ...categoryOptions];
-    }, [expressionFunctions]);
-    const hidePopup = () => {
-        dropdownRef.current.hide();
-        setOverFunction(null);
-    };
-    const [searchInputValue, setSearchInputValue] = React.useState('');
-    return (_jsx(OverlayTrigger, { ref: dropdownRef, showEvent: "mouseenter", hideEvent: "mouseleave", targetOffset: 5, render: () => (_jsxs(Flex, { className: `${baseClassName}__dropdown-functions-list-wrapper twa:max-w-[60vw] twa:shadow-md twa:bg-background twa:text-foreground twa:text-3 twa:rounded-standard twa:p-3`, flexDirection: "column", onMouseLeave: () => hidePopup(), children: [_jsx(Flex, { className: "twa:md:gap-3 twa:gap-2 twa:pb-2 twa:md:justify-between twa:justify-start twa:flex-wrap twa:border-b twa:border-primarydark/30 twa:mb-2", children: categoryOptions.map((option, index) => {
-                        return (_jsx(Radio, { onFocus: (event) => {
-                                event.preventDefault();
-                                event.stopPropagation();
-                            }, onClick: handleFunctionCategoryChange(option.value), checked: currentFunctionCategory === option.value, children: option.label }, option.value));
-                    }) }), _jsxs(Flex, { className: "twa:gap-2 twa:max-h-[60vh]", flexDirection: "row", children: [_jsxs(Flex, { flexDirection: "column", className: "twa:gap-2 twa:rounded-standard", children: [_jsx(Box, { children: _jsx(AdaptableFormControlTextClear, { className: "twa:w-full", value: searchInputValue, OnTextChange: setSearchInputValue, placeholder: "Search Functions" }) }), _jsx(Flex, { className: `${baseClassName}__dropdown-functions-list twa:overflow-auto`, "data-name": "expression-dropdown-functions-list", flexDirection: "column", children: orderedGroupNames
-                                        .filter((groupName) => !!groupedFunctions[groupName])
-                                        .map((groupName) => {
-                                        const functionsInGroup = Object.keys(groupedFunctions[groupName]);
-                                        if (functionsInGroup.length === 0) {
-                                            return _jsx(React.Fragment, {}, groupName);
-                                        }
-                                        const getEditorButtonData = (functionName) => {
-                                            if (functionName === 'CASE') {
-                                                return `CASE <caseValue> WHEN <whenValue> THEN <thenValue> ELSE <defaultValue> END`;
-                                            }
-                                            if (functionName === 'TRUE' || functionName === 'FALSE') {
-                                                return functionName;
-                                            }
-                                            if (functionName === 'IF') {
-                                                return `<condition_expr> ? <consequent_expr> : <alternative_expr>`;
-                                            }
-                                            return `${functionName}()`;
-                                        };
-                                        const fns = functionsInGroup
-                                            .map((functionName) => {
-                                            if (searchInputValue &&
-                                                !functionName.toLowerCase().includes(searchInputValue.toLowerCase())) {
-                                                return null;
-                                            }
-                                            const buttonClassName = 'twa:mr-1 twa:hover:bg-accent twa:hover:text-accent-foreground';
-                                            return (_jsx(Box, { onMouseEnter: () => setOverFunction(functionName), onClick: () => hidePopup(), children: functionName === 'VAR' ? (_jsx(VarEditorButton, { className: buttonClassName }, functionName)) : (_jsx(EditorButton, { data: getEditorButtonData(functionName), className: buttonClassName, children: functionName }, functionName)) }, functionName));
-                                        })
-                                            .filter(Boolean);
-                                        return (_jsxs(Box, { className: cn('twa:mb-2 twa:mx-1', fns.length === 0 ? 'twa:hidden' : ''), children: [_jsx(Tag, { className: "twa:mb-1 twa:bg-primarylight twa:text-primary-foreground twa:w-full", children: StringExtensions.Humanize(groupName) }), fns] }, groupName));
-                                    }) })] }), _jsx(Box, { className: cn(`${baseClassName}__dropdown-functions-description `, `twa:flex-1 twa:p-2 twa:w-[600px] twa:max-w-[60vw]`, `twa:rounded-standard twa:shadow-sm twa:overflow-auto twa:h-auto`, 'twa:bg-primarylight twa:text-primary-foreground'), children: overFunction ? (_jsxs(_Fragment, { children: [_jsx(Tag, { className: "twa:bg-accent twa:text-accent-foreground", children: overFunction }), _jsx(ExpressionFunctionDocumentation, { expressionFunction: expressionFunctions[overFunction] })] })) : (_jsx(Flex, { className: "twa:size-full twa:items-center twa:justify-center twa:text-2 twa:italic", children: _jsxs("ul", { children: [_jsxs("li", { children: ["Hover over a Function to learn more", _jsx("br", {}), _jsx("br", {})] }), _jsx("li", { children: "Click a Function to add it to the Expression in the Editor" })] }) })) })] })] })), children: _jsx(SimpleButton, { "data-name": "expression-dropdown", icon: "arrow-down", iconPosition: 'end', className: "twa:mr-1", children: _jsx(Flex, { className: "twa:mr-1 twa:text-2", children: _jsx(Icon, { name: "equation" }) }) }) }));
-};
-export function BaseEditorInput(props) {
-    const { expressionFunctions, testData, style, type } = props;
-    const { ref: textAreaRefCallback, selectionStart, selectionEnd } = useSelectionRange();
-    const cursor = selectionStart === selectionEnd ? selectionStart : null;
-    let result;
-    let evaluationError;
-    let expressionError;
-    let selectedFunctionName;
-    const baseClassName = 'ab-ExpressionEditorInput';
-    const buildParserExceptionMessage = (e) => {
-        const parserExceptionSummary = 'Invalid expression is not parsable';
-        if (!e.message) {
-            return parserExceptionSummary;
-        }
-        const parserExceptionDetails = e.message;
-        return (_jsxs("details", { children: [_jsxs(Flex, { className: "twa:mb-1", as: "summary", children: [parserExceptionSummary, _jsx("i", { children: " (click for more details)" })] }), _jsx(Box, { className: "twa:ml-3 twa:italic", children: parserExceptionDetails })] }));
-    };
-    const testRowNode = useMemo(() => {
-        const firstRowNode = props.api.gridApi.getFirstRowNode();
-        if (!firstRowNode || !firstRowNode.data) {
-            return {};
-        }
-        return Object.assign(Object.create(Object.getPrototypeOf(firstRowNode)), firstRowNode);
-    }, []);
-    const scopeColumnId = useMemo(() => {
-        return props.api.columnScopeApi.getAnyColumnIdForScope(props.columnScope);
-    }, [props.columnScope]);
-    try {
-        const expr = parser.parse(props.value || '');
-        try {
-            testRowNode.data = testData;
-            const dataChangedEvent = {
-                newValue: 100,
-                oldValue: 150,
-            };
-            result = expr.evaluate({
-                node: testRowNode,
-                functions: expressionFunctions,
-                evaluateCustomQueryVariable: props.api.internalApi.getQueryLanguageService().evaluateCustomQueryVariable,
-                dataChangedEvent,
-                columnScope: scopeColumnId,
-                ...props.api.internalApi.buildBaseContext(),
-            });
-        }
-        catch (err) {
-            if (err instanceof ExpressionEvaluationError) {
-                evaluationError = err;
-            }
-            else {
-                throw err;
-            }
-        }
-        const path = parser.findPathTo(expr.ast, cursor);
-        selectedFunctionName = path[0] ? path[0].type : null;
-    }
-    catch (e) {
-        const isParserException = !!e.hash;
-        if (isParserException) {
-            expressionError = buildParserExceptionMessage(e);
-        }
-        else {
-            props.api.logWarn(`Unexpected error while evaluating '${props.value}':
-      ${e}`);
-        }
-    }
-    useEffect(() => {
-        if (cursor != undefined) {
-            props.onSelectedFunctionChange(selectedFunctionName ? expressionFunctions[selectedFunctionName] : null);
-        }
-    }, [selectedFunctionName]);
-    const operatorButtons = props.editorButtons
-        .filter((editorButtonDef) => !!expressionFunctions[editorButtonDef.functionName])
-        .map((editorButtonDef) => (_jsx(EditorButton, { data: editorButtonDef.data, icon: editorButtonDef.icon, children: !editorButtonDef.icon && (editorButtonDef.text || editorButtonDef.functionName) }, `${editorButtonDef.functionName}-operator`)));
-    const showDocumentationLink = props.api.internalApi.isDocumentationLinksDisplayed();
-    return (_jsxs(_Fragment, { children: [_jsxs(Flex, { "data-name": "expression-toolbar", className: `${baseClassName} twa:py-2 twa:mb-2 twa:mt-2 twa:flex-wrap twa:w-full`, children: [_jsxs(Flex, { className: "twa:flex-1 twa:ml-1 twa:flex-wrap", children: [_jsx(FunctionsDropdown, { expressionFunctions: expressionFunctions, baseClassName: baseClassName }), operatorButtons] }), showDocumentationLink && (_jsx(Flex, { alignItems: "flex-start", children: _jsx(ButtonInfo, { className: "twa:mr-2", tooltip: 'Learn how to use the Expression Editor', onClick: () => window.open(ExpressionEditorDocsLink, '_blank') }) }))] }), _jsx(Textarea, { "data-name": `expression-input-${type}`, ref: textAreaRefCallback, value: props.value || '', placeholder: props.placeholder || 'Create Query', disabled: props.disabled || false, className: join('ab-ExpressionEditor__textarea', `${baseClassName}__textarea`, 'twa:w-full twa:min-h-[100px] twa:p-2 twa:text-4 twa:resize-y twa:font-mono'), autoFocus: true, spellCheck: "false", onChange: (event) => {
-                    props.onChange(event.target.value);
-                }, style: style }), props.isFullExpression !== true && (_jsxs(HelpBlock, { className: "twa:my-2 twa:p-2 twa:text-3", children: ["This Expression must resolve to a ", _jsx("b", { children: "boolean " }), "(i.e. true / false) value"] })), expressionError && (_jsx(ErrorBox, { className: "twa:mt-2 twa:whitespace-pre-wrap twa:w-full", children: expressionError })), evaluationError && (_jsx(ErrorBox, { className: "twa:mt-2 twa:whitespace-pre-wrap", children: `${evaluationError.expressionFnName} ${evaluationError.message}` })), !props.hideResultPreview && result !== undefined && (_jsx(Box, { className: `${baseClassName}__editor-feedback twa:mt-2 twa:p-2 twa:rounded-standard`, "data-name": "expression-editor-feedback", children: _jsxs("pre", { className: "twa:whitespace-pre-wrap twa:m-0", children: ["Result (using test data):", ' ', _jsx("b", { className: "twa:bg-accentlight twa:text-accent twa:rounded-full twa:p-1 twa:px-2", children: JSON.stringify(result) })] }) }))] }));
-}

package/src/components/ExpressionEditor/DataTableEditor.d.ts

@@ -1,17 +0,0 @@
-import * as React from 'react';
-import { AdaptableColumnDataType } from '../../types';
-export declare const DataTableEditor: ({ fields, dataFormatter, data: initialData, type, labels, }: {
-    fields: {
-        label: string;
-        value: string;
-        dataType: AdaptableColumnDataType;
-        readOnly?: boolean;
-    }[];
-    type: string;
-    dataFormatter: (field: string) => string;
-    data: any;
-    labels?: {
-        showIds?: string;
-        filterPlaceholder?: string;
-    };
-}) => React.JSX.Element;

package/src/components/ExpressionEditor/DataTableEditor.js

@@ -1,52 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import * as React from 'react';
-import { baseClassName } from '.';
-import { CheckBox } from '../CheckBox';
-import { AdaptableFormControlTextClear } from '../../View/Components/Forms/AdaptableFormControlTextClear';
-import FormLayout, { FormRow } from '../FormLayout';
-import EditorButton from './EditorButton';
-import Input from '../Input';
-import { isValueValidDate } from '../../Utilities/Helpers/DateHelper';
-import { useAdaptable } from '../../View/AdaptableContext';
-import AdaptableInput from '../../View/Components/AdaptableInput';
-import { Flex } from '../Flex';
-export const DataTableEditor = ({ fields, dataFormatter, data: initialData, type = 'column', labels, }) => {
-    const adaptableApi = useAdaptable().api;
-    const [data, setData] = React.useState(initialData);
-    const [showColumnIds, setShowValues] = React.useState(false);
-    const [searchInputValue, setSearchInputValue] = React.useState('');
-    const getColValue = (fieldValue) => {
-        return adaptableApi.internalApi.getValueUsingField(data, fieldValue);
-    };
-    const updateColValue = (rowData, fielValue, newValue) => {
-        const updatedRowData = adaptableApi.internalApi.setValueUsingField(rowData, fielValue, newValue);
-        return { ...updatedRowData };
-    };
-    const getColDateValue = (fieldValue) => {
-        const colValue = getColValue(fieldValue);
-        return colValue && isValueValidDate(colValue)
-            ? new Date(colValue).toISOString().substr(0, 10)
-            : '';
-    };
-    const hasFriendlyNames = React.useMemo(() => {
-        return fields.some((field) => field.label !== field.value);
-    }, []);
-    return (_jsxs(Flex, { flexDirection: "column", "data-name": `expression-${type}-picker`, className: "twa:h-full", children: [_jsxs(Flex, { className: `${baseClassName}__${type}-list twa:mb-2 twa:mt-[2px]`, flexDirection: "column", alignItems: "flex-start", children: [hasFriendlyNames && (_jsx(CheckBox, { checked: showColumnIds, onChange: (checked) => setShowValues(checked), style: {
-                            float: 'right',
-                            margin: 0,
-                            paddingTop: 'var(--ab-base-space)',
-                            paddingBottom: 'var(--ab-base-space)',
-                        }, children: labels?.showIds ?? 'Show Column IDs' })), _jsx(AdaptableFormControlTextClear, { value: searchInputValue, OnTextChange: setSearchInputValue, placeholder: labels?.filterPlaceholder ?? 'Filter columns...', style: { flex: 1, marginBottom: 3 } })] }), _jsx(FormLayout, { className: "ab-ExpressionEditor__columns", gridColumnGap: "var(--ab-base-space)", gridRowGap: "var(--ab-base-space)", sizes: ['auto', '1fr'], style: { alignItems: 'stretch', overflow: 'auto' }, children: fields
-                    .filter((field) => {
-                    if (!searchInputValue) {
-                        return true;
-                    }
-                    return (field.label.includes(searchInputValue) || field.value?.includes?.(searchInputValue));
-                })
-                    .map((field) => {
-                    const label = showColumnIds ? `[${field.value}]` : field.label;
-                    return (_jsx(FormRow, { label: _jsx(EditorButton, { className: "twa:w-full twa:h-full twa:bg-primary twa:cursor-grab twa:mr-1", data: dataFormatter(field.value), "data-name": type, "data-value": field.value, icon: "drag", children: _jsx(Flex, { flexDirection: "column", alignItems: "flex-start", children: label }) }), children: field.dataType === 'number' ? (_jsx(Input, { type: "number", "data-name": `${type}-input`, "data-value": field.value, value: getColValue(field.value) ?? '', onChange: (e) => setData(updateColValue(data, field.value, Number(e.target.value))), className: "twa:w-full", disabled: field.readOnly })) : field.dataType === 'text' ? (_jsx(Input, { type: "text", "data-name": `${type}-input`, "data-value": field.value, value: getColValue(field.value) ?? '', onChange: (e) => setData(updateColValue(data, field.value, e.target.value)), className: "twa:w-full", disabled: field.readOnly })) : field.dataType === 'date' ? (_jsx(AdaptableInput, { type: "date", "data-name": `${type}-input`, "data-value": field.value, value: getColDateValue(field.value) ?? '', onChange: (e) => {
-                                setData(updateColValue(data, field.value, new Date(e.target.value)));
-                            }, className: "twa:w-full", disabled: field.readOnly })) : field.dataType === 'boolean' ? (_jsx(CheckBox, { "data-name": `${type}-input`, "data-value": field.value, checked: Boolean(getColValue(field.value)), onChange: (checked) => setData(updateColValue(data, field.value, checked)), disabled: field.readOnly })) : null }, field.label));
-                }) })] }));
-};

package/src/components/ExpressionEditor/EditorButton.d.ts

@@ -1,7 +0,0 @@
-import * as React from 'react';
-import { SimpleButtonProps } from '../SimpleButton';
-interface EditorButtonProps extends SimpleButtonProps {
-    data: string;
-}
-declare function EditorButton(props: EditorButtonProps): React.JSX.Element;
-export default EditorButton;

package/src/components/ExpressionEditor/EditorButton.js

@@ -1,35 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import SimpleButton from '../SimpleButton';
-import { useExpressionEditor } from './EditorContext';
-let dragImage;
-const DRAG_IMAGE_SRC = 'data:image/gif;base64,R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs=';
-function EditorButton(props) {
-    const { data, ...buttonProps } = props;
-    const { textAreaRef } = useExpressionEditor();
-    return (_jsx(SimpleButton, { "data-name": 'operator-or-fn', variant: "text", draggable: true, onDragStart: (event) => {
-            if (!dragImage) {
-                dragImage = new Image(0, 0);
-                dragImage.src = DRAG_IMAGE_SRC;
-            }
-            document.getSelection().empty();
-            event.dataTransfer.setData('text', data + ' ');
-            event.dataTransfer.setDragImage(dragImage, 0, 0);
-        }, onDragEnd: () => {
-            try {
-                document.getSelection()?.collapseToEnd();
-            }
-            catch (err) {
-                console.error(err);
-            }
-        }, onClick: () => {
-            textAreaRef.current?.focus();
-            try {
-                document.execCommand('insertText', false, data + ' ');
-                document.getSelection()?.collapseToEnd();
-            }
-            catch (err) {
-                console.error(err);
-            }
-        }, ...buttonProps }));
-}
-export default EditorButton;

package/src/components/ExpressionEditor/EditorContext.d.ts

@@ -1,11 +0,0 @@
-import { ExpressionFunction } from '../../types';
-export declare const ExpressionEditorContext: import("react").Context<{
-    textAreaRef: React.MutableRefObject<HTMLTextAreaElement>;
-    selectedFunction: ExpressionFunction | null;
-    setSelectedFunction: (fn: ExpressionFunction) => void;
-}>;
-export declare const useExpressionEditor: () => {
-    textAreaRef: React.MutableRefObject<HTMLTextAreaElement>;
-    selectedFunction: ExpressionFunction | null;
-    setSelectedFunction: (fn: ExpressionFunction) => void;
-};

package/src/components/ExpressionEditor/EditorContext.js

@@ -1,9 +0,0 @@
-import { createContext, useContext } from 'react';
-export const ExpressionEditorContext = createContext({
-    textAreaRef: { current: null },
-    selectedFunction: null,
-    setSelectedFunction: (_fn) => { },
-});
-export const useExpressionEditor = () => {
-    return useContext(ExpressionEditorContext);
-};

package/src/components/ExpressionEditor/EditorInput.d.ts

@@ -1,16 +0,0 @@
-import * as React from 'react';
-import { AdaptableApi } from '../../Api/AdaptableApi';
-import { AdaptableModule } from '../../AdaptableState/Common/Types';
-import { ColumnScope } from '../../AdaptableState/Common/ColumnScope';
-interface EditorInputProps {
-    type: 'boolean' | 'scalar' | 'aggregatedScalar' | 'cumulativeAggregatedScalar' | 'quantileAggregatedScalar';
-    module: AdaptableModule;
-    value: string;
-    onChange: (value: string) => void;
-    api: AdaptableApi;
-    testData: any;
-    isFullExpression?: boolean;
-    columnScope?: ColumnScope;
-}
-declare function EditorInput(props: EditorInputProps): React.JSX.Element;
-export default EditorInput;

package/src/components/ExpressionEditor/EditorInput.js

@@ -1,84 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useMemo } from 'react';
-import { BaseEditorInput } from './BaseEditorInput';
-import { editorButtonsSearch } from './editorButtonsSearch';
-import { useExpressionEditor } from './EditorContext';
-import { editorButtonsAggregatedScalar } from './editorButtonsAggregatedScalar';
-import { cumulativeAggregatedExpressionFunctions, quantileAggregatedExpressionFunctions, } from '../../Utilities/ExpressionFunctions/aggregatedScalarExpressionFunctions';
-import { editorButtonsCumulativeAggregatedScalar } from './editorButtonsCumulativeAggregatedScalar';
-import { editorButtonsQuantileAggregatedScalar } from './editorButtonsQuantileAggregatedScalar';
-function EditorInput(props) {
-    const moduleExpressionFunctions = props.api.internalApi
-        .getQueryLanguageService()
-        .getModuleExpressionFunctionsMap(props.module);
-    const getFilteredAggregatedExpressionFunctions = (availableAggregatedExpressionFunctions, type) => {
-        let filteredCollection = [];
-        if (type === 'aggregatedScalar') {
-            const excludeSet = new Set([
-                ...cumulativeAggregatedExpressionFunctions,
-                ...quantileAggregatedExpressionFunctions,
-            ]);
-            filteredCollection = Object.keys(availableAggregatedExpressionFunctions).filter((key) => cumulativeAggregatedExpressionFunctions.includes(key) ||
-                !excludeSet.has(key));
-        }
-        else {
-            const includeExpressionFunctions = type === 'cumulativeAggregatedScalar'
-                ? cumulativeAggregatedExpressionFunctions
-                : quantileAggregatedExpressionFunctions;
-            filteredCollection = Object.keys(availableAggregatedExpressionFunctions).filter((key) => includeExpressionFunctions.includes(key));
-        }
-        return filteredCollection.reduce((obj, key) => {
-            obj[key] = availableAggregatedExpressionFunctions[key];
-            return obj;
-        }, {});
-    };
-    const expressionFunctions = useMemo(() => {
-        if (props.type === 'aggregatedScalar' ||
-            props.type === 'cumulativeAggregatedScalar' ||
-            props.type === 'quantileAggregatedScalar') {
-            return getFilteredAggregatedExpressionFunctions(moduleExpressionFunctions.aggregatedScalarFunctions, props.type);
-        }
-        let booleanAndScalarFunctions = {
-            ...moduleExpressionFunctions.booleanFunctions,
-            ...moduleExpressionFunctions.scalarFunctions,
-        };
-        if (!props.columnScope) {
-            booleanAndScalarFunctions = Object.keys(booleanAndScalarFunctions)
-                .filter((key) => key !== '$SCOPE')
-                .reduce((obj, key) => {
-                obj[key] = booleanAndScalarFunctions[key];
-                return obj;
-            }, {});
-        }
-        return booleanAndScalarFunctions;
-    }, [props.type, props.columnScope]);
-    const { setSelectedFunction } = useExpressionEditor();
-    let queryName;
-    switch (props.type) {
-        case 'boolean':
-            queryName = 'Create an Expression that returns true / false';
-            break;
-        case 'scalar':
-            queryName = "Create an Expression that returns a single value of any type";
-            break;
-        case 'aggregatedScalar':
-            queryName = "Create an Expression that evaluates multiple rows and returns a value of any type";
-            break;
-        case 'cumulativeAggregatedScalar':
-            queryName = "Create a Cumulative Expression";
-            break;
-        case 'quantileAggregatedScalar':
-            queryName = "Create a Quantile Expression";
-            break;
-    }
-    return (_jsx(BaseEditorInput, { type: 'main', value: props.value, placeholder: queryName, onChange: props.onChange, onSelectedFunctionChange: setSelectedFunction, expressionFunctions: expressionFunctions, editorButtons: props.type === 'aggregatedScalar'
-            ? editorButtonsAggregatedScalar
-            : props.type === 'cumulativeAggregatedScalar'
-                ? editorButtonsCumulativeAggregatedScalar
-                : props.type === 'quantileAggregatedScalar'
-                    ? editorButtonsQuantileAggregatedScalar
-                    : editorButtonsSearch, testData: props.testData, isFullExpression: props.isFullExpression, hideResultPreview: props.type === 'aggregatedScalar' ||
-            props.type === 'cumulativeAggregatedScalar' ||
-            props.type === 'quantileAggregatedScalar', api: props.api, columnScope: props.columnScope }));
-}
-export default EditorInput;

package/src/components/ExpressionEditor/EditorInputWithWhereClause.d.ts

@@ -1,14 +0,0 @@
-import * as React from 'react';
-import { AdaptableApi } from '../../Api/AdaptableApi';
-import { AdaptableModule } from '../../AdaptableState/Common/Types';
-interface EditorInputWithWhereClauseProps {
-    type: 'observable' | 'aggregatedBoolean';
-    module: AdaptableModule;
-    value: string;
-    onChange: (value: string) => void;
-    testData: any;
-    isFullExpression?: boolean;
-    api: AdaptableApi;
-}
-declare function EditorInputWithWhereClause(props: EditorInputWithWhereClauseProps): React.JSX.Element;
-export default EditorInputWithWhereClause;

package/src/components/ExpressionEditor/EditorInputWithWhereClause.js

@@ -1,55 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState } from 'react';
-import { BaseEditorInput } from './BaseEditorInput';
-import { editorButtonsSearch } from './editorButtonsSearch';
-import useProperty from '../utils/useProperty';
-import { CapitaliseFirstLetter, IsNotNullOrEmptyOrWhiteSpace, IsNullOrEmptyOrWhiteSpace, } from '../../Utilities/Extensions/StringExtensions';
-import { editorButtonsObservable } from './editorButtonsObservable';
-import { CheckBox } from '../CheckBox';
-import { useExpressionEditor } from './EditorContext';
-import { editorButtonsAggregatedBoolean } from './editorButtonsAggregatedBoolean';
-import { Box, Flex } from '../Flex';
-function EditorInputWithWhereClause(props) {
-    const moduleExpressionFunctions = props.api.internalApi
-        .getQueryLanguageService()
-        .getModuleExpressionFunctionsMap(props.module);
-    const reactiveExpressionFns = props.type === 'observable'
-        ? moduleExpressionFunctions.observableFunctions
-        : moduleExpressionFunctions.aggregatedBooleanFunctions;
-    const whereClauseExpressionsFns = {
-        ...moduleExpressionFunctions.booleanFunctions,
-        ...moduleExpressionFunctions.scalarFunctions,
-    };
-    const [value, setValue] = useProperty(props, 'value', '', {
-        onChange: props.onChange,
-    });
-    const [reactiveValue, whereClauseValue] = value.split(' WHERE ');
-    const updateReactiveValue = (value) => {
-        let fullExpressionString = value;
-        if (IsNotNullOrEmptyOrWhiteSpace(value) && IsNotNullOrEmptyOrWhiteSpace(whereClauseValue)) {
-            fullExpressionString = `${value} WHERE ${whereClauseValue}`;
-        }
-        if (IsNullOrEmptyOrWhiteSpace(value)) {
-            setShowWhereClause(false);
-        }
-        setValue(fullExpressionString);
-    };
-    const updateWhereClauseValue = (value) => {
-        if (IsNullOrEmptyOrWhiteSpace(value)) {
-            setValue(reactiveValue);
-        }
-        else {
-            setValue(`${reactiveValue} WHERE ${value}`);
-        }
-    };
-    const { setSelectedFunction } = useExpressionEditor();
-    const [showWhereClause, setShowWhereClause] = useState(IsNotNullOrEmptyOrWhiteSpace(whereClauseValue));
-    const queryName = `${CapitaliseFirstLetter(props.type)}Query`;
-    return (_jsxs(Flex, { flexDirection: "column", alignItems: "flex-start", children: [_jsx(BaseEditorInput, { type: 'main', value: reactiveValue || '', placeholder: `Create ${queryName}`, onChange: updateReactiveValue, onSelectedFunctionChange: setSelectedFunction, expressionFunctions: reactiveExpressionFns, editorButtons: props.type === 'observable' ? editorButtonsObservable : editorButtonsAggregatedBoolean, testData: props.testData, isFullExpression: true, hideResultPreview: true, api: props.api, style: { height: '75px' } }), _jsxs(Box, { className: "twa:text-2 twa:mt-2 twa:pl-3", children: ["Add a ", _jsx("i", { children: "WHERE" }), " Clause to narrow the scope of the Query"] }), _jsx(CheckBox, { disabled: IsNullOrEmptyOrWhiteSpace(reactiveValue), checked: showWhereClause, onChange: (checked) => {
-                    setShowWhereClause(checked);
-                    if (!checked) {
-                        updateWhereClauseValue(null);
-                    }
-                }, className: "twa:pl-3 twa:items-center", children: "WHERE" }), showWhereClause && (_jsx(BaseEditorInput, { type: 'secondary', disabled: IsNullOrEmptyOrWhiteSpace(reactiveValue), value: whereClauseValue || '', placeholder: `Create BooleanQuery which narrows down the scope of the ${queryName}`, onChange: updateWhereClauseValue, onSelectedFunctionChange: setSelectedFunction, expressionFunctions: whereClauseExpressionsFns, editorButtons: editorButtonsSearch, testData: props.testData, isFullExpression: true, hideResultPreview: true, api: props.api, style: { height: '75px' } }))] }));
-}
-export default EditorInputWithWhereClause;

package/src/components/ExpressionEditor/ExpressionFunctionDocumentation.d.ts

@@ -1,7 +0,0 @@
-import { ExpressionFunction } from '../../types';
-import * as React from 'react';
-interface ExpressionFunctionDocumentationProps {
-    expressionFunction: ExpressionFunction;
-}
-export declare const ExpressionFunctionDocumentation: (props: ExpressionFunctionDocumentationProps) => React.JSX.Element;
-export {};

package/src/components/ExpressionEditor/ExpressionFunctionDocumentation.js

@@ -1,7 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Tag } from '../Tag';
-import { Box } from '../Flex';
-const signatureClassName = 'twa:m-0 twa:whitespace-pre-wrap twa:bg-primary twa:text-primary-foreground twa:rounded-standard twa:p-1 twa:inline-block';
-export const ExpressionFunctionDocumentation = (props) => {
-    return props.expressionFunction ? (_jsxs(Box, { "data-name": "expression-editor-documentation", className: "twa:my-2 twa:p-2 twa:rounded-standard twa:leading-normal", children: [props.expressionFunction.description && (_jsx(Box, { className: "twa:mb-3 twa:font-bold twa:whitespace-pre-wrap", "data-name": "expression-editor-documentation-description", children: props.expressionFunction.description })), props.expressionFunction.signatures && (_jsxs(Box, { "data-name": "expression-editor-documentation-signatures", children: [_jsx("b", { children: "Signatures" }), _jsx("ul", { className: "twa:flex twa:flex-col twa:gap-1", children: props.expressionFunction.signatures.map((signature, index) => (_jsx("li", { children: _jsx("pre", { className: signatureClassName, children: signature }) }, index))) })] })), props.expressionFunction.examples && (_jsxs(Box, { "data-name": "expression-editor-documentation-examples", children: [_jsx("b", { children: "Examples" }), _jsx("ul", { className: "twa:flex twa:flex-col twa:gap-1", children: props.expressionFunction.examples.map((example, index) => (_jsx("li", { children: _jsx("pre", { className: signatureClassName, children: example }) }, index))) })] })), props.expressionFunction.returnType && (_jsxs(Box, { "data-name": "expression-editor-documentation-examples", children: [_jsx("b", { children: "Return Type" }), _jsx(Tag, { className: "twa:bg-accentlight twa:text-accent twa:ml-3 twa:rounded-full twa:py-1", children: props.expressionFunction.returnType })] }))] })) : null;
-};

package/src/components/ExpressionEditor/ExpressionPreview.d.ts

@@ -1,7 +0,0 @@
-import * as React from 'react';
-import { AdaptableQuery } from '../../types';
-interface ExpressionPreviewProps {
-    query: AdaptableQuery;
-}
-export declare const ExpressionPreview: React.FunctionComponent<ExpressionPreviewProps>;
-export {};

package/src/components/ExpressionEditor/ExpressionPreview.js

@@ -1,16 +0,0 @@
-import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
-import * as React from 'react';
-import { useAdaptable } from '../../View/AdaptableContext';
-export const ExpressionPreview = (props) => {
-    const adaptableApi = useAdaptable().api;
-    const displayColumnFriendlyNames = adaptableApi.optionsApi.getExpressionOptions()?.displayColumnFriendlyNamesForExpressions;
-    if (!displayColumnFriendlyNames) {
-        return _jsx(_Fragment, { children: adaptableApi.expressionApi.getAdaptableQueryExpression(props.query) });
-    }
-    const expressionWithFriendlyNames = adaptableApi.expressionApi.getAdaptableQueryExpressionWithColumnFriendlyNames(props.query);
-    const strWithMarkedGroupes = expressionWithFriendlyNames.replace(/\]/gi, '],').split(',');
-    return (_jsx("div", { children: strWithMarkedGroupes.map((part, index) => {
-            const partEl = part.includes('[') ? _jsx("i", { children: part.replace(/[\[\]]/g, '') }) : part;
-            return _jsx(React.Fragment, { children: partEl }, index);
-        }) }));
-};

package/src/components/ExpressionEditor/NamedQueryContext.d.ts

@@ -1,10 +0,0 @@
-import { NamedQuery } from '../../types';
-export type ExpressionEditorNamedQuery = false | NamedQuery;
-export declare const NamedQueryContext: import("react").Context<{
-    namedQuery: ExpressionEditorNamedQuery;
-    setNamedQuery: (q: ExpressionEditorNamedQuery) => void;
-}>;
-export declare const useNamedQueryContext: () => {
-    namedQuery: ExpressionEditorNamedQuery;
-    setNamedQuery: (q: ExpressionEditorNamedQuery) => void;
-};