@adaptabletools/adaptable 16.2.4 → 17.0.0-canary.0

package/src/parser/src/predicate/index.d.ts

@@ -0,0 +1,2 @@
+export * from './mapExpressionToQlPredicate';
+export * from './types';

package/src/parser/src/predicate/index.js

@@ -0,0 +1,2 @@
+export * from './mapExpressionToQlPredicate';
+export * from './types';

package/src/parser/src/predicate/mapExpressionToQlPredicate.d.ts

@@ -0,0 +1,2 @@
+import { QlPredicateError, QlPredicate } from './types';
+export declare function mapExpressionToQlPredicate(expression: string): QlPredicate | QlPredicateError;

package/src/parser/src/predicate/mapExpressionToQlPredicate.js

@@ -0,0 +1,88 @@
+import { isBooleanAdaptableQlFunction } from '../../../Utilities/ExpressionFunctions/booleanExpressionFunctions';
+import { getAST } from '../index';
+import { isAST_Function } from '../types';
+import { isQlLogicalOperator } from './types';
+function mapAstToQlPredicate(ast) {
+    const operator = getOperatorFromAST(ast);
+    if (!isAST_Function(ast)) {
+        return;
+    }
+    if (!operator || !isBooleanAdaptableQlFunction(operator)) {
+        throw {
+            errorMessage: `Only boolean functions are supported!`,
+        };
+    }
+    const mapArgToPlArgs = (arg) => {
+        if (typeof arg === 'object' && !Array.isArray(arg) && 'type' in arg) {
+            if (arg.type === 'COL') {
+                return [`[${arg.args[0]}]`];
+            }
+            if (arg.type === 'DATE') {
+                return `DATE("${arg.args[0]}")`;
+            }
+            return mapAstToQlPredicate(arg);
+        }
+        if (['string', 'boolean', 'number'].includes(typeof arg)) {
+            return arg;
+        }
+        if (arg && Array.isArray(arg)) {
+            return arg.map((a) => mapArgToPlArgs(a)).flat();
+        }
+        return null;
+    };
+    const args = ast.args
+        .map(mapArgToPlArgs)
+        .filter((arg) => arg !== null && arg !== undefined)
+        .flat();
+    if (!isQlLogicalOperator(operator)) {
+        if (!args[0] || typeof args[0] !== 'string' || !args[0].includes('[')) {
+            throw {
+                errorMessage: 'First Argument must be an Adaptable Column!',
+            };
+        }
+    }
+    return {
+        operator,
+        args,
+    };
+}
+export function mapExpressionToQlPredicate(expression) {
+    try {
+        if (!expression) {
+            // return a sensible default
+            return {
+                operator: 'AND',
+                args: [],
+            };
+        }
+        const ast = getAST(expression);
+        const astRootNode = ast === null || ast === void 0 ? void 0 : ast[0];
+        // TEST IS ROOT
+        if (!astRootNode || !isAST_Function(astRootNode)) {
+            throw { errorMessage: `Invalid expression: ${expression}` };
+        }
+        const operator = getOperatorFromAST(astRootNode);
+        if (!operator || !isBooleanAdaptableQlFunction(operator)) {
+            return { errorMessage: `Only boolean functions are supported!` };
+        }
+        const qlPredicate = mapAstToQlPredicate(astRootNode);
+        if (!isQlLogicalOperator(qlPredicate.operator)) {
+            return {
+                operator: 'AND',
+                args: [qlPredicate],
+            };
+        }
+        else {
+            return qlPredicate;
+        }
+    }
+    catch (err) {
+        return { errorMessage: `Unsupported expression: ${expression}` };
+    }
+}
+function getOperatorFromAST(astRootNode) {
+    if (!['INFIX', 'FUNCTION', 'COLUMN'].includes(astRootNode.metaInfo)) {
+        return undefined;
+    }
+    return astRootNode.type;
+}

package/src/parser/src/predicate/mapQlPredicateToExpression.d.ts

@@ -0,0 +1,3 @@
+import { QlPredicate } from './types';
+export declare function mapQlPredicateToExpression(predicate: QlPredicate): string;
+export declare function getQlPredicateSymbol(predicateName: string): string | undefined;

package/src/parser/src/predicate/mapQlPredicateToExpression.js

@@ -0,0 +1,109 @@
+import { isQlLogicalOperator } from './types';
+export function mapQlPredicateToExpression(predicate) {
+    if (!predicate) {
+        return '';
+    }
+    const predicateType = getPredicateType(predicate.operator);
+    const { operator, args } = predicate;
+    if (!args || args.length === 0) {
+        return operator;
+    }
+    if (operator === null || !operator) {
+        return '';
+    }
+    const operatorSymbol = getQlPredicateSymbol(operator);
+    // If a combinator with only one branch, remove the combinator.
+    if (args.length === 1 &&
+        typeof args[0] === 'object' &&
+        isQlLogicalOperator(operator)) {
+        return mapQlPredicateToExpression(args[0]);
+    }
+    let [firstArg, ...restOfArgs] = args;
+    const mappedArgs = restOfArgs
+        .filter((arg) => arg !== undefined)
+        .map((arg) => {
+        if (typeof arg === 'string') {
+            if (arg.includes('[')) {
+                return arg;
+            }
+            if (arg.includes('DATE')) {
+                return arg;
+            }
+            if (arg === 'TRUE' || arg === 'FALSE') {
+                return arg;
+            }
+            return `"${arg}"`;
+        }
+        if (typeof arg === 'object') {
+            return mapQlPredicateToExpression(arg);
+        }
+        if (typeof arg === 'boolean') {
+            return arg ? 'TRUE' : 'FALSE';
+        }
+        return arg;
+    });
+    if (typeof firstArg === 'object') {
+        firstArg = mapQlPredicateToExpression(firstArg);
+    }
+    if (predicateType === 'INFIX') {
+        if (operator === 'BETWEEN') {
+            return `${firstArg} ${operatorSymbol} (${mappedArgs})`;
+        }
+        return `${firstArg} ${operatorSymbol} ${mappedArgs.join(', ')}`;
+    }
+    return `${operatorSymbol}(${mappedArgs.join(', ')})`;
+}
+export function getQlPredicateSymbol(predicateName) {
+    switch (predicateName) {
+        case 'NOT':
+            return '!';
+        case 'EQ':
+            return '=';
+        case 'NEQ':
+            return '!=';
+        case 'LT':
+            return '<';
+        case 'LTE':
+            return '<=';
+        case 'GT':
+            return '>';
+        case 'GTE':
+            return '>=';
+        default:
+            return predicateName;
+    }
+}
+function getPredicateType(predicateName) {
+    switch (predicateName) {
+        case 'COL':
+            return 'COLUMN';
+        case 'IF':
+        case 'CASE':
+            return 'CONDITIONAL';
+        case 'NOT':
+            return 'UNARY';
+        case 'ADD':
+        case 'SUB':
+        case 'MUL':
+        case 'DIV':
+        case 'MOD':
+        case 'POW':
+        case 'OR':
+        case 'AND':
+        case 'EQ':
+        case 'NEQ':
+        case 'LT':
+        case 'LTE':
+        case 'GT':
+        case 'GTE':
+        case 'BETWEEN':
+        case 'STARTS_WITH':
+        case 'ENDS_WITH':
+        case 'CONTAINS':
+        case 'IN':
+        case 'WHERE':
+            return 'INFIX';
+        default:
+            return 'FUNCTION';
+    }
+}

package/src/parser/src/predicate/types.d.ts

@@ -0,0 +1,10 @@
+import { BooleanFunctionName } from '../../../types';
+export declare type QlPredicateError = {
+    errorMessage: string;
+};
+export interface QlPredicate {
+    operator: BooleanFunctionName;
+    args?: (QlPredicate | boolean | number | string)[];
+}
+export declare type QlLogicalOperator = 'AND' | 'OR';
+export declare const isQlLogicalOperator: (operator: string) => operator is QlLogicalOperator;

package/src/parser/src/predicate/types.js

@@ -0,0 +1 @@
+export const isQlLogicalOperator = (operator) => ['AND', 'OR'].includes(operator);

package/src/parser/src/tokenizer.js

@@ -1,14 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTokens = void 0;
-const tslib_1 = require("tslib");
 // @ts-ignore
-const parser_1 = tslib_1.__importDefault(require("./parser"));
+import parser from './parser';
 const cache = {};
 const getParser = () => {
-    return parser_1.default;
+    return parser;
 };
-function getTokens(expression) {
+export function getTokens(expression) {
     if (cache[expression]) {
         return cache[expression];
     }
@@ -29,4 +25,3 @@ function getTokens(expression) {
     cache[expression] = tokens;
     return tokens;
 }
-exports.getTokens = getTokens;

package/src/parser/src/types.d.ts

@@ -1,10 +1,12 @@
 import { BaseContext } from '../../../types';
 export declare type AST = AST_Expression[];
+export declare type PredicateType = 'COLUMN' | 'INFIX' | 'UNARY' | 'FUNCTION' | 'CONDITIONAL';
 export declare type AST_Expression = AST_Function | boolean | number | string;
 export declare type AST_Function = {
     type: string;
     args: AST_Expression[];
     range?: [number, number];
+    metaInfo?: PredicateType;
 };
 export declare type Token = {
     type: string;
@@ -80,7 +82,9 @@ export interface ExpressionFunction {
      * Whether Expression is evaluated eagerly (without handling inner AST nodes)
      */
     hasEagerEvaluation?: boolean;
+    inputs?: ExpressionFunctionInputType[] | ExpressionFunctionInputType[][];
 }
+export declare type ExpressionFunctionInputType = 'text' | 'number' | 'date' | 'boolean';
 /**
  * Categories for Expression Functions
  */
@@ -107,3 +111,4 @@ args: any[],
  * Context Object - including current RowNode and AdaptableAPI
  */
 context: ExpressionContext) => any;
+export declare const isAST_Function: (node: AST_Expression) => node is AST_Function;

package/src/parser/src/types.js

@@ -1,2 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export const isAST_Function = (node) => {
+    return (typeof (node === null || node === void 0 ? void 0 : node.type) === 'string' &&
+        Array.isArray(node === null || node === void 0 ? void 0 : node.args));
+};

package/src/parser/src/utils.js

@@ -1,12 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findPathTo = exports.walker = exports.getCurrentToken = void 0;
-function getCurrentToken(tokens, offset) {
+export function getCurrentToken(tokens, offset) {
     return (tokens.find(({ range }) => range[0] <= offset && range[1] > offset) ||
         tokens.find(({ range }) => range[1] == offset));
 }
-exports.getCurrentToken = getCurrentToken;
-function walker(node, callback) {
+export function walker(node, callback) {
     if (node == undefined ||
         typeof node === 'boolean' ||
         typeof node === 'number' ||
@@ -22,8 +18,7 @@ function walker(node, callback) {
         callback(node);
     }
 }
-exports.walker = walker;
-function findPathTo(node, offset) {
+export function findPathTo(node, offset) {
     const path = [];
     if (offset === null)
         return path;
@@ -34,4 +29,3 @@ function findPathTo(node, offset) {
     });
     return path;
 }
-exports.findPathTo = findPathTo;

package/src/renderReactRoot.js

@@ -1,8 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.renderReactRoot = exports.releaseReactWarnings = exports.captureReactWarnings = void 0;
-const tslib_1 = require("tslib");
-const ReactDOM = tslib_1.__importStar(require("react-dom"));
+import * as ReactDOM from 'react-dom';
 //@ts-ignore
 // import * as ReactDOMClient from 'react-dom/client';
 const originalConsoleError = console.error;
@@ -19,7 +15,7 @@ const doRenderReactRoot = (el, container) => {
         ReactDOM.unmountComponentAtNode(container);
     };
 };
-function captureReactWarnings() {
+export function captureReactWarnings() {
     console.error = (message, ...optionalParams) => {
         if (message &&
             typeof message === 'string' &&
@@ -30,12 +26,10 @@ function captureReactWarnings() {
         return originalConsoleError.call(console, message, ...optionalParams);
     };
 }
-exports.captureReactWarnings = captureReactWarnings;
-function releaseReactWarnings() {
+export function releaseReactWarnings() {
     console.error = originalConsoleError;
 }
-exports.releaseReactWarnings = releaseReactWarnings;
-const renderReactRoot = (el, container, supressReact18RenderWarning) => {
+export const renderReactRoot = (el, container, supressReact18RenderWarning) => {
     if (supressReact18RenderWarning) {
         captureReactWarnings();
     }
@@ -53,4 +47,3 @@ const renderReactRoot = (el, container, supressReact18RenderWarning) => {
         }
     };
 };
-exports.renderReactRoot = renderReactRoot;

package/src/theme.js

@@ -1,6 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = {
+export default {
     breakpoints: ['40em', '52em', '64em'],
     fontSizes: [
         'var(--ab-font-size-0)',

package/src/themes/index.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StaticThemes = void 0;
-const GeneralConstants_1 = require("../Utilities/Constants/GeneralConstants");
-exports.StaticThemes = [
+import { LIGHT_THEME, DARK_THEME } from '../Utilities/Constants/GeneralConstants';
+export const StaticThemes = [
     {
-        Name: GeneralConstants_1.LIGHT_THEME,
+        Name: LIGHT_THEME,
         Description: 'Light Theme',
     },
     {
-        Name: GeneralConstants_1.DARK_THEME,
+        Name: DARK_THEME,
         Description: 'Dark Theme',
     },
 ];

package/src/types.d.ts

@@ -17,7 +17,7 @@ export type { DashboardOptions, CustomToolbar, DashboardButtonContext, CustomToo
 export type { EditOptions, ValidationResult, SmartEditCustomOperation, SmartEditOperation, SmartEditOperationContext, ServerValidationContext, CellEditableContext, } from './AdaptableOptions/EditOptions';
 export type { ActionRowOptions, ActionRowButtonOptions, ActionRowFormOptions, ActionRowParamContext, ActionRowParamFieldContext, CreateActionRowFormContext, EditActionRowFormContext, ActionRowFormContext, ActionRowButtonType, ActionRowButtonConfigurationContext, ActionRowButtonsContext, SetPrimaryKeyValueContext, } from './AdaptableOptions/ActionRowOptions';
 export type { ActionColumnContext, ActionColumn, ActionColumnSettings, ActionColumnOptions, } from './AdaptableOptions/ActionColumnOptions';
-export type { ExportOptions, SystemExportDestination, SystemExportDestinations, CustomDestination, ExternalReport, PreProcessExportContext, AdaptableReportColumn, DataFormatType, ExportFormContext, ReportContext, ExportableColumnContext, } from './AdaptableOptions/ExportOptions';
+export type { ExportOptions, SystemExportDestination, SystemExportDestinations, CustomDestination, ExternalReport, PreProcessExportContext, AdaptableReportColumn, DataFormatType, ExportFormContext, ReportContext, ExportableColumnContext, ReportFileNameContext, } from './AdaptableOptions/ExportOptions';
 export type { DataImportValidationError, DataImportOptions, DataImportFileHandler, HandleImportedDataContext, DataImportValidateContext, GetPrimaryKeyValueContext, PreprocessRowDataContext, HandleImportedDataResolution, } from './AdaptableOptions/DataImportOptions';
 export type { DataSetOptions, DataSet, DataSetFormContext, } from './AdaptableOptions/DataSetOptions';
 export type { CellSummaryOptions } from './AdaptableOptions/CellSummaryOptions';
@@ -33,8 +33,8 @@ export type { OpenFinPluginOptions } from './AdaptableOptions/OpenFinPluginOptio
 export type { MasterDetailPluginOptions, DetailInitContext, } from './AdaptableOptions/MasterDetailPluginOptions';
 export type { FinsemblePluginOptions, FinsemblePluginStateOptions, } from './AdaptableOptions/FinsemblePluginOptions';
 export type { DateInputOptions } from './AdaptableOptions/DateInputOptions';
-export type { FilterOptions, FilterContext } from './AdaptableOptions/FilterOptions';
-export type { QuickSearchOptions } from './AdaptableOptions/QuickSearchOptions';
+export type { ColumnFilterOptions, ColumnFilterContext } from './AdaptableOptions/ColumnFilterOptions';
+export type { QuickSearchOptions, QuickSearchContext } from './AdaptableOptions/QuickSearchOptions';
 export type { FormatColumnOptions, CustomDisplayFormatter, CustomDisplayFormatterContext, } from './AdaptableOptions/FormatColumnOptions';
 export type { ColumnOptions, ColumnFriendlyNameContext } from './AdaptableOptions/ColumnOptions';
 export type { AdaptablePersistStateFunction, AdaptableStateFunctionConfig, AdaptableLoadStateFunction, AdaptableSaveStateFunction, AdaptableClearStateFunction, StateOptions, } from './AdaptableOptions/StateOptions';
@@ -75,7 +75,8 @@ export type { DataChangeHistoryApi } from './Api/DataChangeHistoryApi';
 export type { EntitlementApi } from './Api/EntitlementApi';
 export type { ExportApi } from './Api/ExportApi';
 export type { Fdc3Api } from './Api/Fdc3Api';
-export type { FilterApi } from './Api/FilterApi';
+export type { ColumnFilterApi } from './Api/ColumnFilterApi';
+export type { GridFilterApi } from './Api/GridFilterApi';
 export type { FinsembleApi } from './Api/FinsembleApi';
 export type { FlashingCellApi } from './Api/FlashingCellApi';
 export type { FormatColumnApi } from './Api/FormatColumnApi';
@@ -90,7 +91,7 @@ export type { OptionsApi } from './Api/OptionsApi';
 export type { PluginsApi } from './Api/PluginsApi';
 export type { PlusMinusApi } from './Api/PlusMinusApi';
 export type { PredicateApi } from './Api/PredicateApi';
-export type { QueryApi } from './Api/QueryApi';
+export type { NamedQueryApi } from './Api/NamedQueryApi';
 export type { ExpressionApi } from './Api/ExpressionApi';
 export type { QuickSearchApi } from './Api/QuickSearchApi';
 export type { ScheduleApi } from './Api/ScheduleApi';
@@ -121,8 +122,8 @@ export type { CustomToolbarConfiguredInfo } from './Api/Events/CustomToolbarConf
 export type { LiveDataChangedInfo, LiveReport } from './Api/Events/LiveDataChanged';
 export type { ChartChangedInfo, ChartingOpenState, ChartDisplayedInfo, } from './Api/Events/ChartChanged';
 export type { ActionRowSubmittedInfo, ActionRowType, CreatedActionRowInfo, EditedActionRowInfo, DeletedActionRowInfo, } from './Api/Events/ActionRowSubmitted';
-export type { FilterAppliedInfo } from './Api/Events/FilterApplied';
-export type { QueryRunInfo } from './Api/Events/QueryRun';
+export type { ColumnFilterAppliedInfo } from './Api/Events/ColumnFilterApplied';
+export type { GridFilterAppliedInfo } from './Api/Events/GridFilterApplied';
 export type { GridSortedInfo, AdaptableSortState } from './Api/Events/GridSorted';
 export type { AdaptableSearchState } from './Api/Events/AdaptableSearchState';
 export type { DataSetSelectedInfo } from './Api/Events/DataSetSelected';
@@ -176,6 +177,7 @@ export type { CustomSort, CustomSortState } from './PredefinedConfig/CustomSortS
 export type { DashboardState, DashboardTab, AdaptableCoordinate, } from './PredefinedConfig/DashboardState';
 export type { ExportState, Report, ReportData, ReportSchedule, SystemReportName, SystemReportNames, ReportRowScope, ReportColumnScope, } from './PredefinedConfig/ExportState';
 export type { ColumnFilter, ColumnFilterConfig, ColumnFilterPredicate, SystemFilterPredicateIds, SystemFilterPredicateId, } from './PredefinedConfig/Common/ColumnFilter';
+export type { GridFilter } from './PredefinedConfig/Common/GridFilter';
 export type { FormatColumn, FormatColumnState, FormatColumnRule, FormatColumnPredicate, SystemFormatColumnPredicateId, SystemFormatColumnPredicateIds, } from './PredefinedConfig/FormatColumnState';
 export type { StyledColumn, StyledColumnState, PercentBarStyle, GradientStyle, CellColorRange, ColumnComparison, CellTextOptions, CellTextOption, NumericStyledColumn, RangeValueType, SparkLineStyle, BadgeStyle, BadgeStyleDefinition, BadgeStylePredicate, SystemBadgeStylePredicateId, SystemBadgeStylePredicateIds, } from './PredefinedConfig/StyledColumnState';
 export type { FreeTextColumn, FreeTextColumnState, FreeTextStoredValue, FreeTextColumnSettings, } from './PredefinedConfig/FreeTextColumnState';
@@ -186,7 +188,7 @@ export type { Layout, LayoutState } from './PredefinedConfig/LayoutState';
 export type { OpenFinReport, OpenFinSchedule, OpenFinState } from './PredefinedConfig/OpenFinState';
 export type { PlusMinusNudge, PlusMinusState } from './PredefinedConfig/PlusMinusState';
 export type { PredefinedConfig } from './PredefinedConfig/PredefinedConfig';
-export type { QueryState, NamedQuery } from './PredefinedConfig/QueryState';
+export type { NamedQuery, NamedQueryState } from './PredefinedConfig/NamedQueryState';
 export type { QuickSearchState } from './PredefinedConfig/QuickSearchState';
 export type { ReminderSchedule, ScheduleState } from './PredefinedConfig/ScheduleState';
 export type { GridCell, CellUpdateRequest } from './PredefinedConfig/Selection/GridCell';

package/src/types.js

@@ -1,7 +1,3 @@
-"use strict";
 // Base Types
 // Expressions
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AdaptablePlugin = void 0;
-var AdaptablePlugin_1 = require("./AdaptableOptions/AdaptablePlugin");
-Object.defineProperty(exports, "AdaptablePlugin", { enumerable: true, get: function () { return AdaptablePlugin_1.AdaptablePlugin; } });
+export { AdaptablePlugin } from './AdaptableOptions/AdaptablePlugin';

package/types.js

@@ -1,4 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./src/types"), exports);
+export * from './src/types';

package/version.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "16.2.4";
+declare const _default: "17.0.0-canary.0";
 export default _default;

package/version.js

@@ -1,3 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = '16.2.4'; // PLEASE DONT UPDATE THIS!!! - will be updated at build time with the correct version
+export default '17.0.0-canary.0'; // PLEASE DONT UPDATE THIS!!! - will be updated at build time with the correct version