@adaptabletools/adaptable 18.0.17 → 18.1.0-canary.1

package/src/components/ExpressionEditor/QueryBuilder/QueryBuilderInputs.js

@@ -1,8 +1,10 @@
 import React from 'react';
 import { Box, Flex, Text } from 'rebass';
 import { getQlPredicateSymbol } from '../../../parser/src/predicate/mapQlPredicateToExpression';
+import { useAdaptable } from '../../../View/AdaptableContext';
 import AdaptableInput from '../../../View/Components/AdaptableInput';
 import { ColumnSelector } from '../../../View/Components/Selectors/ColumnSelector';
+import { FieldSelector } from '../../../View/Components/Selectors/FieldSelector';
 import { PermittedValuesSelector } from '../../../View/Components/Selectors/PermittedValuesSelector';
 import { CheckBox } from '../../CheckBox';
 import DropdownButton from '../../DropdownButton';
@@ -10,20 +12,61 @@ import { Icon } from '../../icons';
 import { InputGroup } from '../../InputGroup';
 import { Select } from '../../Select';
 import { useQueryBuilderContext } from './QueryBuilder';
-import { mapExpressionFunctionTypeToColumnDataType } from './utils';
-export const PrimitiveColumnSelector = (props) => {
-    return (React.createElement(Box, null,
-        React.createElement(ColumnSelector, { value: props.columnId, type: props.type, onChange: (columnId) => {
+import { isFieldValue, mapColumnExpressionToColumnId, mapExpressionFunctionTypeToColumnDataType, mapExpressionToFieldValue, mapFieldValueToExpression, } from './utils';
+export const PrimitiveColumnOrFieldSelector = (props) => {
+    const adaptable = useAdaptable();
+    const [type, setType] = React.useState(() => {
+        return (
+            // default to column
+            (!props.fieldOrColumn || props.fieldOrColumn.includes('[') ? 'column' : 'field')
+        );
+    });
+    const hasFields = React.useMemo(() => {
+        var _a;
+        return ((_a = adaptable.api.expressionApi.internalApi.getAvailableFields()) === null || _a === void 0 ? void 0 : _a.length) > 0;
+    }, []);
+    const hasFieldsOrValueIsField = hasFields || isFieldValue(props.fieldOrColumn);
+    let input = null;
+    if (type === 'column') {
+        const columnId = mapColumnExpressionToColumnId(props.fieldOrColumn);
+        input = (React.createElement(ColumnSelector, { value: columnId, type: props.type, onChange: (columnId) => {
                 props.onChange(`[${columnId}]`);
-            } })));
+            } }));
+    }
+    else {
+        input = (React.createElement(FieldSelector, { value: mapExpressionToFieldValue(props.fieldOrColumn), type: props.type, onChange: (fieldValue) => {
+                props.onChange(mapFieldValueToExpression(fieldValue));
+            } }));
+    }
+    const typeOptions = [
+        { label: 'Column', value: 'column', icon: 'grid' },
+        { label: 'Field', value: 'field', icon: 'column-outline' },
+    ];
+    return !hasFieldsOrValueIsField || props.hideFields ? (React.createElement(Box, null, input)) : (React.createElement(InputGroup, { Component: Flex, "data-id": "query-first-arg-wrapper" },
+        React.createElement(Select, { renderSingleValue: (value) => {
+                return React.createElement(React.Fragment, null, type === 'column' ? React.createElement(Icon, { name: "grid" }) : React.createElement(Icon, { name: "column-outline" }));
+            }, value: type, options: typeOptions, onChange: (value) => {
+                props.onChange(null);
+                setType(value);
+            } }),
+        input));
 };
 export const PrimiteValueInput = (props) => {
-    var _a, _b;
-    const [type, setType] = React.useState(() => {
+    const adaptable = useAdaptable();
+    const hasFields = React.useMemo(() => {
         var _a;
-        return typeof (props === null || props === void 0 ? void 0 : props.value) === 'string' && ((_a = props === null || props === void 0 ? void 0 : props.value) === null || _a === void 0 ? void 0 : _a.includes('['))
-            ? 'column-name'
-            : 'input-value';
+        return ((_a = adaptable.api.expressionApi.internalApi.getAvailableFields()) === null || _a === void 0 ? void 0 : _a.length) > 0;
+    }, []);
+    const hasFieldsOrValueIsField = hasFields || isFieldValue(props.value);
+    const [type, setType] = React.useState(() => {
+        var _a, _b;
+        if (typeof (props === null || props === void 0 ? void 0 : props.value) === 'string' && ((_a = props === null || props === void 0 ? void 0 : props.value) === null || _a === void 0 ? void 0 : _a.includes('['))) {
+            return 'column-name';
+        }
+        if (typeof (props === null || props === void 0 ? void 0 : props.value) === 'string' && ((_b = props === null || props === void 0 ? void 0 : props.value) === null || _b === void 0 ? void 0 : _b.includes('FIELD'))) {
+            return 'field';
+        }
+        return 'input-value';
     });
     const handleTypeChange = (newType) => {
         if (type !== newType) {
@@ -67,12 +110,18 @@ export const PrimiteValueInput = (props) => {
     };
     let editor = null;
     if (type === 'column-name') {
-        const columnId = props.value ? (_b = (_a = props === null || props === void 0 ? void 0 : props.value) === null || _a === void 0 ? void 0 : _a.replace) === null || _b === void 0 ? void 0 : _b.call(_a, '[', '').replace(']', '') : undefined;
         const abColType = mapExpressionFunctionTypeToColumnDataType(props.inputType);
-        editor = (React.createElement(PrimitiveColumnSelector, { columnId: columnId, onChange: (col) => props.onChange(col), type: abColType }));
+        editor = (React.createElement(PrimitiveColumnOrFieldSelector, { hideFields: true, fieldOrColumn: props.value, type: abColType, onChange: (columnId) => {
+                props.onChange(columnId);
+            } }));
+    }
+    else if (type === 'field') {
+        editor = (React.createElement(FieldSelector, { value: mapExpressionToFieldValue(props.value), onChange: (fieldValue) => {
+                props.onChange(mapFieldValueToExpression(fieldValue));
+            } }));
     }
     else if (!['date', 'boolean'].includes(props.inputType)) {
-        editor = (React.createElement(PermittedValuesSelector, { allowNewValues: true, value: props.value, columnId: props.lefthandColumnIdParam, onChange: (value) => {
+        editor = (React.createElement(PermittedValuesSelector, { allowNewValues: true, value: props.value, columnId: mapColumnExpressionToColumnId(props.lefthandColumnIdParam), onChange: (value) => {
                 props.onChange(value);
             } }));
     }
@@ -95,6 +144,15 @@ export const PrimiteValueInput = (props) => {
             value: 'input-value',
         },
     ];
+    if (hasFieldsOrValueIsField || type === 'field') {
+        options.push({
+            label: (React.createElement(Flex, null,
+                React.createElement(Icon, { name: "column-outline" }),
+                React.createElement(Text, { ml: 2 }, "Field"))),
+            icon: 'column-outline',
+            value: 'field',
+        });
+    }
     const typeOption = options.find((option) => option.value === type);
     return (React.createElement(InputGroup, { Component: Flex, "data-id": "query-input-wrapper", mr: 2 },
         React.createElement(Select, { renderSingleValue: (value) => {

package/src/components/ExpressionEditor/QueryBuilder/QueryPredicateBuilder.js

@@ -1,7 +1,7 @@
 import React from 'react';
 import { Draggable, Droppable } from 'react-beautiful-dnd';
 import { Box, Flex } from 'rebass';
-import { isQlLogicalOperator } from '../../../parser/src/predicate';
+import { isArgumentColumnOrField, isQlLogicalOperator, } from '../../../parser/src/predicate';
 import { mapColumnDataTypeToExpressionFunctionType } from '../../../Utilities/adaptableQlUtils';
 import { booleanExpressionFunctions } from '../../../Utilities/ExpressionFunctions/booleanExpressionFunctions';
 import { useAdaptable } from '../../../View/AdaptableContext';
@@ -9,8 +9,8 @@ import DropdownButton from '../../DropdownButton';
 import ErrorBox from '../../ErrorBox';
 import { Icon } from '../../icons';
 import SimpleButton from '../../SimpleButton';
-import { CombinatorSelector, ExpressionSelector, PrimiteValueInput, PrimitiveColumnSelector, PrimitiveMultiValueInput, } from './QueryBuilderInputs';
-import { getOperatorMatchingInputs as getFunctionMatchingInputTypes } from './utils';
+import { CombinatorSelector, ExpressionSelector, PrimiteValueInput, PrimitiveColumnOrFieldSelector, PrimitiveMultiValueInput, } from './QueryBuilderInputs';
+import { getOperatorMatchingInputs as getFunctionMatchingInputTypes, mapExpressionToFieldValue, } from './utils';
 const ITEM_HEIGHT = 40;
 const BASE_CLASS_NAME = 'ab-QueryBuilder-predicate-editor';
 const Handle = (props) => (React.createElement(Flex, Object.assign({ className: `${BASE_CLASS_NAME}__handle`, height: ITEM_HEIGHT, alignItems: "center", mr: 1 }, props),
@@ -18,8 +18,8 @@ const Handle = (props) => (React.createElement(Flex, Object.assign({ className:
 const QueryPredicateButtons = (props) => {
     return (React.createElement(React.Fragment, null,
         !props.hideAdd && (React.createElement(DropdownButton, { listMinWidth: 150, columns: ['label'], items: [
-                { label: 'Add Column Condition', onClick: () => props.onNewPredicate('filter') },
-                { label: 'Add AND / OR Group', onClick: () => props.onNewPredicate('group') },
+                { label: 'Condition', onClick: () => props.onNewPredicate('filter') },
+                { label: 'AND / OR Group', onClick: () => props.onNewPredicate('group') },
             ], variant: "text" },
             React.createElement(Icon, { name: "plus" }))),
         !props.hideDelete && (React.createElement(SimpleButton, { icon: "delete", variant: "text", onClick: () => {
@@ -96,22 +96,31 @@ const PrimitiveFunctionEditor = (props) => {
     var _a;
     // [handle] [column] [operator-dropdown] [...args] [delete-button] [plus-button]
     const adaptable = useAdaptable();
-    const [columnExpression, ...restOfArgs] = props.predicate.args;
-    const col = columnExpression;
-    let columnId = null;
-    let columnDataType = null;
+    const [columnOrFieldExpression, ...restOfArgs] = props.predicate.args;
+    const columnOrField = columnOrFieldExpression;
+    let columnOrFieldId = null;
+    let columnOrFieldDataType = null;
     let columnInputDataType = null;
     let functionInputInputDataTypes = null;
     // Thsese are the type of inputs ommiting the column
     // [[column-data-type], number, number]
     let restOfFunctionInputDataTypes = [];
-    if (col) {
-        if (typeof col !== 'string' || !col.includes('[')) {
-            return React.createElement(ErrorBox, null, "Expression must start with a column!");
+    if (columnOrField) {
+        if (!isArgumentColumnOrField(columnOrField)) {
+            return React.createElement(ErrorBox, null, "Expression must start with a column or a filed!");
         }
-        columnId = col.replace(/[\[\]]/g, '');
-        columnDataType = adaptable.api.columnApi.getColumnDataTypeForColumnId(columnId);
-        columnInputDataType = mapColumnDataTypeToExpressionFunctionType(columnDataType);
+        if (columnOrField.includes('FIELD')) {
+            // we let the full expression so we can difirienciate between column and field
+            columnOrFieldId = columnOrField;
+            const fieldValue = mapExpressionToFieldValue(columnOrField);
+            columnOrFieldDataType = adaptable.api.expressionApi.internalApi.getFieldType(fieldValue);
+        }
+        else if (columnOrField.includes('[')) {
+            columnOrFieldId = columnOrField;
+            const columnId = columnOrField.replace(/[\[\]]/g, '');
+            columnOrFieldDataType = adaptable.api.columnApi.getColumnDataTypeForColumnId(columnId);
+        }
+        columnInputDataType = mapColumnDataTypeToExpressionFunctionType(columnOrFieldDataType);
         functionInputInputDataTypes = (_a = booleanExpressionFunctions[props.predicate.operator]) === null || _a === void 0 ? void 0 : _a.inputs;
         restOfFunctionInputDataTypes = functionInputInputDataTypes
             ? getFunctionMatchingInputTypes(columnInputDataType, functionInputInputDataTypes)
@@ -128,12 +137,12 @@ const PrimitiveFunctionEditor = (props) => {
             React.createElement(Handle, Object.assign({}, provided.dragHandleProps)),
             React.createElement(Flex, { alignItems: "center", height: ITEM_HEIGHT },
                 React.createElement(Box, { mr: 2 },
-                    React.createElement(PrimitiveColumnSelector, { onChange: (colId) => {
-                            props.onChange(Object.assign(Object.assign({}, props.predicate), { args: [colId], operator: null }));
-                        }, columnId: columnId })),
-                columnId && columnDataType && (React.createElement(ExpressionSelector, { dataType: columnDataType, onExpressionChange: (operator) => {
+                    React.createElement(PrimitiveColumnOrFieldSelector, { onChange: (colOrField) => {
+                            props.onChange(Object.assign(Object.assign({}, props.predicate), { args: [colOrField], operator: null }));
+                        }, fieldOrColumn: columnOrFieldId })),
+                columnOrFieldId && columnOrFieldDataType && (React.createElement(ExpressionSelector, { dataType: columnOrFieldDataType, onExpressionChange: (operator) => {
                         let args = [props.predicate.args[0]];
-                        if (columnDataType === 'Boolean' && operator !== 'NOT') {
+                        if (columnOrFieldDataType === 'Boolean' && operator !== 'NOT') {
                             args = [props.predicate.args[0], 'TRUE'];
                         }
                         props.onChange(Object.assign(Object.assign({}, props.predicate), { operator,
@@ -142,10 +151,9 @@ const PrimitiveFunctionEditor = (props) => {
                     }, value: props.predicate.operator })),
                 React.createElement(Flex, { flex: 1, ml: 2 }, restOfFunctionInputDataTypes.map((type, index) => {
                     var _a;
-                    let value = restOfArgs[index];
                     const commonProps = {
                         key: type + index,
-                        lefthandColumnIdParam: columnId,
+                        lefthandColumnIdParam: columnOrFieldId,
                         inputType: type,
                     };
                     if (type.includes('[]')) {

package/src/components/ExpressionEditor/QueryBuilder/utils.d.ts

@@ -5,4 +5,12 @@ export declare const reorder: (predicate: QlPredicate, from: string, to: string)
 export declare const mapExpressionFunctionTypeToColumnDataType: (type: ExpressionFunctionInputType) => AdaptableColumnDataType;
 export declare const getOperatorMatchingInputs: (columnType: ExpressionFunctionInputType, inputs: ExpressionFunctionInputType[] | Array<ExpressionFunctionInputType>[]) => ExpressionFunctionInputType[];
 export declare const getFunctionsForColumnType: (dataType: AdaptableColumnDataType, availableBooleanFunctions: BooleanFunctionName[]) => BooleanFunctionName[];
-export declare const getUnsuportedExpressionFromQlPredicate: (predicate: QlPredicate | QlPredicateError) => string;
+export declare const getUnsuportedExpressionFromQlPredicate: (predicate: QlPredicate | QlPredicateError, context: {
+    supportedFields: {
+        value: string;
+    }[];
+}) => string;
+export declare const mapFieldValueToExpression: (field: string) => string;
+export declare const mapExpressionToFieldValue: (expression: string) => string;
+export declare const mapColumnExpressionToColumnId: (expression: string) => string;
+export declare const isFieldValue: (expression: string) => boolean;

package/src/components/ExpressionEditor/QueryBuilder/utils.js

@@ -45,7 +45,7 @@ export const mapExpressionFunctionTypeToColumnDataType = (type) => {
 export const getOperatorMatchingInputs = (columnType, inputs) => {
     if (Array.isArray(inputs[0])) {
         const matchingInput = inputs.find((input) => input[0] === columnType);
-        const [_, ...restOfArgs] = matchingInput;
+        const [_, ...restOfArgs] = matchingInput !== null && matchingInput !== void 0 ? matchingInput : [];
         return restOfArgs;
     }
     const [_, ...restOfArgs] = inputs;
@@ -69,10 +69,20 @@ export const getFunctionsForColumnType = (dataType, availableBooleanFunctions) =
         return (matchingInputTypes === null || matchingInputTypes === void 0 ? void 0 : matchingInputTypes[0]) === columnType;
     });
 };
-export const getUnsuportedExpressionFromQlPredicate = (predicate) => {
+export const getUnsuportedExpressionFromQlPredicate = (predicate, context) => {
+    var _a;
     if (!predicate) {
         return null;
     }
+    if (typeof predicate === 'string' && isFieldValue(predicate)) {
+        const field = mapExpressionToFieldValue(predicate);
+        if (!((_a = context.supportedFields) === null || _a === void 0 ? void 0 : _a.some((field) => (field === null || field === void 0 ? void 0 : field.value) === mapExpressionToFieldValue(predicate)))) {
+            return `Expression uses an unregistered field: "${field}"`;
+        }
+        else {
+            return null;
+        }
+    }
     if (typeof predicate === 'object' && 'errorMessage' in predicate) {
         return null;
     }
@@ -88,7 +98,7 @@ export const getUnsuportedExpressionFromQlPredicate = (predicate) => {
     }
     let firstInvalidArg = null;
     for (let arg of predicate.args) {
-        firstInvalidArg = getUnsuportedExpressionFromQlPredicate(arg);
+        firstInvalidArg = getUnsuportedExpressionFromQlPredicate(arg, context);
         if (firstInvalidArg) {
             break;
         }
@@ -98,3 +108,31 @@ export const getUnsuportedExpressionFromQlPredicate = (predicate) => {
     }
     return null;
 };
+export const mapFieldValueToExpression = (field) => `FIELD('${field}')`;
+export const mapExpressionToFieldValue = (expression) => {
+    var _a;
+    if (!expression) {
+        return '';
+    }
+    try {
+        return (_a = expression.match(/FIELD\(['"](.+)['"]\)/)) === null || _a === void 0 ? void 0 : _a[1];
+    }
+    catch (e) {
+        return '';
+    }
+};
+export const mapColumnExpressionToColumnId = (expression) => {
+    var _a;
+    if (!expression) {
+        return null;
+    }
+    try {
+        return (_a = expression.match(/\[(.+)\]/)) === null || _a === void 0 ? void 0 : _a[1];
+    }
+    catch (e) {
+        return expression;
+    }
+};
+export const isFieldValue = (expression) => {
+    return typeof expression === 'string' && expression.includes('FIELD');
+};

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

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { AdaptableApi, AdaptableColumn, AdaptableModule, NamedQuery } from '../../types';
+import { AdaptableApi, AdaptableColumn, AdaptableField, AdaptableModule, NamedQuery } from '../../types';
 export type ExpressionEditorType = 'boolean' | 'scalar' | 'observable' | 'aggregatedBoolean' | 'aggregatedScalar' | 'cumulativeAggregatedScalar' | 'quantileAggregatedScalar';
 interface ExpressionEditorProps {
     value: string;
@@ -10,6 +10,7 @@ interface ExpressionEditorProps {
         [key: string]: any;
     };
     columns: AdaptableColumn[];
+    fields?: AdaptableField[];
     namedQueries: NamedQuery[];
     allowSaveNamedQuery?: boolean;
     style?: React.CSSProperties;
@@ -18,5 +19,6 @@ interface ExpressionEditorProps {
     showQueryBuilder?: boolean;
     showExpressionEditor?: boolean;
 }
+export declare const baseClassName = "ab-ExpressionEditor";
 export declare function ExpressionEditor(props: ExpressionEditorProps): JSX.Element;
 export {};

package/src/components/ExpressionEditor/index.js

@@ -1,36 +1,29 @@
 import * as React from 'react';
-import { useState, useRef } from 'react';
+import { useRef, useState } from 'react';
 import { Box, Flex, Text } from 'rebass';
-import { CheckBox } from '../CheckBox';
-import FormLayout, { FormRow } from '../FormLayout';
-import HelpBlock from '../HelpBlock';
-import Input from '../Input';
-import EditorButton from './EditorButton';
-import AdaptableInput from '../../View/Components/AdaptableInput';
-import Radio from '../Radio';
-import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
-import EditorInputWithWhereClause from './EditorInputWithWhereClause';
-import EditorInput from './EditorInput';
-import { ExpressionEditorContext } from './EditorContext';
-import { ExpressionFunctionDocumentation } from './ExpressionFunctionDocumentation';
 import { AggregatedBooleanQueryDocsLink, AggregatedScalarQueryDocsLink, BooleanQueryDocsLink, CumulativeAggregatedScalarQueryDocsLink, ObservableQueryDocsLink, QuantileAggregatedScalarQueryDocsLink, ScalarQueryDocsLink, } from '../../Utilities/Constants/DocumentationLinkConstants';
+import { NamedQueryModuleId } from '../../Utilities/Constants/ModuleConstants';
+import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
 import StringExtensions from '../../Utilities/Extensions/StringExtensions';
+import AdaptableInput from '../../View/Components/AdaptableInput';
 import { ButtonInfo } from '../../View/Components/Buttons/ButtonInfo';
+import { CheckBox } from '../CheckBox';
 import { CodeBlock } from '../CodeBlock';
-import { useNamedQueryContext } from './NamedQueryContext';
-import { NamedQueryModuleId } from '../../Utilities/Constants/ModuleConstants';
-import { isValueValidDate } from '../../Utilities/Helpers/DateHelper';
-import { AdaptableFormControlTextClear } from '../../View/Components/Forms/AdaptableFormControlTextClear';
+import HelpBlock from '../HelpBlock';
+import Panel from '../Panel';
 import { Tabs } from '../Tabs';
+import { DataTableEditor } from './DataTableEditor';
+import { ExpressionEditorContext } from './EditorContext';
+import EditorInput from './EditorInput';
+import EditorInputWithWhereClause from './EditorInputWithWhereClause';
+import { ExpressionFunctionDocumentation } from './ExpressionFunctionDocumentation';
+import { useNamedQueryContext } from './NamedQueryContext';
+import { NamedQueryEditor } from './NamedQueryEditor';
 import { QueryBuilder } from './QueryBuilder';
+export const baseClassName = `ab-ExpressionEditor`;
 export function ExpressionEditor(props) {
     var _a, _b, _c;
     const { type, module } = props;
-    const [data, setData] = useState(props.initialData);
-    const [showColumnIds, setShowColumnIds] = useState(false);
-    const [inlineQuery, setInlineQuery] = useState(false);
-    const [showNamedQueries, setShowNamedQueries] = useState(false);
-    const baseClassName = `ab-ExpressionEditor`;
     const [selectedFunction, setSelectedFunction] = useState(null);
     const [expressionText, setExpressionText] = useState(props.value);
     const { namedQuery, setNamedQuery } = useNamedQueryContext();
@@ -39,80 +32,20 @@ export function ExpressionEditor(props) {
     const editorInput = type === 'observable' || type === 'aggregatedBoolean' ? (React.createElement(EditorInputWithWhereClause, { type: type, module: module, value: props.value, onChange: (value) => {
             setExpressionText(value);
             props.onChange(value);
-        }, testData: data, api: props.api })) : (
+        }, testData: props.initialData, api: props.api })) : (
     // 'boolean','scalar','aggregatedScalar'/'cumulativeAggregatedScalar'/'quantileAggregatedScalar'
     (React.createElement(
         EditorInput,
         { type: type, module: module, value: props.value, onChange: (value) => {
                 setExpressionText(value);
                 props.onChange(value);
-            }, testData: data, isFullExpression: props.isFullExpression, api: props.api }
+            }, testData: props.initialData, isFullExpression: props.isFullExpression, api: props.api }
     )));
+    const adaptableFields = props.api.expressionApi.internalApi.getAvailableFields();
     // currently only boolean and scalar expressions support nested calculated columns (calc cols which reference other calc cols)
     const queryableColumns = type === 'scalar' || type === 'boolean' || type === 'aggregatedScalar'
         ? props.columns
         : props.columns.filter((c) => !props.api.columnApi.isCalculatedColumn(c.columnId));
-    const getColValue = (column) => {
-        var _a;
-        return props.api.internalApi.getValueUsingField(data, (_a = column.field) !== null && _a !== void 0 ? _a : column.columnId);
-    };
-    const updateColValue = (rowData, column, newValue) => {
-        var _a;
-        const updatedRowData = props.api.internalApi.setValueUsingField(rowData, (_a = column.field) !== null && _a !== void 0 ? _a : column.columnId, newValue);
-        return Object.assign({}, updatedRowData);
-    };
-    const getColDateValue = (column) => {
-        const colValue = getColValue(column);
-        return colValue && isValueValidDate(colValue)
-            ? new Date(colValue).toISOString().substr(0, 10)
-            : '';
-    };
-    const [searchInputValue, setSearchInputValue] = React.useState('');
-    const dataTableEditor = (React.createElement(React.Fragment, null,
-        React.createElement(Flex, { className: `${baseClassName}__columns-list`, flexDirection: "column", alignItems: "start", style: { marginTop: 2 } },
-            React.createElement(CheckBox, { checked: showColumnIds, onChange: (checked) => setShowColumnIds(checked), style: {
-                    float: 'right',
-                    margin: 0,
-                    paddingTop: 'var(--ab-space-1)',
-                    paddingBottom: 'var(--ab-space-1)',
-                } }, 'Show Column IDs'),
-            React.createElement(AdaptableFormControlTextClear, { value: searchInputValue, OnTextChange: setSearchInputValue, placeholder: "Filter columns...", style: { flex: 1, marginBottom: 3 } })),
-        React.createElement(FormLayout, { className: "ab-ExpressionEditor__columns", gridColumnGap: "var(--ab-space-1)", gridRowGap: "var(--ab-space-1)", sizes: ['auto', '100px'], style: { alignItems: 'stretch' } }, queryableColumns
-            .filter((column) => {
-            if (!searchInputValue) {
-                return true;
-            }
-            return (column.columnId.includes(searchInputValue) ||
-                column.friendlyName.includes(searchInputValue));
-        })
-            .map((column) => (React.createElement(FormRow, { key: column.columnId, label: React.createElement(EditorButton, { width: "100%", height: "100%", style: {
-                    background: 'var(--ab-color-primary)',
-                    cursor: 'grab',
-                    marginRight: 'var(--ab-space-1)',
-                }, data: `[${column.columnId}]`, "data-name": "column", icon: "drag" },
-                React.createElement(Flex, { flexDirection: "column", alignItems: "start" }, showColumnIds ? `[${column.columnId}]` : column.friendlyName)) }, column.dataType === 'Number' ? (React.createElement(Input, { type: "number", "data-name": "column-input", "data-value": column.columnId, value: getColValue(column), onChange: (e) => setData(updateColValue(data, column, Number(e.target.value))), width: "100%", disabled: column.readOnly })) : column.dataType === 'String' ? (React.createElement(Input, { type: "text", "data-name": "column-input", "data-value": column.columnId, value: getColValue(column), onChange: (e) => setData(updateColValue(data, column, e.target.value)), width: "100%", disabled: column.readOnly })) : column.dataType === 'Date' ? (React.createElement(AdaptableInput, { type: "date", "data-name": "column-input", "data-value": column.columnId, value: getColDateValue(column), onChange: (e) => {
-                setData(updateColValue(data, column, new Date(e.target.value)));
-            }, style: { width: '100%' }, disabled: column.readOnly })) : column.dataType === 'Boolean' ? (React.createElement(CheckBox, { "data-name": "column-input", "data-value": column.columnId, checked: getColValue(column), onChange: (checked) => setData(updateColValue(data, column, checked)), disabled: column.readOnly })) : null))))));
-    const namedQueries = (React.createElement(Flex, { flexDirection: "column", alignItems: "start", style: { marginTop: 2 } },
-        React.createElement(CheckBox, { checked: showColumnIds, onChange: (checked) => setShowColumnIds(checked) }, "Show Column IDs"),
-        React.createElement(CheckBox, { checked: inlineQuery, onChange: (checked) => setInlineQuery(checked) }, "Inline Query"),
-        props.namedQueries.map((namedQuery) => (React.createElement(Flex, { key: namedQuery.Uuid, flexDirection: "column", alignItems: "start", style: {
-                padding: 3,
-                marginTop: 'var(--ab-space-2)',
-                marginBottom: 'var(--ab-space-2)',
-                width: '100%',
-            }, backgroundColor: "primarylight" },
-            ' ',
-            React.createElement(EditorButton, { width: "100%", height: "100%", style: {
-                    background: 'var(--ab-color-primary)',
-                    cursor: 'grab',
-                }, data: inlineQuery ? namedQuery.BooleanExpression : `QUERY("${namedQuery.Name}")`, "data-name": "column", icon: "drag" },
-                React.createElement(Flex, { flexDirection: "column", alignItems: "start" }, namedQuery.Name)),
-            React.createElement(Flex, { alignItems: "start", style: {
-                    padding: 5,
-                } }, showColumnIds
-                ? namedQuery.BooleanExpression
-                : props.api.expressionApi.getAdaptableQueryExpressionWithColumnFriendlyNames(namedQuery)))))));
     const showDocumentationLinks = props.api.internalApi.isDocumentationLinksDisplayed();
     // @Bogdan i did this to be sure but i think we can get rid of this as the button does the same (and better IMO)
     const showNamedQueryStuff = false;
@@ -154,19 +87,59 @@ export function ExpressionEditor(props) {
                     StringExtensions.IsNullOrEmpty(expressionText === null || expressionText === void 0 ? void 0 : expressionText.trim()) && renderQueryHints(type),
                     showDocumentationLinks && (React.createElement(HelpBlock, { "data-name": "query-documentation", mt: 2, mb: 2, fontSize: 3 },
                         React.createElement(ButtonInfo, { mr: 2, onClick: () => window.open(queryDocumentationLink, '_blank') }),
-                        "See ",
-                        StringExtensions.CapitaliseFirstLetter(type),
-                        " Query documentation for more details and examples")),
+                        "See documentation for more details and examples")),
                     React.createElement(Box, { flex: 1 }),
                     showNamedQueryStuff && saveAsNamedQueryElement),
-                React.createElement(Box, { className: `${baseClassName}__column-picker`, "data-name": "expression-column-picker", pb: 2, paddingLeft: 2, pr: 2 },
-                    ArrayExtensions.IsNotNullOrEmpty(props.namedQueries) && (React.createElement(Flex, { flexDirection: "row", alignItems: "start", p: 1, mt: 2, backgroundColor: "primarylight" },
-                        React.createElement(Radio, { checked: !showNamedQueries, onChange: (checked) => setShowNamedQueries(!checked), style: { marginRight: 10 } }, "Columns"),
-                        React.createElement(Radio, { checked: showNamedQueries, onChange: (checked) => setShowNamedQueries(checked), style: { marginLeft: 10, whiteSpace: 'nowrap' } }, "Named Queries"))),
-                    showNamedQueries ? React.createElement("div", null, namedQueries) : React.createElement("div", null, dataTableEditor))))));
+                React.createElement(Box, { className: `${baseClassName}__sidebar`, "data-name": "expression-sidebar", pb: 2, paddingLeft: 2, pr: 2 },
+                    React.createElement(Panel, { bodyProps: { style: { height: '100%' } }, style: { height: '100%' } },
+                        React.createElement(Tabs, { style: { height: '100%' }, variant: "" },
+                            React.createElement(Tabs.Tab, { value: "column" }, "Columns"),
+                            React.createElement(Tabs.Tab, { value: "field" }, "Fields"),
+                            React.createElement(Tabs.Tab, { value: "named-query" }, "Named Queries"),
+                            React.createElement(Tabs.Content, { flex: 1, style: { height: '100%' } },
+                                React.createElement(DataTableEditor, { type: "column", dataFormatter: (value) => `[${value}]`, fields: queryableColumns.map((column) => ({
+                                        label: column.friendlyName,
+                                        value: column.columnId,
+                                        dataType: column.dataType,
+                                        readOnly: column.readOnly,
+                                    })), data: props.initialData })),
+                            React.createElement(Tabs.Content, null, adaptableFields && adaptableFields.length > 0 ? (React.createElement(DataTableEditor, { type: "field", labels: {
+                                    showIds: 'Show Field path',
+                                    filterPlaceholder: 'Filter fields...',
+                                }, dataFormatter: (value) => `FIELD("${value}")`, data: props.initialData, fields: adaptableFields === null || adaptableFields === void 0 ? void 0 : adaptableFields.map((field) => ({
+                                    label: field.label,
+                                    value: field.name,
+                                    dataType: field.dataType,
+                                    readOnly: true,
+                                })) })) : (React.createElement(Text, { p: 2 }, "No Data Fields provided"))),
+                            React.createElement(Tabs.Content, null, ArrayExtensions.IsNullOrEmpty(props.namedQueries) ? (React.createElement("div", null,
+                                React.createElement(Text, { p: 2 }, "No Named Queries defined"),
+                                React.createElement(Text, { fontSize: 2, padding: 2, p: 2 },
+                                    "Named Queries are saved Expressions which can be referenced in other Expressions using the ",
+                                    React.createElement("i", null, "QUERY"),
+                                    " keyword",
+                                    ' '))) : (React.createElement(NamedQueryEditor, { namedQueries: props.namedQueries }))))))))));
     const queryBuilderElement = (React.createElement(QueryBuilder, { module: module, query: expressionText, onChange: (query) => {
             setExpressionText(query);
             props.onChange(query);
+        }, getFields: (type) => {
+            return props.fields
+                .filter((field) => {
+                if (!type) {
+                    return (field.dataType === 'String' ||
+                        field.dataType === 'Number' ||
+                        field.dataType === 'Boolean' ||
+                        field.dataType === 'Date');
+                }
+                else {
+                    return field.dataType === type;
+                }
+            })
+                .map((field) => ({
+                value: field.name,
+                label: field.label,
+                type: field.dataType,
+            }));
         }, getColumns: (type) => {
             return props.columns
                 .filter((column) => {
@@ -198,7 +171,7 @@ export function ExpressionEditor(props) {
         } }, (() => {
         switch (true) {
             case showQueryBuilder && showExpressionEditor:
-                return (React.createElement(Tabs, { mb: 2, p: 2, minHeight: 0, flex: 1 },
+                return (React.createElement(Tabs, { "data-name": "editor-selector-tabs", mb: 2, p: 2, minHeight: 0, flex: 1 },
                     React.createElement(Tabs.Tab, { value: "editor" }, "Expression Editor"),
                     React.createElement(Tabs.Tab, { value: "ui" }, "Query Builder"),
                     React.createElement(Tabs.Content, null, editorElement),

package/src/components/Input/NumberInput.d.ts

@@ -2,9 +2,10 @@ import * as React from 'react';
 import { InputProps } from './index';
 export type NumberInputProps = {
     onChange: (value: number) => void;
+    noArrows?: boolean;
 } & Omit<InputProps, 'onChange'>;
 /**
  * This component allows - and empty values as intermediery values
  * it calls change only with valid numeric values
  */
-export declare const NumberInput: React.FunctionComponent<NumberInputProps>;
+export declare const NumberInput: React.ForwardRefExoticComponent<Pick<NumberInputProps, "children" | "size" | "name" | "tabIndex" | "color" | "style" | "cite" | "data" | "form" | "label" | "p" | "slot" | "span" | "summary" | "title" | "pattern" | "start" | "hidden" | "content" | "default" | "flex" | "wrap" | "open" | "padding" | "multiple" | "disabled" | "checked" | "download" | "list" | "order" | "target" | "rows" | "src" | "className" | "onTransitionEnd" | "defaultChecked" | "defaultValue" | "suppressContentEditableWarning" | "suppressHydrationWarning" | "accessKey" | "contentEditable" | "contextMenu" | "dir" | "draggable" | "id" | "lang" | "placeholder" | "spellCheck" | "translate" | "radioGroup" | "role" | "about" | "datatype" | "inlist" | "prefix" | "property" | "resource" | "typeof" | "vocab" | "autoCapitalize" | "autoCorrect" | "autoSave" | "itemProp" | "itemScope" | "itemType" | "itemID" | "itemRef" | "results" | "security" | "unselectable" | "inputMode" | "is" | "aria-activedescendant" | "aria-atomic" | "aria-autocomplete" | "aria-busy" | "aria-checked" | "aria-colcount" | "aria-colindex" | "aria-colspan" | "aria-controls" | "aria-current" | "aria-describedby" | "aria-details" | "aria-disabled" | "aria-dropeffect" | "aria-errormessage" | "aria-expanded" | "aria-flowto" | "aria-grabbed" | "aria-haspopup" | "aria-hidden" | "aria-invalid" | "aria-keyshortcuts" | "aria-label" | "aria-labelledby" | "aria-level" | "aria-live" | "aria-modal" | "aria-multiline" | "aria-multiselectable" | "aria-orientation" | "aria-owns" | "aria-placeholder" | "aria-posinset" | "aria-pressed" | "aria-readonly" | "aria-relevant" | "aria-required" | "aria-roledescription" | "aria-rowcount" | "aria-rowindex" | "aria-rowspan" | "aria-selected" | "aria-setsize" | "aria-sort" | "aria-valuemax" | "aria-valuemin" | "aria-valuenow" | "aria-valuetext" | "dangerouslySetInnerHTML" | "onCopy" | "onCopyCapture" | "onCut" | "onCutCapture" | "onPaste" | "onPasteCapture" | "onCompositionEnd" | "onCompositionEndCapture" | "onCompositionStart" | "onCompositionStartCapture" | "onCompositionUpdate" | "onCompositionUpdateCapture" | "onFocus" | "onFocusCapture" | "onBlur" | "onBlurCapture" | "onChange" | "onChangeCapture" | "onBeforeInput" | "onBeforeInputCapture" | "onInput" | "onInputCapture" | "onReset" | "onResetCapture" | "onSubmit" | "onSubmitCapture" | "onInvalid" | "onInvalidCapture" | "onLoad" | "onLoadCapture" | "onError" | "onErrorCapture" | "onKeyDown" | "onKeyDownCapture" | "onKeyPress" | "onKeyPressCapture" | "onKeyUp" | "onKeyUpCapture" | "onAbort" | "onAbortCapture" | "onCanPlay" | "onCanPlayCapture" | "onCanPlayThrough" | "onCanPlayThroughCapture" | "onDurationChange" | "onDurationChangeCapture" | "onEmptied" | "onEmptiedCapture" | "onEncrypted" | "onEncryptedCapture" | "onEnded" | "onEndedCapture" | "onLoadedData" | "onLoadedDataCapture" | "onLoadedMetadata" | "onLoadedMetadataCapture" | "onLoadStart" | "onLoadStartCapture" | "onPause" | "onPauseCapture" | "onPlay" | "onPlayCapture" | "onPlaying" | "onPlayingCapture" | "onProgress" | "onProgressCapture" | "onRateChange" | "onRateChangeCapture" | "onSeeked" | "onSeekedCapture" | "onSeeking" | "onSeekingCapture" | "onStalled" | "onStalledCapture" | "onSuspend" | "onSuspendCapture" | "onTimeUpdate" | "onTimeUpdateCapture" | "onVolumeChange" | "onVolumeChangeCapture" | "onWaiting" | "onWaitingCapture" | "onAuxClick" | "onAuxClickCapture" | "onClick" | "onClickCapture" | "onContextMenu" | "onContextMenuCapture" | "onDoubleClick" | "onDoubleClickCapture" | "onDrag" | "onDragCapture" | "onDragEnd" | "onDragEndCapture" | "onDragEnter" | "onDragEnterCapture" | "onDragExit" | "onDragExitCapture" | "onDragLeave" | "onDragLeaveCapture" | "onDragOver" | "onDragOverCapture" | "onDragStart" | "onDragStartCapture" | "onDrop" | "onDropCapture" | "onMouseDown" | "onMouseDownCapture" | "onMouseEnter" | "onMouseLeave" | "onMouseMove" | "onMouseMoveCapture" | "onMouseOut" | "onMouseOutCapture" | "onMouseOver" | "onMouseOverCapture" | "onMouseUp" | "onMouseUpCapture" | "onSelect" | "onSelectCapture" | "onTouchCancel" | "onTouchCancelCapture" | "onTouchEnd" | "onTouchEndCapture" | "onTouchMove" | "onTouchMoveCapture" | "onTouchStart" | "onTouchStartCapture" | "onPointerDown" | "onPointerDownCapture" | "onPointerMove" | "onPointerMoveCapture" | "onPointerUp" | "onPointerUpCapture" | "onPointerCancel" | "onPointerCancelCapture" | "onPointerEnter" | "onPointerEnterCapture" | "onPointerLeave" | "onPointerLeaveCapture" | "onPointerOver" | "onPointerOverCapture" | "onPointerOut" | "onPointerOutCapture" | "onGotPointerCapture" | "onGotPointerCaptureCapture" | "onLostPointerCapture" | "onLostPointerCaptureCapture" | "onScroll" | "onScrollCapture" | "onWheel" | "onWheelCapture" | "onAnimationStart" | "onAnimationStartCapture" | "onAnimationEnd" | "onAnimationEndCapture" | "onAnimationIteration" | "onAnimationIterationCapture" | "onTransitionEndCapture" | "opacity" | "value" | "step" | "sizes" | "variant" | "tx" | "as" | "css" | "key" | "m" | "margin" | "mt" | "marginTop" | "mr" | "marginRight" | "mb" | "marginBottom" | "ml" | "marginLeft" | "mx" | "marginX" | "my" | "marginY" | "pt" | "paddingTop" | "pr" | "paddingRight" | "pb" | "paddingBottom" | "pl" | "paddingLeft" | "px" | "paddingX" | "py" | "paddingY" | "width" | "height" | "minWidth" | "minHeight" | "maxWidth" | "maxHeight" | "display" | "verticalAlign" | "overflow" | "overflowX" | "overflowY" | "fontFamily" | "fontSize" | "fontWeight" | "lineHeight" | "letterSpacing" | "fontStyle" | "textAlign" | "bg" | "backgroundColor" | "alignItems" | "alignContent" | "justifyItems" | "justifyContent" | "flexWrap" | "flexDirection" | "flexGrow" | "flexShrink" | "flexBasis" | "justifySelf" | "alignSelf" | "sx" | "accept" | "acceptCharset" | "action" | "allowFullScreen" | "allowTransparency" | "alt" | "async" | "autoComplete" | "autoFocus" | "autoPlay" | "capture" | "cellPadding" | "cellSpacing" | "charSet" | "challenge" | "classID" | "cols" | "colSpan" | "controls" | "coords" | "crossOrigin" | "dateTime" | "defer" | "encType" | "formAction" | "formEncType" | "formMethod" | "formNoValidate" | "formTarget" | "frameBorder" | "headers" | "high" | "href" | "hrefLang" | "htmlFor" | "httpEquiv" | "integrity" | "keyParams" | "keyType" | "kind" | "loop" | "low" | "manifest" | "marginHeight" | "marginWidth" | "max" | "maxLength" | "media" | "mediaGroup" | "method" | "min" | "minLength" | "muted" | "nonce" | "noValidate" | "optimum" | "playsInline" | "poster" | "preload" | "readOnly" | "rel" | "required" | "reversed" | "rowSpan" | "sandbox" | "scope" | "scoped" | "scrolling" | "seamless" | "selected" | "shape" | "srcDoc" | "srcLang" | "srcSet" | "type" | "useMap" | "wmode" | "noArrows"> & React.RefAttributes<HTMLInputElement>>;

package/src/components/Input/NumberInput.js

@@ -1,10 +1,12 @@
+import { __rest } from "tslib";
 import * as React from 'react';
-import Input from './index';
+import Input, { baseClassName } from './index';
+import join from '../utils/join';
 /**
  * This component allows - and empty values as intermediery values
  * it calls change only with valid numeric values
  */
-export const NumberInput = (props) => {
+export const NumberInput = React.forwardRef((props, ref) => {
     const [value, setValue] = React.useState(() => {
         var _a;
         // awlays controlled
@@ -37,5 +39,6 @@ export const NumberInput = (props) => {
             setValue(props.value);
         }
     }, [props.value, value]);
-    return React.createElement(Input, Object.assign({}, props, { value: value, onBlur: handleBlur, onChange: handleChange }));
-};
+    const { noArrows } = props, restOfProps = __rest(props, ["noArrows"]);
+    return (React.createElement(Input, Object.assign({}, restOfProps, { ref: ref, className: join(noArrows ? `${baseClassName}--no-arrows` : '', props.className), value: value, onBlur: handleBlur, onChange: handleChange })));
+});