@genesislcap/foundation-ui 14.258.3 → 14.259.0

package/dist/esm/expression-builder/value-expression-builder.js

@@ -0,0 +1,297 @@
+import { __decorate } from "tslib";
+import { ExpressionBuilder, template, styles, Config } from '@genesislcap/expression-builder';
+import { customElement, observable } from '@microsoft/fast-element';
+import { mapFieldTypeToRuleExpressionType, numberTypes, toBinaryExpression, toMethodExpression, transformRuleValue, rebuildRuleValue, } from './expressions-shared-helpers';
+import { RuleExpression } from './types';
+/**
+ * CONFIG
+ * TODO: this file doesn't have unit tests, as the unit tests are basically identical to the rule-expression-builder file. Once we properly
+ * split responsibilities then everything can receive tests
+ */
+/**
+ * Operator names for the server expression
+ * Mapped to the RuleExpression names where possible
+ * @internal
+ **/
+const valueOperatorNames = {
+    TRIM: 'TRIM',
+    ADD: 'ADD',
+    SUBTRACT: 'SUBTRACT',
+    MULTIPLY: 'MULTIPLY',
+    DIVIDE: 'DIVIDE',
+    CONVERT_TO_DATE: 'CONVERT_TO_DATE',
+    CONVERT_TO_DATE_TIME: 'CONVERT_TO_DATE_TIME',
+};
+/**
+ * Operators for the server expression
+ * @internal
+ **/
+const valueOperators = [
+    {
+        type: valueOperatorNames.TRIM,
+        applyTo: ['string'],
+        nbInputs: 0,
+        tooltip: "Returns a string whose value is this string, with all leading and trailing space removed, where space is defined as any character whose codepoint is less than or equal to 'U+0020' (the space character)",
+    },
+    {
+        type: valueOperatorNames.ADD,
+        applyTo: [...numberTypes],
+        nbInputs: 1,
+        tooltip: 'Returns the result of the field value mathematically added to the specified rule value. FIELD + VALUE',
+    },
+    {
+        type: valueOperatorNames.SUBTRACT,
+        applyTo: [...numberTypes],
+        nbInputs: 1,
+        tooltip: 'Returns the result of the field value mathematically subtracted by the specified rule value. FIELD - VALUE',
+    },
+    {
+        type: valueOperatorNames.MULTIPLY,
+        applyTo: [...numberTypes],
+        nbInputs: 1,
+        tooltip: 'Returns the result of the field value mathematically multiplied by the specified rule value. FIELD * VALUE',
+    },
+    {
+        type: valueOperatorNames.DIVIDE,
+        applyTo: [...numberTypes],
+        nbInputs: 1,
+        tooltip: 'Returns the result of the field value mathematically divided by the specified rule value. FIELD / VALUE',
+    },
+    {
+        type: valueOperatorNames.CONVERT_TO_DATE,
+        applyTo: ['date'],
+        nbInputs: 0,
+        tooltip: 'Returns the date, which is stored as the epoch time, as a formatted date YYYY/dd/mm',
+    },
+    {
+        type: valueOperatorNames.CONVERT_TO_DATE_TIME,
+        applyTo: ['date-time'],
+        nbInputs: 0,
+        tooltip: 'Returns the date-time, which is stored as the epoch time, as a formatted date YYYY/dd/mm HH:mm:ss',
+    },
+];
+/**
+ * Converts a client operator name to a server operator name
+ *
+ * The opposite to `transformServerNameToOperatorName`
+ *
+ * @privateRemarks
+ * Most names are the same, but this handles cases where date comparison operator names are different
+ * on the display to their server name
+ *
+ * TODO: We could clean this up if we support labels/aliases on the client component
+ *
+ * @internal
+ **/
+function transformOperatorNameToServerName(op) {
+    switch (op) {
+        default:
+            return op;
+    }
+}
+/**
+ * Converts a client `Rule` into the correct server `MethodExpression`
+ *
+ * @internal
+ **/
+function ruleToRuleMethodExpression(rule, operatorName) {
+    switch (operatorName) {
+        case valueOperatorNames.TRIM:
+            return toMethodExpression(rule, RuleExpression.methodCall.TRIM, []);
+        case valueOperatorNames.CONVERT_TO_DATE:
+            return toMethodExpression(rule, RuleExpression.methodCall.LONG_TO_DATE, []);
+        case valueOperatorNames.CONVERT_TO_DATE_TIME:
+            return toMethodExpression(rule, RuleExpression.methodCall.LONG_TO_DATE_TIME, []);
+    }
+}
+/**
+ * Converts a client `Rule` into the correct server `Expression`
+ *
+ * @privateRemarks
+ * The server doesn't have a concept for a partial expression so if the user doesn't fill out all values
+ * (e.g. chooses a field but not an operator) that would be lost via this process
+ *
+ * @internal
+ **/
+function ruleToRuleExpression(ruleInput) {
+    var _a, _b;
+    // If the user hasn't fully filled out the rule then we just ignore it for the condition
+    if (!(((_a = ruleInput.operator) === null || _a === void 0 ? void 0 : _a.type) && ((_b = ruleInput.field) === null || _b === void 0 ? void 0 : _b.fieldId)))
+        return null;
+    const rule = transformRuleValue(ruleInput);
+    const rhsType = mapFieldTypeToRuleExpressionType(rule);
+    const operatorName = transformOperatorNameToServerName(rule.operator.type);
+    switch (operatorName) {
+        case valueOperatorNames.TRIM:
+        case valueOperatorNames.CONVERT_TO_DATE:
+        case valueOperatorNames.CONVERT_TO_DATE_TIME:
+            return ruleToRuleMethodExpression(rule, operatorName);
+        case valueOperatorNames.ADD:
+        case valueOperatorNames.SUBTRACT:
+        case valueOperatorNames.DIVIDE:
+        case valueOperatorNames.MULTIPLY:
+            return toBinaryExpression(rule, operatorName, rhsType);
+        default:
+            throw new Error(`Unmatched case for operator name: ${operatorName}`);
+    }
+}
+/**
+ * Convert from Genesis to Expression builder
+ */
+/**
+ * Converts a server operator name to a client operator name
+ *
+ * The opposite to `transformOperatorNameToServerName`
+ *
+ * @privateRemarks
+ * Most names are the same, but this handles cases where date comparison operator names are different
+ * on the display to their server name
+ *
+ * TODO: We could clean this up if we support labels/aliases on the client component
+ *
+ * @internal
+ **/
+function transformServerNameToOperatorName(op, rulePartialField) {
+    // TODO: this function usage doens't need to do anything because all binary expression operator names match on client and server
+    // for now
+    const useDateOperatorNames = rulePartialField.field.type === 'date' || rulePartialField.field.type === 'date-time';
+    if (!useDateOperatorNames)
+        return op;
+    switch (op) {
+        default:
+            return op;
+    }
+}
+/**
+ * Handles operator names which have a special client name, but serialised to a normal operator on the server
+ *
+ * @internal
+ **/
+function rebuildOperator(rulePartialField, binExpr) {
+    const operator = (() => {
+        const clientOperatorName = transformServerNameToOperatorName(binExpr.OPERATION, rulePartialField);
+        return valueOperators.find((o) => o.type === clientOperatorName);
+    })();
+    return Object.assign(Object.assign({}, rulePartialField), { operator });
+}
+/**
+ * Converts a server BinaryExpression to a client BinaryOperator
+ *
+ * The opposite of `toBinaryExpression`
+ * @internal
+ **/
+function fromBinaryExpression(fields, binExpr) {
+    if (binExpr.LEFT.TYPE !== 'FIELD')
+        throw new Error('BinaryExpression LHS must be TYPE === FIELD');
+    if (!['STRING', 'NUMBER', 'BOOLEAN', 'NULL'].includes(binExpr.RIGHT.TYPE))
+        throw new Error('BinaryExpression RHS must be TYPE === NUMBER | STRING | BOOLEAN | NULL');
+    return rebuildRuleValue(rebuildOperator({
+        field: fields.find((f) => f.fieldId === binExpr.LEFT.NAME),
+    }, binExpr), binExpr.RIGHT);
+}
+/**
+ * Converts a server MethodExpression to a client BinaryOperator
+ *
+ * The opposite of `toMethodExpression`
+ *
+ * @internal
+ **/
+function fromMethodExpression(fields, methodExpr) {
+    const [clientOperatorName, value] = (() => {
+        switch (true) {
+            case methodExpr.METHOD === 'TRIM':
+                return [valueOperatorNames[valueOperatorNames.TRIM], undefined];
+            case methodExpr.METHOD === 'LONG_TO_DATE':
+                return [valueOperatorNames[valueOperatorNames.CONVERT_TO_DATE], undefined];
+            case methodExpr.METHOD === 'LONG_TO_DATE_TIME':
+                return [valueOperatorNames[valueOperatorNames.CONVERT_TO_DATE_TIME], undefined];
+            default:
+                throw new Error('Unhandled fromMethodExpression case');
+        }
+    })();
+    return {
+        field: fields.find((f) => f.fieldId === methodExpr.PARAMETERS[0].NAME),
+        operator: valueOperators.find((o) => o.type === clientOperatorName),
+        value,
+    };
+}
+/**
+ * Converts recursively from a PREDICATE_EXPRESSION to client Groups and Rules
+ *
+ * @internal
+ **/
+function ruleExpressionToGroup(fields, expr) {
+    return {
+        combinator: Config.NULL_COMBINATOR,
+        children: expr.EXPRESSIONS.map((condition) => {
+            if (!('TYPE' in condition))
+                throw new Error('RuleExpression format not yet supported - no TYPE');
+            if (condition.TYPE === 'PREDICATE_EXPRESSION')
+                return ruleExpressionToGroup(fields, condition);
+            if (condition.TYPE === 'BINARY_EXPRESSION')
+                return fromBinaryExpression(fields, condition);
+            if (condition.TYPE === 'METHOD_EXPRESSION')
+                return fromMethodExpression(fields, condition);
+            throw new Error('RuleExpression format not yet supported - unsupported TYPE');
+        }),
+    };
+}
+/**
+ * We don't create the foundation version of the component in the same way as the other components,
+ * they're composed from a base FAST component.
+ * The reason for this is that we want to have ExpressionBuilder as an independent and open source
+ * component, and due to this we don't want to release it as base components that someone needs to use
+ * FAST to compose.
+ */
+let FoundationValueExpressionBuilder = class FoundationValueExpressionBuilder extends ExpressionBuilder {
+    valueConfigChanged(_, newConfig) {
+        const topLevelPredicateExpr = {
+            TYPE: 'PREDICATE_EXPRESSION',
+            OPERATION: 'NULL',
+            EXPRESSIONS: newConfig.model ? [newConfig.model] : [],
+        };
+        const model = ruleExpressionToGroup(newConfig.fields, topLevelPredicateExpr);
+        this.config = {
+            combinators: [Config.NULL_COMBINATOR],
+            operators: valueOperators,
+            fields: newConfig.fields,
+            model,
+            maxNesting: newConfig.maxNesting,
+            partialRuleValidationWarning: newConfig.partialRuleValidationWarning,
+        };
+    }
+    configChanged(oldConfig, newConfig) {
+        if (!newConfig.operators || !newConfig.combinators) {
+            throw new Error('Unable to detect operators or combinators. Did you set the config on the rule builder via the config property? Use the valueConfig property instead');
+        }
+        super.configChanged(oldConfig, newConfig);
+    }
+    dispatchChangeEvent(group) {
+        if (!('children' in group))
+            throw new Error('Invalid top level group hierarchy');
+        if (group.children.length === 0)
+            return;
+        if (group.children.length > 1)
+            throw new Error('Value expressions should not have multiple rules');
+        if ('children' in group.children[0])
+            throw new Error('Trying to convert group to rule');
+        const valueExpr = ruleToRuleExpression(group.children[0]);
+        this.dispatchEvent(new CustomEvent('change', {
+            detail: valueExpr,
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+        }));
+    }
+};
+__decorate([
+    observable
+], FoundationValueExpressionBuilder.prototype, "valueConfig", void 0);
+FoundationValueExpressionBuilder = __decorate([
+    customElement({
+        name: 'foundation-value-expression-builder',
+        styles: styles,
+        template,
+    })
+], FoundationValueExpressionBuilder);
+export { FoundationValueExpressionBuilder };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@genesislcap/foundation-ui",
   "description": "Genesis Foundation UI",
-  "version": "14.258.3",
+  "version": "14.259.0",
   "sideEffects": false,
   "license": "SEE LICENSE IN license.txt",
   "main": "dist/esm/index.js",
@@ -83,13 +83,13 @@
     }
   },
   "devDependencies": {
-    "@genesislcap/foundation-testing": "14.258.3",
-    "@genesislcap/genx": "14.258.3",
-    "@genesislcap/rollup-builder": "14.258.3",
-    "@genesislcap/ts-builder": "14.258.3",
-    "@genesislcap/uvu-playwright-builder": "14.258.3",
-    "@genesislcap/vite-builder": "14.258.3",
-    "@genesislcap/webpack-builder": "14.258.3",
+    "@genesislcap/foundation-testing": "14.259.0",
+    "@genesislcap/genx": "14.259.0",
+    "@genesislcap/rollup-builder": "14.259.0",
+    "@genesislcap/ts-builder": "14.259.0",
+    "@genesislcap/uvu-playwright-builder": "14.259.0",
+    "@genesislcap/vite-builder": "14.259.0",
+    "@genesislcap/webpack-builder": "14.259.0",
     "copyfiles": "^2.4.1",
     "rimraf": "^5.0.0",
     "rxjs": "^7.5.4"
@@ -100,15 +100,15 @@
     "@fortawesome/free-regular-svg-icons": "^6.2.1",
     "@fortawesome/free-solid-svg-icons": "^6.2.1",
     "@genesiscommunitysuccess/analyzer-import-alias-plugin": "^5.0.3",
-    "@genesislcap/expression-builder": "14.258.3",
-    "@genesislcap/foundation-comms": "14.258.3",
-    "@genesislcap/foundation-criteria": "14.258.3",
-    "@genesislcap/foundation-errors": "14.258.3",
-    "@genesislcap/foundation-events": "14.258.3",
-    "@genesislcap/foundation-logger": "14.258.3",
-    "@genesislcap/foundation-notifications": "14.258.3",
-    "@genesislcap/foundation-user": "14.258.3",
-    "@genesislcap/foundation-utils": "14.258.3",
+    "@genesislcap/expression-builder": "14.259.0",
+    "@genesislcap/foundation-comms": "14.259.0",
+    "@genesislcap/foundation-criteria": "14.259.0",
+    "@genesislcap/foundation-errors": "14.259.0",
+    "@genesislcap/foundation-events": "14.259.0",
+    "@genesislcap/foundation-logger": "14.259.0",
+    "@genesislcap/foundation-notifications": "14.259.0",
+    "@genesislcap/foundation-user": "14.259.0",
+    "@genesislcap/foundation-utils": "14.259.0",
     "@microsoft/fast-colors": "5.3.1",
     "@microsoft/fast-components": "2.30.6",
     "@microsoft/fast-element": "1.14.0",
@@ -130,5 +130,5 @@
     "access": "public"
   },
   "customElements": "dist/custom-elements.json",
-  "gitHead": "0acd5f3f2eb9903b9b0d70b5d35210fd0b26d0c5"
+  "gitHead": "6656bbcddf94db7587bab3339ca021718ce54709"
 }