@finos/legend-application-query 5.2.8 → 6.0.0

package/lib/stores/query-builder/fetch-structure/projection/post-filter/operators/QueryBuilderPostFilterOperator_StartWith.js

@@ -0,0 +1,75 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { PRIMITIVE_TYPE, buildPrimitiveInstanceValue, } from '@finos/legend-graph';
+import { UnsupportedOperationError } from '@finos/legend-shared';
+import { QueryBuilderPostFilterOperator } from '../QueryBuilderPostFilterOperator.js';
+import { buildPostFilterConditionState } from '../QueryBuilderPostFilterStateBuilder.js';
+import { buildNotExpression, generateDefaultValueForPrimitiveType, getNonCollectionValueSpecificationType, unwrapNotExpression, } from '../../../../QueryBuilderValueSpecificationHelper.js';
+import { buildPostFilterConditionExpression } from './QueryBuilderPostFilterOperatorHelper.js';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../../../graphManager/QueryBuilderSupportedFunctions.js';
+export class QueryBuilderPostFilterOperator_StartWith extends QueryBuilderPostFilterOperator {
+    getLabel() {
+        return 'starts with';
+    }
+    isCompatibleWithType(type) {
+        if (type.path === PRIMITIVE_TYPE.STRING) {
+            return true;
+        }
+        return false;
+    }
+    isCompatibleWithConditionValue(postFilterConditionState) {
+        const type = postFilterConditionState.value
+            ? getNonCollectionValueSpecificationType(postFilterConditionState.value)
+            : undefined;
+        return PRIMITIVE_TYPE.STRING === type?.path;
+    }
+    getDefaultFilterConditionValue(postFilterConditionState) {
+        const propertyType = postFilterConditionState.columnState.getReturnType();
+        switch (propertyType?.path) {
+            case PRIMITIVE_TYPE.STRING: {
+                return buildPrimitiveInstanceValue(postFilterConditionState.postFilterState.projectionState
+                    .queryBuilderState.graphManagerState.graph, propertyType.path, generateDefaultValueForPrimitiveType(propertyType.path));
+            }
+            default:
+                throw new UnsupportedOperationError(`Can't get default value for post-filter operator '${this.getLabel()}' when the LHS property is of type '${propertyType?.path}'`);
+        }
+    }
+    buildPostFilterConditionExpression(postFilterConditionState) {
+        return buildPostFilterConditionExpression(postFilterConditionState, this, QUERY_BUILDER_SUPPORTED_FUNCTIONS.STARTS_WITH);
+    }
+    buildPostFilterConditionState(postFilterState, expression) {
+        return buildPostFilterConditionState(postFilterState, expression, QUERY_BUILDER_SUPPORTED_FUNCTIONS.STARTS_WITH, this);
+    }
+}
+export class QueryBuilderPostFilterOperator_NotStartWith extends QueryBuilderPostFilterOperator_StartWith {
+    getLabel() {
+        return `doesn't start with`;
+    }
+    buildPostFilterConditionExpression(postFilterConditionState) {
+        const expression = super.buildPostFilterConditionExpression(postFilterConditionState);
+        return expression
+            ? buildNotExpression(postFilterConditionState.postFilterState.projectionState
+                .queryBuilderState.graphManagerState.graph, expression)
+            : undefined;
+    }
+    buildPostFilterConditionState(postFilterState, expression) {
+        const innerExpression = unwrapNotExpression(expression);
+        return innerExpression
+            ? super.buildPostFilterConditionState(postFilterState, innerExpression)
+            : undefined;
+    }
+}
+//# sourceMappingURL=QueryBuilderPostFilterOperator_StartWith.js.map

package/lib/stores/query-builder/fetch-structure/projection/post-filter/operators/QueryBuilderPostFilterOperator_StartWith.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryBuilderPostFilterOperator_StartWith.js","sourceRoot":"","sources":["../../../../../../../src/stores/query-builder/fetch-structure/projection/post-filter/operators/QueryBuilderPostFilterOperator_StartWith.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAKL,cAAc,EACd,2BAA2B,GAC5B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,EAAE,8BAA8B,EAAE,MAAM,sCAAsC,CAAC;AACtF,OAAO,EAAE,6BAA6B,EAAE,MAAM,0CAA0C,CAAC;AAKzF,OAAO,EACL,kBAAkB,EAClB,oCAAoC,EACpC,sCAAsC,EACtC,mBAAmB,GACpB,MAAM,qDAAqD,CAAC;AAC7D,OAAO,EAAE,kCAAkC,EAAE,MAAM,2CAA2C,CAAC;AAC/F,OAAO,EAAE,iCAAiC,EAAE,MAAM,kEAAkE,CAAC;AAErH,MAAM,OAAO,wCAAyC,SAAQ,8BAA8B;IAC1F,QAAQ;QACN,OAAO,aAAa,CAAC;IACvB,CAAC;IAED,oBAAoB,CAAC,IAAU;QAC7B,IAAI,IAAI,CAAC,IAAI,KAAK,cAAc,CAAC,MAAM,EAAE;YACvC,OAAO,IAAI,CAAC;SACb;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,8BAA8B,CAC5B,wBAAkD;QAElD,MAAM,IAAI,GAAG,wBAAwB,CAAC,KAAK;YACzC,CAAC,CAAC,sCAAsC,CAAC,wBAAwB,CAAC,KAAK,CAAC;YACxE,CAAC,CAAC,SAAS,CAAC;QACd,OAAO,cAAc,CAAC,MAAM,KAAK,IAAI,EAAE,IAAI,CAAC;IAC9C,CAAC;IAED,8BAA8B,CAC5B,wBAAkD;QAElD,MAAM,YAAY,GAAG,wBAAwB,CAAC,WAAW,CAAC,aAAa,EAAE,CAAC;QAC1E,QAAQ,YAAY,EAAE,IAAI,EAAE;YAC1B,KAAK,cAAc,CAAC,MAAM,CAAC,CAAC;gBAC1B,OAAO,2BAA2B,CAChC,wBAAwB,CAAC,eAAe,CAAC,eAAe;qBACrD,iBAAiB,CAAC,iBAAiB,CAAC,KAAK,EAC5C,YAAY,CAAC,IAAI,EACjB,oCAAoC,CAAC,YAAY,CAAC,IAAI,CAAC,CACxD,CAAC;aACH;YACD;gBACE,MAAM,IAAI,yBAAyB,CACjC,qDAAqD,IAAI,CAAC,QAAQ,EAAE,uCAClE,YAAY,EAAE,IAChB,GAAG,CACJ,CAAC;SACL;IACH,CAAC;IAED,kCAAkC,CAChC,wBAAkD;QAElD,OAAO,kCAAkC,CACvC,wBAAwB,EACxB,IAAI,EACJ,iCAAiC,CAAC,WAAW,CAC9C,CAAC;IACJ,CAAC;IAED,6BAA6B,CAC3B,eAA4C,EAC5C,UAA8B;QAE9B,OAAO,6BAA6B,CAClC,eAAe,EACf,UAAU,EACV,iCAAiC,CAAC,WAAW,EAC7C,IAAI,CACL,CAAC;IACJ,CAAC;CACF;AACD,MAAM,OAAO,2CAA4C,SAAQ,wCAAwC;IAC9F,QAAQ;QACf,OAAO,oBAAoB,CAAC;IAC9B,CAAC;IAEQ,kCAAkC,CACzC,wBAAkD;QAElD,MAAM,UAAU,GAAG,KAAK,CAAC,kCAAkC,CACzD,wBAAwB,CACzB,CAAC;QACF,OAAO,UAAU;YACf,CAAC,CAAC,kBAAkB,CAChB,wBAAwB,CAAC,eAAe,CAAC,eAAe;iBACrD,iBAAiB,CAAC,iBAAiB,CAAC,KAAK,EAC5C,UAAU,CACX;YACH,CAAC,CAAC,SAAS,CAAC;IAChB,CAAC;IAEQ,6BAA6B,CACpC,eAA4C,EAC5C,UAAoC;QAEpC,MAAM,eAAe,GAAG,mBAAmB,CAAC,UAAU,CAAC,CAAC;QACxD,OAAO,eAAe;YACpB,CAAC,CAAC,KAAK,CAAC,6BAA6B,CAAC,eAAe,EAAE,eAAe,CAAC;YACvE,CAAC,CAAC,SAAS,CAAC;IAChB,CAAC;CACF"}

package/lib/stores/query-builder/filter/QueryBuilderFilterOperator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryBuilderFilterOperator.d.ts","sourceRoot":"","sources":["../../../../src/stores/query-builder/filter/QueryBuilderFilterOperator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EACV,wBAAwB,EACxB,kBAAkB,EACnB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EACV,oBAAoB,EACpB,uBAAuB,EACxB,MAAM,8BAA8B,CAAC;AAEtC,8BAAsB,0BAA0B;IAC9C,QAAQ,CAAC,IAAI,SAAU;IAEvB,QAAQ,CAAC,QAAQ,CAAC,oBAAoB,EAAE,oBAAoB,GAAG,MAAM;IAErE,QAAQ,CAAC,uCAAuC,CAC9C,oBAAoB,EAAE,oBAAoB,GACzC,OAAO;IAEV,QAAQ,CAAC,oCAAoC,CAC3C,oBAAoB,EAAE,oBAAoB,GACzC,OAAO;IAEV,QAAQ,CAAC,8BAA8B,CACrC,oBAAoB,EAAE,oBAAoB,GACzC,kBAAkB,GAAG,SAAS;IAEjC,QAAQ,CAAC,8BAA8B,CACrC,oBAAoB,EAAE,oBAAoB,GACzC,kBAAkB;IAErB,QAAQ,CAAC,yBAAyB,CAChC,WAAW,EAAE,uBAAuB,EACpC,UAAU,EAAE,wBAAwB,GACnC,oBAAoB,GAAG,SAAS;CACpC"}

package/lib/stores/query-builder/filter/QueryBuilderFilterOperator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryBuilderFilterOperator.js","sourceRoot":"","sources":["../../../../src/stores/query-builder/filter/QueryBuilderFilterOperator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAMH,OAAO,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAC;AAM5C,MAAM,OAAgB,0BAA0B;IACrC,IAAI,GAAG,IAAI,EAAE,CAAC;CAwBxB"}

package/lib/stores/query-builder/filter/QueryBuilderFilterOperatorLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryBuilderFilterOperatorLoader.d.ts","sourceRoot":"","sources":["../../../../src/stores/query-builder/filter/QueryBuilderFilterOperatorLoader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AA8BH,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAC;AAElF,eAAO,MAAM,kCAAkC,QACzC,0BAA0B,EAiB7B,CAAC"}

package/lib/stores/query-builder/filter/QueryBuilderFilterOperatorLoader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryBuilderFilterOperatorLoader.js","sourceRoot":"","sources":["../../../../src/stores/query-builder/filter/QueryBuilderFilterOperatorLoader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EACL,gCAAgC,EAChC,mCAAmC,GACpC,MAAM,iDAAiD,CAAC;AACzD,OAAO,EAAE,sCAAsC,EAAE,MAAM,uDAAuD,CAAC;AAC/G,OAAO,EACL,uCAAuC,EACvC,oCAAoC,GACrC,MAAM,qDAAqD,CAAC;AAC7D,OAAO,EAAE,2CAA2C,EAAE,MAAM,4DAA4D,CAAC;AACzH,OAAO,EAAE,wCAAwC,EAAE,MAAM,yDAAyD,CAAC;AACnH,OAAO,EAAE,mCAAmC,EAAE,MAAM,oDAAoD,CAAC;AACzG,OAAO,EACL,kCAAkC,EAClC,qCAAqC,GACtC,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EACL,kCAAkC,EAClC,qCAAqC,GACtC,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EACL,kCAAkC,EAClC,qCAAqC,GACtC,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EACL,6BAA6B,EAC7B,gCAAgC,GACjC,MAAM,8CAA8C,CAAC;AAGtD,MAAM,CAAC,MAAM,kCAAkC,GAC7C,GAAiC,EAAE,CAAC;IAClC,IAAI,gCAAgC,EAAE;IACtC,IAAI,mCAAmC,EAAE;IACzC,IAAI,mCAAmC,EAAE;IACzC,IAAI,wCAAwC,EAAE;IAC9C,IAAI,sCAAsC,EAAE;IAC5C,IAAI,2CAA2C,EAAE;IACjD,IAAI,oCAAoC,EAAE;IAC1C,IAAI,uCAAuC,EAAE;IAC7C,IAAI,kCAAkC,EAAE;IACxC,IAAI,qCAAqC,EAAE;IAC3C,IAAI,kCAAkC,EAAE;IACxC,IAAI,qCAAqC,EAAE;IAC3C,IAAI,6BAA6B,EAAE;IACnC,IAAI,gCAAgC,EAAE;IACtC,IAAI,kCAAkC,EAAE;IACxC,IAAI,qCAAqC,EAAE;CAC5C,CAAC"}

package/lib/stores/query-builder/filter/QueryBuilderFilterState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryBuilderFilterState.d.ts","sourceRoot":"","sources":["../../../../src/stores/query-builder/filter/QueryBuilderFilterState.ts"],"names":[],"mappings":"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"}

package/lib/stores/query-builder/filter/QueryBuilderFilterState.js

@@ -0,0 +1,531 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { action, computed, makeAutoObservable, makeObservable, observable, flow, } from 'mobx';
+import { assertTrue, getNullableFirstElement, guaranteeNonNullable, guaranteeType, IllegalStateError, uuid, addUniqueEntry, deleteEntry, assertErrorThrown, filterByType, ActionState, } from '@finos/legend-shared';
+import { QueryBuilderPropertyExpressionState } from '../QueryBuilderPropertyEditorState.js';
+import { observe_ValueSpecification, } from '@finos/legend-graph';
+import { DEFAULT_LAMBDA_VARIABLE_NAME } from '../QueryBuilderConfig.js';
+import { buildPropertyTypeaheadQuery, buildTypeaheadOptions, performTypeahead, } from '../QueryBuilderTypeaheadHelper.js';
+import { QUERY_BUILDER_GROUP_OPERATION } from '../QueryBuilderGroupOperationHelper.js';
+export var QUERY_BUILDER_FILTER_DND_TYPE;
+(function (QUERY_BUILDER_FILTER_DND_TYPE) {
+    QUERY_BUILDER_FILTER_DND_TYPE["GROUP_CONDITION"] = "GROUP_CONDITION";
+    QUERY_BUILDER_FILTER_DND_TYPE["CONDITION"] = "CONDITION";
+    QUERY_BUILDER_FILTER_DND_TYPE["BLANK_CONDITION"] = "BLANK_CONDITION";
+})(QUERY_BUILDER_FILTER_DND_TYPE = QUERY_BUILDER_FILTER_DND_TYPE || (QUERY_BUILDER_FILTER_DND_TYPE = {}));
+export class FilterConditionState {
+    filterState;
+    propertyExpressionState;
+    operator;
+    value;
+    existsLambdaParamNames = [];
+    typeaheadSearchResults;
+    typeaheadSearchState = ActionState.create();
+    constructor(filterState, propertyExpression) {
+        makeAutoObservable(this, {
+            filterState: false,
+            operators: computed,
+            changeProperty: action,
+            changeOperator: action,
+            setOperator: action,
+            setValue: action,
+            typeaheadSearchResults: observable,
+            typeaheadSearchState: observable,
+            addExistsLambdaParamNames: action,
+            handleTypeaheadSearch: flow,
+        });
+        this.filterState = filterState;
+        this.propertyExpressionState = new QueryBuilderPropertyExpressionState(filterState.queryBuilderState, propertyExpression);
+        // operator
+        assertTrue(this.operators.length !== 0, `Can't find an operator for property '${this.propertyExpressionState.path}': no operators registered`);
+        this.operator = this.operators[0];
+        this.setValue(this.operator.getDefaultFilterConditionValue(this));
+    }
+    get operators() {
+        return this.filterState.operators.filter((op) => op.isCompatibleWithFilterConditionProperty(this));
+    }
+    *handleTypeaheadSearch() {
+        try {
+            this.typeaheadSearchState.inProgress();
+            this.typeaheadSearchResults = undefined;
+            if (performTypeahead(this.value)) {
+                const result = (yield this.filterState.queryBuilderState.graphManagerState.graphManager.executeMapping(buildPropertyTypeaheadQuery(this.filterState.queryBuilderState, this.propertyExpressionState.propertyExpression, this.value), guaranteeNonNullable(this.filterState.queryBuilderState.mapping), guaranteeNonNullable(this.filterState.queryBuilderState.runtimeValue), this.filterState.queryBuilderState.graphManagerState.graph));
+                this.typeaheadSearchResults = buildTypeaheadOptions(result);
+            }
+            this.typeaheadSearchState.pass();
+        }
+        catch (error) {
+            assertErrorThrown(error);
+            this.typeaheadSearchResults = [];
+            this.typeaheadSearchState.fail();
+        }
+        finally {
+            this.typeaheadSearchState.complete();
+        }
+    }
+    changeProperty(propertyExpression) {
+        try {
+            // first, check if the new property is supported
+            new FilterConditionState(this.filterState, propertyExpression);
+        }
+        catch (error) {
+            assertErrorThrown(error);
+            this.filterState.queryBuilderState.applicationStore.notifyError(error);
+            return;
+        }
+        // observe the property expression
+        observe_ValueSpecification(propertyExpression, this.filterState.queryBuilderState.observableContext);
+        this.propertyExpressionState = new QueryBuilderPropertyExpressionState(this.filterState.queryBuilderState, propertyExpression);
+        const newCompatibleOperators = this.operators;
+        assertTrue(newCompatibleOperators.length !== 0, `Can't find an operator for property '${this.propertyExpressionState.path}': no operators registered`);
+        if (!newCompatibleOperators.includes(this.operator)) {
+            this.changeOperator(newCompatibleOperators[0]);
+        }
+        else if (!this.operator.isCompatibleWithFilterConditionValue(this)) {
+            this.setValue(this.operator.getDefaultFilterConditionValue(this));
+        }
+    }
+    changeOperator(val) {
+        this.setOperator(val);
+        if (!this.operator.isCompatibleWithFilterConditionValue(this)) {
+            this.setValue(this.operator.getDefaultFilterConditionValue(this));
+        }
+    }
+    setOperator(val) {
+        this.operator = val;
+    }
+    setValue(val) {
+        this.value = val
+            ? observe_ValueSpecification(val, this.filterState.queryBuilderState.observableContext)
+            : undefined;
+    }
+    addExistsLambdaParamNames(val) {
+        this.existsLambdaParamNames.push(val);
+    }
+}
+export class QueryBuilderFilterTreeNodeData {
+    id = uuid();
+    label = '';
+    // NOTE: we don't use the `isSelected` attribute is not used since we keep track of it from the tree data level
+    isOpen;
+    parentId;
+    constructor(parentId) {
+        this.parentId = parentId;
+        makeObservable(this, {
+            isOpen: observable,
+            parentId: observable,
+            setIsOpen: action,
+            setParentId: action,
+        });
+    }
+    setIsOpen(val) {
+        this.isOpen = val;
+    }
+    setParentId(val) {
+        this.parentId = val;
+    }
+}
+export class QueryBuilderFilterTreeGroupNodeData extends QueryBuilderFilterTreeNodeData {
+    groupOperation;
+    childrenIds = [];
+    constructor(parentId, groupOperation) {
+        super(parentId);
+        makeObservable(this, {
+            groupOperation: observable,
+            childrenIds: observable,
+            setGroupOperation: action,
+            addChildNode: action,
+            removeChildNode: action,
+            dragPreviewLabel: computed,
+        });
+        this.groupOperation = groupOperation;
+        this.isOpen = true;
+    }
+    get dragPreviewLabel() {
+        return `${this.groupOperation.toUpperCase()} group`;
+    }
+    setGroupOperation(val) {
+        this.groupOperation = val;
+    }
+    addChildNode(node) {
+        addUniqueEntry(this.childrenIds, node.id);
+        node.setParentId(this.id);
+    }
+    removeChildNode(node) {
+        deleteEntry(this.childrenIds, node.id);
+        node.setParentId(undefined);
+    }
+    addChildNodeAt(node, idx) {
+        if (!this.childrenIds.find((childId) => childId === node.id)) {
+            idx = Math.max(0, Math.min(idx, this.childrenIds.length - 1));
+            this.childrenIds.splice(idx, 0, node.id);
+            node.setParentId(this.id);
+        }
+    }
+}
+export class QueryBuilderFilterTreeConditionNodeData extends QueryBuilderFilterTreeNodeData {
+    condition;
+    constructor(parentId, condition) {
+        super(parentId);
+        makeObservable(this, {
+            condition: observable,
+            dragPreviewLabel: computed,
+        });
+        this.condition = condition;
+    }
+    get dragPreviewLabel() {
+        return this.condition.propertyExpressionState.title;
+    }
+}
+export class QueryBuilderFilterTreeBlankConditionNodeData extends QueryBuilderFilterTreeNodeData {
+    constructor(parentId) {
+        super(parentId);
+        makeObservable(this, {
+            dragPreviewLabel: computed,
+        });
+    }
+    get dragPreviewLabel() {
+        return '<blank>';
+    }
+}
+export class QueryBuilderFilterState {
+    queryBuilderState;
+    lambdaParameterName = DEFAULT_LAMBDA_VARIABLE_NAME;
+    rootIds = [];
+    nodes = new Map();
+    selectedNode;
+    isRearrangingConditions = false;
+    operators = [];
+    _suppressClickawayEventListener = false;
+    constructor(queryBuilderState, operators) {
+        makeAutoObservable(this, {
+            queryBuilderState: false,
+            isValidMove: false,
+            setLambdaParameterName: action,
+            setRearrangingConditions: action,
+            suppressClickawayEventListener: action,
+            handleClickaway: action,
+            setSelectedNode: action,
+            addNodeFromNode: action,
+            replaceBlankNodeWithNode: action,
+            addGroupConditionNodeFromNode: action,
+            newGroupWithConditionFromNode: action,
+            removeNodeAndPruneBranch: action,
+            pruneTree: action,
+            simplifyTree: action,
+            collapseTree: action,
+            expandTree: action,
+        });
+        this.queryBuilderState = queryBuilderState;
+        this.operators = operators;
+    }
+    get isEmpty() {
+        return !this.nodes.size && !this.rootIds.length;
+    }
+    setLambdaParameterName(val) {
+        this.lambdaParameterName = val;
+    }
+    setRearrangingConditions(val) {
+        this.isRearrangingConditions = val;
+    }
+    suppressClickawayEventListener() {
+        this._suppressClickawayEventListener = true;
+    }
+    handleClickaway() {
+        if (this._suppressClickawayEventListener) {
+            this._suppressClickawayEventListener = false;
+            return;
+        }
+        this.setSelectedNode(undefined);
+    }
+    setSelectedNode(val) {
+        this.selectedNode = val;
+    }
+    getNode(id) {
+        return guaranteeNonNullable(this.nodes.get(id), `Can't find query builder filter tree node with ID '${id}'`);
+    }
+    getRootNode() {
+        assertTrue(this.rootIds.length < 2, 'Query builder filter tree cannot have more than 1 root');
+        const rootId = getNullableFirstElement(this.rootIds);
+        return rootId ? this.getNode(rootId) : undefined;
+    }
+    getParentNode(node) {
+        return node.parentId
+            ? guaranteeType(this.nodes.get(node.parentId), QueryBuilderFilterTreeGroupNodeData)
+            : undefined;
+    }
+    addRootNode(node) {
+        const rootNode = this.getRootNode();
+        this.nodes.set(node.id, node);
+        if (rootNode instanceof QueryBuilderFilterTreeGroupNodeData) {
+            rootNode.addChildNode(node);
+        }
+        else if (rootNode instanceof QueryBuilderFilterTreeConditionNodeData ||
+            rootNode instanceof QueryBuilderFilterTreeBlankConditionNodeData) {
+            // if the root node is condition node, form a group between the root node and the new node and nominate the group node as the new root
+            const groupNode = new QueryBuilderFilterTreeGroupNodeData(undefined, QUERY_BUILDER_GROUP_OPERATION.AND);
+            groupNode.addChildNode(rootNode);
+            groupNode.addChildNode(node);
+            this.rootIds = [groupNode.id];
+            this.nodes.set(groupNode.id, groupNode);
+        }
+        else if (!rootNode) {
+            // if there is no root node, set this node as the root
+            this.rootIds = [node.id];
+        }
+    }
+    addNodeFromNode(node, fromNode) {
+        if (fromNode instanceof QueryBuilderFilterTreeGroupNodeData) {
+            this.nodes.set(node.id, node);
+            fromNode.addChildNode(node);
+        }
+        else if (fromNode instanceof QueryBuilderFilterTreeConditionNodeData ||
+            fromNode instanceof QueryBuilderFilterTreeBlankConditionNodeData) {
+            this.nodes.set(node.id, node);
+            const fromNodeParent = this.getParentNode(fromNode);
+            if (fromNodeParent) {
+                fromNodeParent.addChildNode(node);
+            }
+            else {
+                this.addRootNode(node);
+            }
+        }
+        else if (!this.selectedNode) {
+            // if no current node is selected, the node will be added to root
+            this.addRootNode(node);
+        }
+    }
+    replaceBlankNodeWithNode(node, blankNode) {
+        this.nodes.set(node.id, node);
+        const blankNodeParent = this.getParentNode(blankNode);
+        if (blankNodeParent) {
+            const blankNodeIdx = blankNodeParent.childrenIds.findIndex((childId) => childId === blankNode.id);
+            blankNodeParent.addChildNodeAt(node, blankNodeIdx);
+            blankNodeParent.removeChildNode(blankNode);
+        }
+        else {
+            this.addRootNode(node);
+        }
+        this.removeNode(blankNode);
+    }
+    addGroupConditionNodeFromNode(fromNode) {
+        const newGroupNode = new QueryBuilderFilterTreeGroupNodeData(undefined, QUERY_BUILDER_GROUP_OPERATION.AND);
+        const newBlankConditionNode1 = new QueryBuilderFilterTreeBlankConditionNodeData(undefined);
+        const newBlankConditionNode2 = new QueryBuilderFilterTreeBlankConditionNodeData(undefined);
+        this.nodes.set(newBlankConditionNode1.id, newBlankConditionNode1);
+        this.nodes.set(newBlankConditionNode2.id, newBlankConditionNode2);
+        newGroupNode.addChildNode(newBlankConditionNode1);
+        newGroupNode.addChildNode(newBlankConditionNode2);
+        this.addNodeFromNode(newGroupNode, fromNode);
+    }
+    newGroupWithConditionFromNode(node, fromNode) {
+        const newNode = node ?? new QueryBuilderFilterTreeBlankConditionNodeData(undefined);
+        if (fromNode instanceof QueryBuilderFilterTreeConditionNodeData) {
+            const fromNodeParent = this.getParentNode(fromNode);
+            if (fromNodeParent) {
+                const fromNodeIdx = fromNodeParent.childrenIds.findIndex((childId) => childId === fromNode.id);
+                fromNodeParent.removeChildNode(fromNode);
+                const newGroupNode = new QueryBuilderFilterTreeGroupNodeData(undefined, QUERY_BUILDER_GROUP_OPERATION.AND);
+                this.nodes.set(newNode.id, newNode);
+                this.nodes.set(newGroupNode.id, newGroupNode);
+                newGroupNode.addChildNode(fromNode);
+                newGroupNode.addChildNode(newNode);
+                fromNodeParent.addChildNodeAt(newGroupNode, fromNodeIdx);
+            }
+            else {
+                this.addRootNode(newNode);
+            }
+        }
+    }
+    removeNode(node) {
+        this.nodes.delete(node.id);
+        // remove relationship with children nodes
+        if (node instanceof QueryBuilderFilterTreeGroupNodeData) {
+            // NOTE: we are deleting child node, i.e. modifying `childrenIds` as we iterate
+            [...node.childrenIds].forEach((childId) => node.removeChildNode(this.getNode(childId)));
+        }
+        // remove relationship with parent node
+        const parentNode = this.getParentNode(node);
+        if (parentNode) {
+            parentNode.removeChildNode(node);
+        }
+        else {
+            deleteEntry(this.rootIds, node.id);
+        }
+    }
+    pruneChildlessGroupNodes() {
+        const getChildlessGroupNodes = () => Array.from(this.nodes.values())
+            .filter(filterByType(QueryBuilderFilterTreeGroupNodeData))
+            .filter((node) => !node.childrenIds.length);
+        let nodesToProcess = getChildlessGroupNodes();
+        while (nodesToProcess.length) {
+            nodesToProcess.forEach((node) => this.removeNode(node));
+            nodesToProcess = getChildlessGroupNodes();
+        }
+    }
+    pruneOrphanNodes() {
+        const getOrphanNodes = () => Array.from(this.nodes.values()).filter((node) => !node.parentId && !this.rootIds.includes(node.id)); // nodes without parent, except for root nodes
+        let nodesToProcess = getOrphanNodes();
+        while (nodesToProcess.length) {
+            nodesToProcess.forEach((node) => this.removeNode(node));
+            nodesToProcess = getOrphanNodes();
+        }
+    }
+    /**
+     * If group node has fewer than 2 children, flatten it
+     */
+    squashGroupNode(node) {
+        if (node.childrenIds.length < 2) {
+            const parentNode = this.getParentNode(node);
+            // NOTE: we are deleting child node, i.e. modifying `childrenIds` as we iterate
+            [...node.childrenIds].forEach((childId) => {
+                const childNode = this.getNode(childId);
+                node.removeChildNode(childNode);
+                if (parentNode) {
+                    parentNode.addChildNode(childNode);
+                }
+                else {
+                    addUniqueEntry(this.rootIds, childId);
+                }
+            });
+            // remove the group node
+            this.nodes.delete(node.id);
+            if (parentNode) {
+                parentNode.removeChildNode(node);
+            }
+            else {
+                deleteEntry(this.rootIds, node.id);
+            }
+        }
+    }
+    removeNodeAndPruneBranch(node) {
+        const parentNode = this.getParentNode(node);
+        this.removeNode(node);
+        // squash parent node after the current node is deleted
+        if (parentNode) {
+            parentNode.removeChildNode(node);
+            let currentParentNode = parentNode;
+            while (currentParentNode) {
+                if (currentParentNode.childrenIds.length >= 2) {
+                    break;
+                }
+                this.squashGroupNode(currentParentNode);
+                currentParentNode = this.getParentNode(currentParentNode);
+            }
+        }
+        else {
+            deleteEntry(this.rootIds, node.id);
+        }
+        this.pruneOrphanNodes();
+        // check if selected node is still around, if not, unset the selected node
+        if (this.selectedNode && !this.nodes.get(this.selectedNode.id)) {
+            this.setSelectedNode(undefined);
+        }
+    }
+    pruneTree() {
+        this.setSelectedNode(undefined);
+        // remove all blank nodes
+        Array.from(this.nodes.values())
+            .filter((node) => node instanceof QueryBuilderFilterTreeBlankConditionNodeData)
+            .forEach((node) => this.removeNode(node));
+        // prune
+        this.pruneOrphanNodes();
+        this.pruneChildlessGroupNodes();
+        // squash group nodes
+        // NOTE: since we have pruned all blank nodes and childless group nodes, at this point, if there are group nodes to be squashed
+        // it will be group node with exactly 1 non-blank condition
+        const getSquashableGroupNodes = () => Array.from(this.nodes.values())
+            .filter(filterByType(QueryBuilderFilterTreeGroupNodeData))
+            .filter((node) => node.childrenIds.length < 2)
+            .filter((node) => {
+            if (!node.childrenIds.length) {
+                throw new IllegalStateError('Query builder filter tree found unexpected childless group nodes');
+            }
+            const firstChildNodeId = node.childrenIds[0];
+            const childNode = this.getNode(firstChildNodeId);
+            if (childNode instanceof QueryBuilderFilterTreeBlankConditionNodeData) {
+                throw new IllegalStateError('Query builder filter tree found unexpected blank nodes');
+            }
+            return (this.getNode(firstChildNodeId) instanceof
+                QueryBuilderFilterTreeConditionNodeData);
+        });
+        let nodesToProcess = getSquashableGroupNodes();
+        while (nodesToProcess.length) {
+            nodesToProcess.forEach((node) => this.squashGroupNode(node));
+            nodesToProcess = getSquashableGroupNodes();
+        }
+        // check if selected node is still around, if not, unset the selected node
+        if (this.selectedNode && !this.nodes.get(this.selectedNode.id)) {
+            this.setSelectedNode(undefined);
+        }
+    }
+    /**
+     * Cleanup unecessary group nodes (i.e. group node whose group operation is the same as its parent's)
+     */
+    simplifyTree() {
+        this.setSelectedNode(undefined);
+        const getUnnecessaryNodes = () => Array.from(this.nodes.values())
+            .filter(filterByType(QueryBuilderFilterTreeGroupNodeData))
+            .filter((node) => {
+            if (!node.parentId || !this.nodes.has(node.parentId)) {
+                return false;
+            }
+            const parentGroupNode = guaranteeType(this.nodes.get(node.parentId), QueryBuilderFilterTreeGroupNodeData);
+            return parentGroupNode.groupOperation === node.groupOperation;
+        });
+        // Squash these unnecessary group nodes
+        let nodesToProcess = getUnnecessaryNodes();
+        while (nodesToProcess.length) {
+            nodesToProcess.forEach((node) => {
+                const parentNode = guaranteeType(this.nodes.get(guaranteeNonNullable(node.parentId)), QueryBuilderFilterTreeGroupNodeData);
+                // send all children of the current group node to their grandparent node
+                [...node.childrenIds].forEach((childId) => {
+                    const childNode = this.getNode(childId);
+                    parentNode.addChildNode(childNode);
+                });
+                // remove the current group node
+                parentNode.removeChildNode(node);
+                // remove the node
+                this.nodes.delete(node.id);
+            });
+            nodesToProcess = getUnnecessaryNodes();
+        }
+    }
+    isValidMove(node, toNode) {
+        const isMovingToItself = node === toNode;
+        // disallow moving a node to its descendants
+        let isMovingToChildNode = false;
+        let currentParentNode = this.getParentNode(toNode);
+        while (currentParentNode) {
+            if (currentParentNode === node) {
+                isMovingToChildNode = true;
+                break;
+            }
+            currentParentNode = this.getParentNode(currentParentNode);
+        }
+        return !isMovingToItself && !isMovingToChildNode;
+    }
+    moveNode(node, toNode) {
+        // do something;
+    }
+    collapseTree() {
+        Array.from(this.nodes.values()).forEach((node) => node.setIsOpen(false));
+    }
+    expandTree() {
+        Array.from(this.nodes.values()).forEach((node) => node.setIsOpen(true));
+    }
+}
+//# sourceMappingURL=QueryBuilderFilterState.js.map