@vuu-ui/vuu-table-extras 2.1.19-beta.2 → 2.1.19-beta.3

package/src/column-expression-input/column-function-descriptors.js

@@ -1,281 +0,0 @@
-const columnFunctionDescriptors = [
-    {
-        accepts: [
-            "boolean"
-        ],
-        description: "Applies boolean and operator across supplied parameters to returns a single boolean result",
-        example: {
-            expression: 'and(ccy="EUR",quantity=0)',
-            result: "true | false"
-        },
-        name: "and",
-        params: {
-            description: "( boolean, [ boolean* ] )"
-        },
-        type: "boolean"
-    },
-    {
-        accepts: "string",
-        description: "Returns multiple string values as a single joined string. Arguments may be string literal values, string columns or other string expressions. Non string arguments may also be included, these will be converted to strings.",
-        example: {
-            expression: 'concatenate("example", "-test")',
-            result: '"example-test"'
-        },
-        name: "concatenate",
-        params: {
-            description: "( string, string, [ string* ] )"
-        },
-        type: "string"
-    },
-    {
-        accepts: [
-            "string",
-            "string"
-        ],
-        description: "Tests a string value to determine whether it contains a given substring. Accepts two arguments: source text and target substring. Returns true if <source text> contains one or more occurrences of <target subscring>",
-        example: {
-            expression: 'contains("Royal Bank of Scotland", "bank")',
-            result: "true"
-        },
-        name: "contains",
-        params: {
-            description: "( string )"
-        },
-        type: "boolean"
-    },
-    {
-        accepts: [
-            "string",
-            "number"
-        ],
-        description: "Returns the leftmost <number> characters from <string>. First argument may be a string literal, string column or other string expression.",
-        example: {
-            expression: 'left("USD Benchmark Report", 3)',
-            result: '"USD"'
-        },
-        name: "left",
-        params: {
-            count: 2,
-            description: "( string, number )"
-        },
-        type: "string"
-    },
-    {
-        accepts: "string",
-        description: "Returns the number of characters in <string>. Argument may be a string literal, string column or other string expression.",
-        example: {
-            expression: 'len("example")',
-            result: "7"
-        },
-        name: "len",
-        params: {
-            description: "(string)"
-        },
-        type: "number"
-    },
-    {
-        accepts: "string",
-        description: "Convert a string value to lowercase. Argument may be a string column or other string expression.",
-        example: {
-            expression: 'lower("examPLE")',
-            result: '"example"'
-        },
-        name: "lower",
-        params: {
-            description: "( string )"
-        },
-        type: "string"
-    },
-    {
-        accepts: [
-            "boolean"
-        ],
-        description: "Applies boolean or operator across supplied parameters to returns a single boolean result",
-        example: {
-            expression: 'or(status="cancelled",quantity=0)',
-            result: "true | false"
-        },
-        name: "or",
-        params: {
-            description: "( boolean, [ boolean* ] )"
-        },
-        type: "boolean"
-    },
-    {
-        accepts: "string",
-        description: "Convert a string value to uppercase. Argument may be a string column or other string expression.",
-        example: {
-            expression: 'upper("example")',
-            result: '"EXAMPLE"'
-        },
-        name: "upper",
-        params: {
-            description: "( string )"
-        },
-        type: "string"
-    },
-    {
-        accepts: [
-            "string",
-            "number"
-        ],
-        description: "Returns the rightmost <number> characters from <string>. First argument may be a string literal, string column or other string expression.",
-        example: {
-            expression: "blah",
-            result: "blah"
-        },
-        name: "right",
-        params: {
-            description: "( string )"
-        },
-        type: "string"
-    },
-    {
-        accepts: [
-            "string",
-            "string",
-            "string"
-        ],
-        description: "Replace characters within a string. Accepts three arguments: source text, text to replace and replacement text. Returns a copy of <source text> with any occurrences of <text to replace> replaced by <replacement text>",
-        example: {
-            expression: "blah",
-            result: "blah"
-        },
-        name: "replace",
-        params: {
-            description: "( string )"
-        },
-        type: "string"
-    },
-    {
-        accepts: "number",
-        description: "Converts a number to a string.",
-        example: {
-            expression: "blah",
-            result: "blah"
-        },
-        name: "text",
-        params: {
-            description: "( string )"
-        },
-        type: "string"
-    },
-    {
-        accepts: "string",
-        description: "Tests a string value to determine whether it starts with a given substring. Accepts two arguments: source text and target substring. Returns true if <source text> starts with <target subscring>.",
-        example: {
-            expression: "blah",
-            result: "blah"
-        },
-        name: "starts",
-        params: {
-            description: "( string )"
-        },
-        type: "boolean"
-    },
-    {
-        accepts: "string",
-        description: "Tests a string value to determine whether it ends with a given substring. Accepts two arguments: source text and target substring. Returns true if <source text> ends with <target subscring>.",
-        example: {
-            expression: "blah",
-            result: "blah"
-        },
-        name: "ends",
-        params: {
-            description: "( string )"
-        },
-        type: "boolean"
-    },
-    {
-        accepts: "number",
-        description: "blah",
-        example: {
-            expression: "blah",
-            result: "blah"
-        },
-        name: "min",
-        params: {
-            description: "( string )"
-        },
-        type: "number"
-    },
-    {
-        accepts: "number",
-        description: "blah",
-        example: {
-            expression: "blah",
-            result: "blah"
-        },
-        name: "max",
-        params: {
-            description: "( string )"
-        },
-        type: "number"
-    },
-    {
-        accepts: "number",
-        description: "blah",
-        example: {
-            expression: "blah",
-            result: "blah"
-        },
-        name: "sum",
-        params: {
-            description: "( string )"
-        },
-        type: "number"
-    },
-    {
-        accepts: "number",
-        description: "blah",
-        example: {
-            expression: "blah",
-            result: "blah"
-        },
-        name: "round",
-        params: {
-            description: "( string )"
-        },
-        type: "number"
-    },
-    {
-        accepts: "any",
-        description: "blah",
-        example: {
-            expression: "blah",
-            result: "blah"
-        },
-        name: "or",
-        params: {
-            description: "( string )"
-        },
-        type: "boolean"
-    },
-    {
-        accepts: "any",
-        description: "blah",
-        example: {
-            expression: "blah",
-            result: "blah"
-        },
-        name: "and",
-        params: {
-            description: "( string )"
-        },
-        type: "boolean"
-    },
-    {
-        accepts: "any",
-        description: "Return one of two possible result values, depending on the evaluation of a filter expression. If <filterExpression> resolves to true, result is <expression1>, otherwise <expression2>. ",
-        example: {
-            expression: "blah",
-            result: "blah"
-        },
-        name: "if",
-        params: {
-            description: "( filterExpression, expression1, expression 2)"
-        },
-        type: "variable"
-    }
-];
-export { columnFunctionDescriptors };

package/src/column-expression-input/column-language-parser/ColumnExpressionLanguage.js

@@ -1,18 +0,0 @@
-import { LRLanguage, LanguageSupport, styleTags, tags } from "@vuu-ui/vuu-codemirror";
-import { parser } from "./generated/column-parser.js";
-const columnExpressionLanguage = LRLanguage.define({
-    name: "VuuColumnExpression",
-    parser: parser.configure({
-        props: [
-            styleTags({
-                Column: tags.attributeValue,
-                Function: tags.variableName,
-                String: tags.string,
-                Or: tags.emphasis,
-                Operator: tags.operator
-            })
-        ]
-    })
-});
-const columnExpressionLanguageSupport = ()=>new LanguageSupport(columnExpressionLanguage);
-export { columnExpressionLanguageSupport };

package/src/column-expression-input/column-language-parser/ColumnExpressionTreeWalker.js

@@ -1,381 +0,0 @@
-class LiteralExpressionImpl {
-    type;
-    value;
-    constructor(value){
-        this.value = value;
-        switch(typeof value){
-            case "boolean":
-                this.type = "booleanLiteralExpression";
-                break;
-            case "number":
-                this.type = "numericLiteralExpression";
-                break;
-            default:
-                this.type = "stringLiteralExpression";
-        }
-    }
-    toJSON() {
-        return {
-            type: this.type,
-            value: this.value
-        };
-    }
-}
-class ColumnExpressionImpl {
-    type = "colExpression";
-    column;
-    constructor(columnName){
-        this.column = columnName;
-    }
-    toJSON() {
-        return {
-            type: this.type,
-            column: this.column
-        };
-    }
-}
-class ArithmeticExpressionImpl {
-    #expressions = [
-        {
-            type: "unknown"
-        },
-        {
-            type: "unknown"
-        }
-    ];
-    #op;
-    type = "arithmeticExpression";
-    constructor(op = "unknown"){
-        this.#op = op;
-    }
-    get op() {
-        return this.#op;
-    }
-    set op(op) {
-        this.#op = op;
-    }
-    get expressions() {
-        return this.#expressions;
-    }
-    toJSON() {
-        return {
-            type: this.type,
-            op: this.#op,
-            expressions: this.#expressions
-        };
-    }
-}
-class CallExpressionImpl {
-    #expressions = [];
-    functionName;
-    type = "callExpression";
-    constructor(functionName){
-        this.functionName = functionName;
-    }
-    get expressions() {
-        return this.#expressions;
-    }
-    get arguments() {
-        return this.#expressions;
-    }
-    toJSON() {
-        return {
-            type: this.type,
-            functionName: this.functionName,
-            arguments: this.#expressions.map((e)=>e.toJSON?.())
-        };
-    }
-}
-class RelationalExpressionImpl {
-    #expressions = [
-        {
-            type: "unknown"
-        },
-        {
-            type: "unknown"
-        }
-    ];
-    #op = "unknown";
-    type = "relationalExpression";
-    get op() {
-        return this.#op;
-    }
-    set op(op) {
-        this.#op = op;
-    }
-    get expressions() {
-        return this.#expressions;
-    }
-    toJSON() {
-        return {
-            type: this.type,
-            op: this.#op,
-            expressions: this.#expressions
-        };
-    }
-}
-class BooleanConditionImp {
-    #expressions = [
-        {
-            type: "unknown"
-        },
-        {
-            type: "unknown"
-        }
-    ];
-    #op;
-    type = "booleanCondition";
-    constructor(booleanOperator){
-        this.#op = booleanOperator;
-    }
-    get op() {
-        return this.#op;
-    }
-    get expressions() {
-        return this.#expressions;
-    }
-    toJSON() {
-        return {
-            type: this.type,
-            op: this.#op,
-            expressions: this.#expressions.map((e)=>e.toJSON?.())
-        };
-    }
-}
-class ConditionalExpressionImpl {
-    #expressions;
-    type = "conditionalExpression";
-    constructor(booleanOperator){
-        this.#expressions = [
-            booleanOperator ? new BooleanConditionImp(booleanOperator) : new RelationalExpressionImpl(),
-            {
-                type: "unknown"
-            },
-            {
-                type: "unknown"
-            }
-        ];
-    }
-    get expressions() {
-        return this.#expressions;
-    }
-    get condition() {
-        return this.#expressions[0];
-    }
-    get truthyExpression() {
-        return this.#expressions[1];
-    }
-    set truthyExpression(expression) {
-        this.#expressions[1] = expression;
-    }
-    get falsyExpression() {
-        return this.#expressions[2];
-    }
-    set falsyExpression(expression) {
-        this.#expressions[2] = expression;
-    }
-    toJSON() {
-        return {
-            type: this.type,
-            condition: this.condition.toJSON?.(),
-            truthyExpression: this.truthyExpression,
-            falsyExpression: this.falsyExpression?.toJSON?.() ?? this.falsyExpression
-        };
-    }
-}
-const isUnknown = (e)=>"unknown" === e.type;
-const isArithmeticExpression = (expression)=>"arithmeticExpression" === expression.type;
-const isCallExpression = (expression)=>"callExpression" === expression.type;
-const isConditionalExpression = (expression)=>"conditionalExpression" === expression.type;
-const isCondition = (expression)=>"relationalExpression" === expression.type || "booleanCondition" === expression.type;
-const booleanConditionIsIncomplete = (condition)=>condition.expressions.length < 2 || condition.expressions.some((e)=>conditionIsIncomplete(e));
-const isBooleanCondition = (expression)=>"booleanCondition" === expression.type;
-const isRelationalExpression = (expression)=>expression?.type === "relationalExpression";
-const conditionIsIncomplete = (condition)=>isBooleanCondition(condition) && booleanConditionIsIncomplete(condition) || isRelationalExpression(condition) && condition.expressions.length < 2;
-const firstIncompleteExpression = (expression)=>{
-    if (isUnknown(expression)) return expression;
-    if (isRelationalExpression(expression)) {
-        const [operand1, operand2] = expression.expressions;
-        if (expressionIsIncomplete(operand1)) return firstIncompleteExpression(operand1);
-        if ("unknown" === expression.op) return expression;
-        if (expressionIsIncomplete(operand2)) return firstIncompleteExpression(operand2);
-    } else if (isCondition(expression)) {
-        const { expressions = [] } = expression;
-        for (const e of expressions)if (expressionIsIncomplete(e)) return firstIncompleteExpression(e);
-    } else if (isConditionalExpression(expression)) {
-        const { condition, truthyExpression, falsyExpression } = expression;
-        if (expressionIsIncomplete(condition)) return firstIncompleteExpression(condition);
-        if (expressionIsIncomplete(truthyExpression)) return firstIncompleteExpression(truthyExpression);
-        if (expressionIsIncomplete(falsyExpression)) return firstIncompleteExpression(falsyExpression);
-    } else if (isArithmeticExpression(expression)) {
-        const { expressions = [] } = expression;
-        for (const e of expressions)if (expressionIsIncomplete(e)) return firstIncompleteExpression(e);
-    }
-};
-const replaceUnknownExpression = (incompleteExpression, unknownExpression, expression)=>{
-    const { expressions = [] } = incompleteExpression;
-    if (expressions.includes(unknownExpression)) {
-        const pos = expressions.indexOf(unknownExpression);
-        expressions.splice(pos, 1, expression);
-        return true;
-    }
-    for (const e of expressions)if (replaceUnknownExpression(e, unknownExpression, expression)) return true;
-    return false;
-};
-const expressionIsIncomplete = (expression)=>{
-    if (isUnknown(expression)) return true;
-    if (isConditionalExpression(expression)) return expressionIsIncomplete(expression.condition) || expressionIsIncomplete(expression.truthyExpression) || expressionIsIncomplete(expression.falsyExpression);
-    if (isRelationalExpression(expression) || isBooleanCondition(expression)) return void 0 === expression.op || expression.expressions.some((e)=>expressionIsIncomplete(e));
-    return false;
-};
-const addExpression = (expression, subExpression)=>{
-    const targetExpression = firstIncompleteExpression(expression);
-    if (targetExpression) if (targetExpression.expressions) targetExpression.expressions.push(subExpression);
-    else console.warn("don't know how to treat targetExpression");
-    else console.error("no target expression found");
-};
-class ColumnExpression {
-    #expression;
-    #callStack = [];
-    setCondition(booleanOperator) {
-        if (void 0 === this.#expression) this.addExpression(new ConditionalExpressionImpl(booleanOperator));
-        else if (isConditionalExpression(this.#expression)) {
-            if (expressionIsIncomplete(this.#expression.condition)) {
-                const condition = booleanOperator ? new BooleanConditionImp(booleanOperator) : new RelationalExpressionImpl();
-                this.addExpression(condition);
-            } else if (isUnknown(this.#expression.truthyExpression)) this.#expression.truthyExpression = new ConditionalExpressionImpl(booleanOperator);
-            else if (expressionIsIncomplete(this.#expression.truthyExpression)) {
-                const condition = booleanOperator ? new BooleanConditionImp(booleanOperator) : new RelationalExpressionImpl();
-                this.addExpression(condition);
-            } else if (isUnknown(this.#expression.falsyExpression)) this.#expression.falsyExpression = new ConditionalExpressionImpl(booleanOperator);
-            else if (expressionIsIncomplete(this.#expression.falsyExpression)) {
-                const condition = booleanOperator ? new BooleanConditionImp(booleanOperator) : new RelationalExpressionImpl();
-                this.addExpression(condition);
-            }
-        } else console.error("setCondition called unexpectedly");
-    }
-    addExpression(expression) {
-        if (this.#callStack.length > 0) {
-            const currentCallExpression = this.#callStack.at(-1);
-            currentCallExpression?.arguments.push(expression);
-        } else if (void 0 === this.#expression) this.#expression = expression;
-        else if (isArithmeticExpression(this.#expression)) {
-            const targetExpression = firstIncompleteExpression(this.#expression);
-            if (targetExpression && isUnknown(targetExpression)) replaceUnknownExpression(this.#expression, targetExpression, expression);
-        } else if (isConditionalExpression(this.#expression)) {
-            if (expressionIsIncomplete(this.#expression)) {
-                const targetExpression = firstIncompleteExpression(this.#expression);
-                if (targetExpression && isUnknown(targetExpression)) replaceUnknownExpression(this.#expression, targetExpression, expression);
-                else if (targetExpression) addExpression(targetExpression, expression);
-            }
-        }
-    }
-    setFunction(functionName) {
-        const callExpression = new CallExpressionImpl(functionName);
-        this.addExpression(callExpression);
-        this.#callStack.push(callExpression);
-    }
-    setColumn(columnName) {
-        this.addExpression(new ColumnExpressionImpl(columnName));
-    }
-    setArithmeticOp(value) {
-        const op = value;
-        const expression = this.#expression;
-        if (isArithmeticExpression(expression)) expression.op = op;
-    }
-    setRelationalOperator(value) {
-        const op = value;
-        if (this.#expression && isConditionalExpression(this.#expression)) {
-            const targetExpression = firstIncompleteExpression(this.#expression);
-            if (isRelationalExpression(targetExpression)) targetExpression.op = op;
-            else console.error(`no target expression found (op = ${value})`);
-        }
-    }
-    setValue(value) {
-        const literalExpression = new LiteralExpressionImpl(value);
-        if (void 0 === this.#expression) this.#expression = literalExpression;
-        else if (isArithmeticExpression(this.#expression)) this.addExpression(literalExpression);
-        else if (isCallExpression(this.#expression)) this.#expression.arguments.push(literalExpression);
-        else if (isConditionalExpression(this.#expression)) if (expressionIsIncomplete(this.#expression)) {
-            const targetExpression = firstIncompleteExpression(this.#expression);
-            if (targetExpression && isUnknown(targetExpression)) replaceUnknownExpression(this.#expression, targetExpression, literalExpression);
-            else if (targetExpression) addExpression(targetExpression, literalExpression);
-        } else console.log("what do we do with value, in a complete expression");
-    }
-    closeBrace() {
-        this.#callStack.pop();
-    }
-    get expression() {
-        return this.#expression;
-    }
-    toJSON() {
-        return this.#expression?.toJSON();
-    }
-}
-const walkTree = (tree, source)=>{
-    const columnExpression = new ColumnExpression();
-    const cursor = tree.cursor();
-    do {
-        const { name, from, to } = cursor;
-        switch(name){
-            case "AndCondition":
-                columnExpression.setCondition("and");
-                break;
-            case "OrCondition":
-                columnExpression.setCondition("or");
-                break;
-            case "RelationalExpression":
-                columnExpression.setCondition();
-                break;
-            case "ArithmeticExpression":
-                columnExpression.addExpression(new ArithmeticExpressionImpl());
-                break;
-            case "Column":
-                {
-                    const columnName = source.substring(from, to);
-                    columnExpression.setColumn(columnName);
-                }
-                break;
-            case "Function":
-                {
-                    const functionName = source.substring(from, to);
-                    columnExpression.setFunction(functionName);
-                }
-                break;
-            case "Times":
-            case "Divide":
-            case "Plus":
-            case "Minus":
-                {
-                    const op = source.substring(from, to);
-                    columnExpression.setArithmeticOp(op);
-                }
-                break;
-            case "RelationalOperator":
-                {
-                    const op = source.substring(from, to);
-                    columnExpression.setRelationalOperator(op);
-                }
-                break;
-            case "False":
-            case "True":
-                {
-                    const value = source.substring(from, to);
-                    columnExpression.setValue("true" === value);
-                }
-                break;
-            case "String":
-                columnExpression.setValue(source.substring(from + 1, to - 1));
-                break;
-            case "Number":
-                columnExpression.setValue(parseFloat(source.substring(from, to)));
-                break;
-            case "CloseBrace":
-                columnExpression.closeBrace();
-                break;
-            default:
-        }
-    }while (cursor.next())
-    return columnExpression.toJSON();
-};
-export { walkTree };