13784630843

Committed 11 Mar 2025 09:28AM CUT coverage: 4.027% (-87.6%) from 91.657%

Build # 13784630843

Build Type

Pull #15465

github

Committed by

web-flow

Commit Message

Merge c3f73a0e2 into 9898d98a6

Pull Request Pull Request #15465: [Query Builder] drag and drop refactor without DOM manipulations

Run Details

124 of 15563 branches covered (0.8%)

0 of 160 new or added lines in 2 files covered. (0.0%)

25607 existing lines in 325 files now uncovered.

1180 of 29304 relevant lines covered (4.03%)

0.29 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/projects/igniteui-angular/src/lib/grids/filtering/excel-style/common.ts

import { isTree } from '../../../data-operations/expressions-tree-util';
import { FilteringLogic, IFilteringExpression } from '../../../data-operations/filtering-expression.interface';
import { IFilteringExpressionsTree } from '../../../data-operations/filtering-expressions-tree';

/**
 * @hidden @internal
 */
export class FilterListItem {
    public value: any;
    public label: any;
    public isSelected: boolean;
    public indeterminate: boolean;
    public isFiltered: boolean;
    public isSpecial = false;
    public isBlanks = false;
    public children?: Array<FilterListItem>;
    public parent?: FilterListItem;
}

/**
 * @hidden
 */
export class ExpressionUI {
    public expressionId: string;
    public expression: IFilteringExpression;
    public beforeOperator: FilteringLogic;
    public afterOperator: FilteringLogic;
    public isSelected = false;
    public isVisible = true;

    constructor() {
        // Use IDs to identify expressions clearly and use to track them in template @for cycles.
        this.expressionId = crypto.randomUUID();
    }
}

/**
 * @hidden @internal
 */
export class ActiveElement {
    public index: number;
    public id: string;
    public checked: boolean;
}

export function generateExpressionsList(expressions: IFilteringExpressionsTree | IFilteringExpression,
    operator: FilteringLogic,
    expressionsUIs: ExpressionUI[]): void {
    generateExpressionsListRecursive(expressions, operator, expressionsUIs);

    // The beforeOperator of the first expression and the afterOperator of the last expression should be null
    if (expressionsUIs.length) {
        expressionsUIs[expressionsUIs.length - 1].afterOperator = null;
    }
}


function generateExpressionsListRecursive(expressions: IFilteringExpressionsTree | IFilteringExpression,
    operator: FilteringLogic,
    expressionsUIs: ExpressionUI[]): void {
    if (!expressions) {
        return;
    }

    if (isTree(expressions)) {
        for (const operand of expressions.filteringOperands) {
            generateExpressionsListRecursive(operand, expressions.operator, expressionsUIs);
        }
        if (expressionsUIs.length) {
            expressionsUIs[expressionsUIs.length - 1].afterOperator = operator;
        }
    } else {
        const exprUI = new ExpressionUI();
        exprUI.expression = expressions;
        exprUI.afterOperator = operator;

        const prevExprUI = expressionsUIs[expressionsUIs.length - 1];
        if (prevExprUI) {
            exprUI.beforeOperator = prevExprUI.afterOperator;
        }

        expressionsUIs.push(exprUI);
    }
}

1	import { isTree } from '../../../data-operations/expressions-tree-util';
2	import { FilteringLogic, IFilteringExpression } from '../../../data-operations/filtering-expression.interface';
3	import { IFilteringExpressionsTree } from '../../../data-operations/filtering-expressions-tree';
4
5	/**
6	* @hidden @internal
7	*/
8	export class FilterListItem {
9	public value: any;
10	public label: any;
11	public isSelected: boolean;
12	public indeterminate: boolean;
13	public isFiltered: boolean;
UNCOV 14	public isSpecial = false;	×
UNCOV 15	public isBlanks = false;	×
16	public children?: Array<FilterListItem>;
17	public parent?: FilterListItem;
18	}
19
20	/**
21	* @hidden
22	*/
23	export class ExpressionUI {
24	public expressionId: string;
25	public expression: IFilteringExpression;
26	public beforeOperator: FilteringLogic;
27	public afterOperator: FilteringLogic;
UNCOV 28	public isSelected = false;	×
UNCOV 29	public isVisible = true;	×
30
31	constructor() {
32	// Use IDs to identify expressions clearly and use to track them in template @for cycles.
UNCOV 33	this.expressionId = crypto.randomUUID();	×
34	}
35	}
36
37	/**
38	* @hidden @internal
39	*/
40	export class ActiveElement {
41	public index: number;
42	public id: string;
43	public checked: boolean;
44	}
45
46	export function generateExpressionsList(expressions: IFilteringExpressionsTree \| IFilteringExpression,
47	operator: FilteringLogic,
48	expressionsUIs: ExpressionUI[]): void {
UNCOV 49	generateExpressionsListRecursive(expressions, operator, expressionsUIs);	×
50
51	// The beforeOperator of the first expression and the afterOperator of the last expression should be null
UNCOV 52	if (expressionsUIs.length) {	×
UNCOV 53	expressionsUIs[expressionsUIs.length - 1].afterOperator = null;	×
54	}
55	}
56
57
58	function generateExpressionsListRecursive(expressions: IFilteringExpressionsTree \| IFilteringExpression,
59	operator: FilteringLogic,
60	expressionsUIs: ExpressionUI[]): void {
UNCOV 61	if (!expressions) {	×
UNCOV 62	return;	×
63	}
64
UNCOV 65	if (isTree(expressions)) {	×
UNCOV 66	for (const operand of expressions.filteringOperands) {	×
UNCOV 67	generateExpressionsListRecursive(operand, expressions.operator, expressionsUIs);	×
68	}
UNCOV 69	if (expressionsUIs.length) {	×
UNCOV 70	expressionsUIs[expressionsUIs.length - 1].afterOperator = operator;	×
71	}
72	} else {
UNCOV 73	const exprUI = new ExpressionUI();	×
UNCOV 74	exprUI.expression = expressions;	×
UNCOV 75	exprUI.afterOperator = operator;	×
76
UNCOV 77	const prevExprUI = expressionsUIs[expressionsUIs.length - 1];	×
UNCOV 78	if (prevExprUI) {	×
UNCOV 79	exprUI.beforeOperator = prevExprUI.afterOperator;	×
80	}
81
UNCOV 82	expressionsUIs.push(exprUI);	×
83	}
84	}

IgniteUI / igniteui-angular / 13784630843

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous