@genesislcap/foundation-ui 14.247.2 → 14.249.0

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

@@ -0,0 +1,540 @@
+import { __decorate } from "tslib";
+import { ExpressionBuilder, template, styles, formatDateString, formatDateTimeString, } from '@genesislcap/expression-builder';
+import { customElement, observable } from '@microsoft/fast-element';
+import { RuleExpression } from './types';
+/**
+ * CONFIG
+ */
+/**
+ * Combinators for the server expression
+ * @internal
+ **/
+const logicalCombinators = [
+    {
+        type: RuleExpression.logicalOperations.AND,
+        maxRules: 'many',
+    },
+    {
+        type: RuleExpression.logicalOperations.OR,
+        maxRules: 'many',
+    },
+];
+/**
+ * Operator names for the server expression
+ * Mapped to the RuleExpression names where possible
+ * @internal
+ **/
+export const clientOperators = {
+    EQUALS: RuleExpression.operations.EQUALS,
+    NOT_EQUALS: RuleExpression.operations.NOT_EQUALS,
+    IS_NULL: 'IS_NULL',
+    NOT_NULL: 'NOT_NULL',
+    IS_BLANK: 'IS_BLANK',
+    NOT_BLANK: 'NOT_BLANK',
+    CONTAINS_IGNORE_CASE: 'CONTAINS_IGNORE_CASE',
+    CONTAINS_WORDS_STARTING_WITH_IGNORE_CASE: 'CONTAINS_WORDS_STARTING_WITH_IGNORE_CASE',
+    CONTAINS_WORDS_STARTING_WITH_IGNORE_CASE_WITH_DELIMITER: 'CONTAINS_WORDS_STARTING_WITH_IGNORE_CASE_WITH_DELIMITER',
+    GREATER_THAN: RuleExpression.operations.GREATER_THAN,
+    GREATER_THAN_OR_EQUAL: RuleExpression.operations.GREATER_THAN_OR_EQUAL,
+    LESS_THAN: RuleExpression.operations.LESS_THAN,
+    LESS_THAN_OR_EQUAL: RuleExpression.operations.LESS_THAN_OR_EQUAL,
+    IS_BEFORE: 'IS_BEFORE',
+    IS_AFTER: 'IS_AFTER',
+    ON_OR_BEFORE: 'ON_OR_BEFORE',
+    ON_OR_AFTER: 'ON_OR_AFTER',
+};
+const intTypes = ['int', 'short', 'long'];
+const floatTypes = ['double', 'bigdecimal'];
+const numberTypes = [...intTypes, ...floatTypes];
+const dateTypes = ['date', 'date-time'];
+const stringTypes = ['string', 'enum'];
+const booleanTypes = ['boolean'];
+/**
+ * Operators for the server expression
+ * @internal
+ **/
+const logicalOperators = [
+    {
+        type: clientOperators.EQUALS,
+        nbInputs: 1,
+        applyTo: [...stringTypes, ...booleanTypes, ...numberTypes, ...dateTypes],
+    },
+    {
+        type: clientOperators.NOT_EQUALS,
+        nbInputs: 1,
+        applyTo: [...stringTypes, ...booleanTypes, ...numberTypes, ...dateTypes],
+    },
+    {
+        type: clientOperators.IS_NULL,
+        nbInputs: 0,
+        applyTo: [...stringTypes, ...booleanTypes, ...numberTypes, ...dateTypes],
+    },
+    {
+        type: clientOperators.NOT_NULL,
+        nbInputs: 0,
+        applyTo: [...stringTypes, ...booleanTypes, ...numberTypes, ...dateTypes],
+    },
+    {
+        type: clientOperators.IS_BLANK,
+        nbInputs: 0,
+        applyTo: ['string'],
+    },
+    {
+        type: clientOperators.NOT_BLANK,
+        nbInputs: 0,
+        applyTo: ['string'],
+    },
+    {
+        type: clientOperators.CONTAINS_IGNORE_CASE,
+        nbInputs: 1,
+        applyTo: ['string'],
+    },
+    {
+        type: clientOperators.CONTAINS_WORDS_STARTING_WITH_IGNORE_CASE,
+        nbInputs: 1,
+        applyTo: ['string'],
+    },
+    {
+        type: clientOperators.CONTAINS_WORDS_STARTING_WITH_IGNORE_CASE_WITH_DELIMITER,
+        nbInputs: 1,
+        applyTo: ['string'],
+    },
+    {
+        type: clientOperators.GREATER_THAN,
+        nbInputs: 1,
+        applyTo: [...numberTypes],
+    },
+    {
+        type: clientOperators.GREATER_THAN_OR_EQUAL,
+        nbInputs: 1,
+        applyTo: [...numberTypes],
+    },
+    {
+        type: clientOperators.LESS_THAN,
+        nbInputs: 1,
+        applyTo: [...numberTypes],
+    },
+    {
+        type: clientOperators.LESS_THAN_OR_EQUAL,
+        nbInputs: 1,
+        applyTo: [...numberTypes],
+    },
+    {
+        type: clientOperators.IS_BEFORE,
+        nbInputs: 1,
+        applyTo: [...dateTypes],
+    },
+    {
+        type: clientOperators.IS_AFTER,
+        nbInputs: 1,
+        applyTo: [...dateTypes],
+    },
+    {
+        type: clientOperators.ON_OR_BEFORE,
+        nbInputs: 1,
+        applyTo: [...dateTypes],
+    },
+    {
+        type: clientOperators.ON_OR_AFTER,
+        nbInputs: 1,
+        applyTo: [...dateTypes],
+    },
+];
+/**
+ * Convert from Expression builder to Genesis
+ */
+/**
+ * Converts a client BinaryOperator to a server BinaryExpression
+ *
+ * The opposite of `fromBinaryExpression`
+ * @internal
+ **/
+export function toBinaryExpression(rule, OPERATION, TYPE) {
+    if (!('value' in rule))
+        return null;
+    return {
+        TYPE: 'BINARY_EXPRESSION',
+        LEFT: {
+            TYPE: 'FIELD',
+            NAME: rule.field.fieldId,
+        },
+        OPERATION,
+        RIGHT: {
+            TYPE,
+            VALUE: rule.value,
+        },
+    };
+}
+/**
+ * Converts a client BinaryOperator to a server BinaryExpression
+ *
+ * The opposite of `fromBinaryExpression`
+ *
+ * @privateRemarks
+ * Used in specific cases where a server operation doesn't map nicely to a client one,
+ * such as IS_NULL being a client UniraryOperation but a server BinaryExpression
+ * @internal
+ **/
+export function toSetValueBinaryExpression(rule, OPERATION, RIGHT) {
+    return {
+        TYPE: 'BINARY_EXPRESSION',
+        LEFT: {
+            TYPE: 'FIELD',
+            NAME: rule.field.fieldId,
+        },
+        OPERATION,
+        RIGHT,
+    };
+}
+/**
+ * Converts a client BinaryOperator to a server MethodExpression
+ *
+ * The opposite of `fromMethodExpression`
+ *
+ * @internal
+ **/
+export function toMethodExpression(rule, METHOD, extraParams = []) {
+    if (!('value' in rule))
+        return null;
+    return {
+        TYPE: 'METHOD_EXPRESSION',
+        PARAMETERS: [
+            {
+                TYPE: 'FIELD',
+                NAME: rule.field.fieldId,
+            },
+            {
+                TYPE: 'STRING',
+                VALUE: rule.value,
+            },
+            ...extraParams,
+        ],
+        METHOD,
+    };
+}
+/**
+ * Converts a client field type to a server expression type
+ *
+ * @internal
+ **/
+export function mapFieldTypeToRuleExpressionType(rule) {
+    switch (rule.field.type) {
+        case 'int':
+        case 'long':
+        case 'double':
+        case 'bigdecimal':
+        case 'date':
+        case 'date-time':
+        case 'short':
+            return 'NUMBER';
+        case 'string':
+        case 'enum':
+            return 'STRING';
+        case 'boolean':
+            return 'BOOLEAN';
+    }
+}
+export const MILLIS_TO_SECONDS = 1000;
+/**
+ * Converts a client field value to a server field value
+ *
+ * The opposite to `rebuildRuleValue`
+ *
+ * @privateRemarks
+ * `string` (+`enum`) and `boolean` types are left as they are
+ * `number` types are converted to string due to the limitation of BigDecimal values from the server
+ * `date` and `datetime-local` converted to epoch time as the server works with numbers
+ *
+ * @internal
+ **/
+export function transformRuleValue(rule) {
+    const transform = (value) => {
+        if (stringTypes.includes(rule.field.type))
+            return value;
+        if (numberTypes.includes(rule.field.type))
+            return value.toString(); // Handle as bigdecimal
+        if (booleanTypes.includes(rule.field.type))
+            return value;
+        if (Array.isArray(value))
+            throw new Error(`Not implemented TernararyOperator or VariadicOperator args in rule value transformer`);
+        if (dateTypes.includes(rule.field.type)) {
+            return (new Date(value).getTime() / MILLIS_TO_SECONDS).toString(); // Handle as bigdecimal
+        }
+        throw new Error('Unhandled transformRuleValue case');
+    };
+    const validRule = !(!('value' in rule) ||
+        typeof rule.value === 'undefined' ||
+        rule.value === null);
+    return Object.assign(Object.assign({}, rule), (validRule ? { value: transform(rule.value) } : {}));
+}
+/**
+ * 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
+ **/
+export function transformOperatorNameToServerName(op) {
+    switch (op) {
+        case 'IS_BEFORE':
+            return 'LESS_THAN';
+        case 'IS_AFTER':
+            return 'GREATER_THAN';
+        case 'ON_OR_BEFORE':
+            return 'LESS_THAN_OR_EQUAL';
+        case 'ON_OR_AFTER':
+            return 'GREATER_THAN_OR_EQUAL';
+        default:
+            return op;
+    }
+}
+/**
+ * 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
+ **/
+export 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 clientOperators.EQUALS:
+        case clientOperators.NOT_EQUALS:
+        case clientOperators.GREATER_THAN:
+        case clientOperators.GREATER_THAN_OR_EQUAL:
+        case clientOperators.LESS_THAN:
+        case clientOperators.LESS_THAN_OR_EQUAL:
+            return toBinaryExpression(rule, operatorName, rhsType);
+        case clientOperators.IS_NULL:
+            return toSetValueBinaryExpression(rule, RuleExpression.operations.EQUALS, { TYPE: 'NULL' });
+        case clientOperators.NOT_NULL:
+            return toSetValueBinaryExpression(rule, RuleExpression.operations.NOT_EQUALS, {
+                TYPE: 'NULL',
+            });
+        case clientOperators.IS_BLANK:
+            return toSetValueBinaryExpression(rule, RuleExpression.operations.EQUALS, {
+                TYPE: 'STRING',
+                VALUE: '',
+            });
+        case clientOperators.NOT_BLANK:
+            return toSetValueBinaryExpression(rule, RuleExpression.operations.NOT_EQUALS, {
+                TYPE: 'STRING',
+                VALUE: '',
+            });
+        case clientOperators.CONTAINS_IGNORE_CASE:
+            return toMethodExpression(rule, RuleExpression.methodCall.CONTAINS_IGNORE_CASE);
+        case clientOperators.CONTAINS_WORDS_STARTING_WITH_IGNORE_CASE:
+            return toMethodExpression(rule, RuleExpression.methodCall.CONTAINS_WORDS_STARTING_WITH_IGNORE_CASE);
+        case clientOperators.CONTAINS_WORDS_STARTING_WITH_IGNORE_CASE_WITH_DELIMITER:
+            return toMethodExpression(rule, RuleExpression.methodCall.CONTAINS_WORDS_STARTING_WITH_IGNORE_CASE, [{ TYPE: 'STRING', VALUE: ';' }]);
+        default:
+            throw new Error(`Unmatched case for operator name: ${operatorName}`);
+    }
+}
+/**
+ * Converts a client `Group` into the correct server `Expression`
+ *
+ * @internal
+ **/
+export function groupToRuleExpression(group) {
+    return {
+        TYPE: 'PREDICATE_EXPRESSION',
+        OPERATION: group.combinator.type,
+        CONDITIONS: group.children
+            .map((c) => 'children' in c ? groupToRuleExpression(c) : ruleToRuleExpression(c))
+            .filter(Boolean),
+    };
+}
+/**
+ * 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
+ **/
+export function transformServerNameToOperatorName(op) {
+    switch (op) {
+        case 'LESS_THAN':
+            return 'IS_BEFORE';
+        case 'GREATER_THAN':
+            return 'IS_AFTER';
+        case 'LESS_THAN_OR_EQUAL':
+            return 'ON_OR_BEFORE';
+        case 'GREATER_THAN_OR_EQUAL':
+            return 'ON_OR_AFTER';
+        default:
+            return op;
+    }
+}
+/**
+ * Converts a server field value to a client field value
+ *
+ * The opposite to `transformRuleValue`
+ *
+ * @privateRemarks
+ * `string` (+`enum`) and `boolean` types are left as they are
+ * `date` and `datetime-local` are converted to the string format required for input type=[date|datetime-local]
+ * `number` types are parsed as ints or floats as required
+ *
+ * @internal
+ **/
+export function rebuildRuleValue(rule, rhs) {
+    const transform = (value) => {
+        if (stringTypes.includes(rule.field.type))
+            return value;
+        if (intTypes.includes(rule.field.type))
+            return parseInt(value);
+        if (floatTypes.includes(rule.field.type))
+            return parseFloat(value);
+        if (booleanTypes.includes(rule.field.type))
+            return value;
+        if (dateTypes.includes(rule.field.type)) {
+            const dateObj = new Date(parseInt(value) * MILLIS_TO_SECONDS);
+            return rule.field.type === 'date' ? formatDateString(dateObj) : formatDateTimeString(dateObj);
+        }
+        throw new Error('Unhandled rebuildRuleValue case');
+    };
+    const operatorNbInputs = rule.operator.nbInputs;
+    if (operatorNbInputs === 'many' || operatorNbInputs === 2)
+        throw new Error(`Not implemented TernararyOperator or VariadicOperator args in rebuildRuleValue`);
+    return Object.assign(Object.assign({}, rule), (operatorNbInputs === 0 ? {} : { value: transform(rhs.VALUE) }));
+}
+/**
+ * Handles operator names which have a special client name, but serialised to a normal operator on the server
+ *
+ * @privateRemarks
+ * e.g. `NOT_NULL` is a standard NOT_EQUAL BinaryExpression on the server, but a special UniraryOperation on the client
+ *
+ * @internal
+ **/
+export function rebuildOperator(binExpr) {
+    if (binExpr.RIGHT.TYPE === 'NULL') {
+        const op = binExpr.OPERATION === 'EQUALS'
+            ? clientOperators[clientOperators.IS_NULL]
+            : clientOperators[clientOperators.NOT_NULL];
+        return logicalOperators.find((o) => o.type === op);
+    }
+    if (binExpr.RIGHT.TYPE === 'STRING' && binExpr.RIGHT.VALUE === '') {
+        const op = binExpr.OPERATION === 'EQUALS'
+            ? clientOperators[clientOperators.IS_BLANK]
+            : clientOperators[clientOperators.NOT_BLANK];
+        return logicalOperators.find((o) => o.type === op);
+    }
+    const clientOperatorName = transformServerNameToOperatorName(binExpr.OPERATION);
+    return logicalOperators.find((o) => o.type === clientOperatorName);
+}
+/**
+ * Converts a server BinaryExpression to a client BinaryOperator
+ *
+ * The opposite of `toBinaryExpression`
+ * @internal
+ **/
+export 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({
+        field: fields.find((f) => f.fieldId === binExpr.LEFT.NAME),
+        operator: rebuildOperator(binExpr),
+    }, binExpr.RIGHT);
+}
+/**
+ * Converts a server MethodExpression to a client BinaryOperator
+ *
+ * The opposite of `toMethodExpression`
+ *
+ * @internal
+ **/
+export function fromMethodExpression(fields, methodExpr) {
+    const clientOperatorName = methodExpr.METHOD === 'CONTAINS_IGNORE_CASE'
+        ? clientOperators[clientOperators.CONTAINS_IGNORE_CASE]
+        : methodExpr.PARAMETERS.length === 2
+            ? clientOperators[clientOperators.CONTAINS_WORDS_STARTING_WITH_IGNORE_CASE]
+            : clientOperators[clientOperators.CONTAINS_WORDS_STARTING_WITH_IGNORE_CASE_WITH_DELIMITER];
+    return {
+        field: fields.find((f) => f.fieldId === methodExpr.PARAMETERS[0].NAME),
+        operator: logicalOperators.find((o) => o.type === clientOperatorName),
+        value: methodExpr.PARAMETERS[1].VALUE, // TODO currently the only methods defined are BinaryExpression Strings
+    };
+}
+/**
+ * Converts recursively from a PREDICATE_EXPRESSION to client Groups and Rules
+ *
+ * @internal
+ **/
+export function ruleExpressionToGroup(fields, expr) {
+    return {
+        combinator: logicalCombinators.find((combinator) => combinator.type === expr.OPERATION),
+        children: expr.CONDITIONS.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 FoundationRuleExpressionBuilder = class FoundationRuleExpressionBuilder extends ExpressionBuilder {
+    ruleConfigChanged(_, newConfig) {
+        this.config = Object.assign({ combinators: logicalCombinators, operators: logicalOperators, fields: newConfig.fields, maxNesting: newConfig.maxNesting }, ((newConfig === null || newConfig === void 0 ? void 0 : newConfig.model)
+            ? {
+                model: ruleExpressionToGroup(newConfig.fields, newConfig.model),
+            }
+            : {}));
+    }
+    dispatchChangeEvent(group) {
+        const ruleExpr = groupToRuleExpression(group);
+        this.dispatchEvent(new CustomEvent('change', {
+            detail: ruleExpr,
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+        }));
+    }
+};
+__decorate([
+    observable
+], FoundationRuleExpressionBuilder.prototype, "ruleConfig", void 0);
+FoundationRuleExpressionBuilder = __decorate([
+    customElement({
+        name: 'foundation-rule-expression-builder',
+        styles: styles,
+        template,
+    })
+], FoundationRuleExpressionBuilder);
+export { FoundationRuleExpressionBuilder };

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

@@ -0,0 +1,21 @@
+import { Config, template, styles } from '@genesislcap/expression-builder';
+export { Config as ExpressionBuilderConfig };
+export const ExpressionBuilderCore = {
+    template,
+    styles,
+};
+/**
+ * Based on the RuleExpression config in Kotlin
+ */
+export var RuleExpression;
+(function (RuleExpression) {
+    RuleExpression.methodCall = {
+        CONTAINS_IGNORE_CASE: 'CONTAINS_IGNORE_CASE',
+        CONTAINS_WORDS_STARTING_WITH_IGNORE_CASE: 'CONTAINS_WORDS_STARTING_WITH_IGNORE_CASE',
+    };
+    RuleExpression.logicalOperations = {
+        AND: 'AND',
+        OR: 'OR',
+    };
+    RuleExpression.operations = Object.assign(Object.assign({}, RuleExpression.logicalOperations), { GREATER_THAN: 'GREATER_THAN', LESS_THAN: 'LESS_THAN', GREATER_THAN_OR_EQUAL: 'GREATER_THAN_OR_EQUAL', LESS_THAN_OR_EQUAL: 'LESS_THAN_OR_EQUAL', EQUALS: 'EQUALS', NOT_EQUALS: 'NOT_EQUALS', PLUS: 'PLUS', MINUS: 'MINUS', MULTIPLY: 'MULTIPLY', DIVIDE: 'DIVIDE', BITWISE_AND: 'BITWISE_AND', BITWISE_OR: 'BITWISE_OR', ASSIGNMENT: 'ASSIGNMENT' });
+})(RuleExpression || (RuleExpression = {}));

package/dist/esm/index.js

@@ -12,16 +12,16 @@ export * from './anchored-region';
 export * from './avatar';
 export * from './badge';
 export * from './banner';
-export * from './breadcrumb-item';
 export * from './breadcrumb';
+export * from './breadcrumb-item';
 export * from './button';
-export * from './context';
 export * from './calendar';
 export * from './card';
 export * from './categorized-multiselect';
 export * from './checkbox';
 export * from './combobox';
 export * from './connection-indicator';
+export * from './context';
 export * from './data-grid';
 export * from './data-grid-cell';
 export * from './data-grid-datasource';
@@ -32,9 +32,10 @@ export * from './dialog';
 export * from './disclosure';
 export * from './divider';
 export * from './dropdown-menu';
-export * from './error-boundary';
 export * from './error-banner';
+export * from './error-boundary';
 export * from './error-dialog';
+export * from './expression-builder';
 export * from './file-upload';
 export * from './filter';
 export * from './filter-bar';
@@ -70,8 +71,8 @@ export * from './select';
 export * from './skeleton';
 export * from './slider';
 export * from './slider-label';
-export * from './stacking-icons';
 export * from './snackbar';
+export * from './stacking-icons';
 export * from './stepper';
 export * from './stepper-tab';
 export * from './stepper-tab-panel';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@genesislcap/foundation-ui",
   "description": "Genesis Foundation UI",
-  "version": "14.247.2",
+  "version": "14.249.0",
   "sideEffects": false,
   "license": "SEE LICENSE IN license.txt",
   "main": "dist/esm/index.js",
@@ -83,13 +83,13 @@
     }
   },
   "devDependencies": {
-    "@genesislcap/foundation-testing": "14.247.2",
-    "@genesislcap/genx": "14.247.2",
-    "@genesislcap/rollup-builder": "14.247.2",
-    "@genesislcap/ts-builder": "14.247.2",
-    "@genesislcap/uvu-playwright-builder": "14.247.2",
-    "@genesislcap/vite-builder": "14.247.2",
-    "@genesislcap/webpack-builder": "14.247.2",
+    "@genesislcap/foundation-testing": "14.249.0",
+    "@genesislcap/genx": "14.249.0",
+    "@genesislcap/rollup-builder": "14.249.0",
+    "@genesislcap/ts-builder": "14.249.0",
+    "@genesislcap/uvu-playwright-builder": "14.249.0",
+    "@genesislcap/vite-builder": "14.249.0",
+    "@genesislcap/webpack-builder": "14.249.0",
     "copyfiles": "^2.4.1",
     "rimraf": "^5.0.0",
     "rxjs": "^7.5.4"
@@ -100,14 +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/foundation-comms": "14.247.2",
-    "@genesislcap/foundation-criteria": "14.247.2",
-    "@genesislcap/foundation-errors": "14.247.2",
-    "@genesislcap/foundation-events": "14.247.2",
-    "@genesislcap/foundation-logger": "14.247.2",
-    "@genesislcap/foundation-notifications": "14.247.2",
-    "@genesislcap/foundation-user": "14.247.2",
-    "@genesislcap/foundation-utils": "14.247.2",
+    "@genesislcap/expression-builder": "14.249.0",
+    "@genesislcap/foundation-comms": "14.249.0",
+    "@genesislcap/foundation-criteria": "14.249.0",
+    "@genesislcap/foundation-errors": "14.249.0",
+    "@genesislcap/foundation-events": "14.249.0",
+    "@genesislcap/foundation-logger": "14.249.0",
+    "@genesislcap/foundation-notifications": "14.249.0",
+    "@genesislcap/foundation-user": "14.249.0",
+    "@genesislcap/foundation-utils": "14.249.0",
     "@microsoft/fast-colors": "5.3.1",
     "@microsoft/fast-components": "2.30.6",
     "@microsoft/fast-element": "1.14.0",
@@ -129,5 +130,5 @@
     "access": "public"
   },
   "customElements": "dist/custom-elements.json",
-  "gitHead": "ce87a41c2796b6320b7401ee18c06b3b11b86899"
+  "gitHead": "0827469e373358a4dbc50de154868998adf62bd9"
 }