13331632524

Committed 14 Feb 2025 02:51PM CUT coverage: 22.015% (-69.6%) from 91.622%

Build # 13331632524

Build Type

Pull #15372

github

Committed by

web-flow

Commit Message

Merge d52d57714 into bcb78ae0a

Pull Request Pull Request #15372: chore(*): test ci passing

Run Details

1990 of 15592 branches covered (12.76%)

431 of 964 new or added lines in 18 files covered. (44.71%)

19956 existing lines in 307 files now uncovered.

6452 of 29307 relevant lines covered (22.02%)

249.17 hits per line

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

5.3

/projects/igniteui-angular/src/lib/grids/tree-grid/tree-grid.pipes.ts

import { Inject, Pipe, PipeTransform } from '@angular/core';
import { cloneArray, cloneHierarchicalArray } from '../../core/utils';
import { DataUtil } from '../../data-operations/data-util';
import { ITreeGridRecord } from './tree-grid.interfaces';
import { GridType, IGX_GRID_BASE } from '../common/grid.interface';
import { GridPagingMode } from '../common/enums';
import { TransactionType } from '../../services/public_api';
import { IgxAddRow } from '../common/crud.service';
import { ISortingExpression } from '../../data-operations/sorting-strategy';
import { IGridSortingStrategy } from '../common/strategy';
import { IGroupingExpression } from '../../data-operations/grouping-expression.interface';

/**
 * @hidden
 */
@Pipe({
    name: 'treeGridHierarchizing',
    standalone: true
})
export class IgxTreeGridHierarchizingPipe implements PipeTransform {

    constructor(@Inject(IGX_GRID_BASE) private grid: GridType) { }

    public transform(collection: any[], primaryKey: string, foreignKey: string, childDataKey: string, _: number): ITreeGridRecord[] {
        let hierarchicalRecords: ITreeGridRecord[] = [];
        const treeGridRecordsMap = new Map<any, ITreeGridRecord>();
        const flatData: any[] = [];

        if (!collection || !collection.length) {
            this.grid.flatData = collection;
            this.grid.records = treeGridRecordsMap;
            this.grid.rootRecords = collection;
            return collection;
        }

        if (childDataKey) {
            hierarchicalRecords = this.hierarchizeRecursive(collection, primaryKey, childDataKey, undefined,
                flatData, 0, treeGridRecordsMap);
        } else if (primaryKey) {
            hierarchicalRecords = this.hierarchizeFlatData(collection, primaryKey, foreignKey, treeGridRecordsMap, flatData);
        }

        this.grid.flatData = this.grid.transactions.enabled ?
            flatData.filter(rec => {
                const state = this.grid.transactions.getState(this.getRowID(primaryKey, rec));
                return !state || state.type !== TransactionType.ADD;
            }) : flatData;
        this.grid.records = treeGridRecordsMap;
        this.grid.rootRecords = hierarchicalRecords;
        return hierarchicalRecords;
    }

    private getRowID(primaryKey: any, rowData: any) {
        return primaryKey ? rowData[primaryKey] : rowData;
    }

    private hierarchizeFlatData(collection: any[], primaryKey: string, foreignKey: string,
        map: Map<any, ITreeGridRecord>, flatData: any[]):
        ITreeGridRecord[] {
        const result: ITreeGridRecord[] = [];
        const missingParentRecords: ITreeGridRecord[] = [];
        collection.forEach(row => {
            const record: ITreeGridRecord = {
                key: this.getRowID(primaryKey, row),
                data: row,
                children: []
            };
            const parent = map.get(row[foreignKey]);
            if (parent) {
                record.parent = parent;
                parent.children.push(record);
            } else {
                missingParentRecords.push(record);
            }

            map.set(row[primaryKey], record);
        });

        missingParentRecords.forEach(record => {
            const parent = map.get(record.data[foreignKey]);
            if (parent) {
                record.parent = parent;
                parent.children.push(record);
            } else {
                result.push(record);
            }
        });

        this.setIndentationLevels(result, 0, flatData);

        return result;
    }

    private setIndentationLevels(collection: ITreeGridRecord[], indentationLevel: number, flatData: any[]) {
        for (const record of collection) {
            record.level = indentationLevel;
            record.expanded = this.grid.gridAPI.get_row_expansion_state(record);
            flatData.push(record.data);

            if (record.children && record.children.length > 0) {
                this.setIndentationLevels(record.children, indentationLevel + 1, flatData);
            }
        }
    }

    private hierarchizeRecursive(collection: any[], primaryKey: string, childDataKey: string,
        parent: ITreeGridRecord, flatData: any[], indentationLevel: number, map: Map<any, ITreeGridRecord>): ITreeGridRecord[] {
        const result: ITreeGridRecord[] = [];

        for (const item of collection) {
            const record: ITreeGridRecord = {
                key: this.getRowID(primaryKey, item),
                data: item,
                parent,
                level: indentationLevel
            };
            record.expanded = this.grid.gridAPI.get_row_expansion_state(record);
            flatData.push(item);
            map.set(record.key, record);
            record.children = item[childDataKey] ?
                this.hierarchizeRecursive(item[childDataKey], primaryKey, childDataKey, record, flatData, indentationLevel + 1, map) :
                undefined;
            result.push(record);
        }

        return result;
    }
}

/**
 * @hidden
 */
@Pipe({
    name: 'treeGridFlattening',
    standalone: true
})
export class IgxTreeGridFlatteningPipe implements PipeTransform {

    constructor(@Inject(IGX_GRID_BASE) private grid: GridType) { }

    public transform(collection: ITreeGridRecord[],
        expandedLevels: number, expandedStates: Map<any, boolean>, _: number): any[] {

        const data: ITreeGridRecord[] = [];

        this.grid.processedRootRecords = collection;
        this.grid.processedRecords = new Map<any, ITreeGridRecord>();

        this.getFlatDataRecursive(collection, data, expandedLevels, expandedStates, true);

        this.grid.processedExpandedFlatData = data.map(r => r.data);

        return data;
    }

    private getFlatDataRecursive(collection: ITreeGridRecord[], data: ITreeGridRecord[],
        expandedLevels: number, expandedStates: Map<any, boolean>, parentExpanded: boolean) {
        if (!collection || !collection.length) {
            return;
        }

        for (const hierarchicalRecord of collection) {
            if (parentExpanded) {
                data.push(hierarchicalRecord);
            }

            hierarchicalRecord.expanded = this.grid.gridAPI.get_row_expansion_state(hierarchicalRecord);

            this.updateNonProcessedRecordExpansion(this.grid, hierarchicalRecord);

            this.grid.processedRecords.set(hierarchicalRecord.key, hierarchicalRecord);

            this.getFlatDataRecursive(hierarchicalRecord.children, data, expandedLevels,
                expandedStates, parentExpanded && hierarchicalRecord.expanded);
        }
    }

    private updateNonProcessedRecordExpansion(grid: GridType, record: ITreeGridRecord) {
        const rec = grid.records.get(record.key);
        rec.expanded = record.expanded;
    }
}

/** @hidden */
@Pipe({
    name: 'treeGridSorting',
    standalone: true
})
export class IgxTreeGridSortingPipe implements PipeTransform {

    constructor(@Inject(IGX_GRID_BASE) private grid: GridType) { }

    public transform(
        hierarchicalData: ITreeGridRecord[],
        sortExpressions: ISortingExpression[],
        groupExpressions: IGroupingExpression[],
        sorting: IGridSortingStrategy,
        _: number,
        pinned?: boolean): ITreeGridRecord[] {

        const expressions = groupExpressions ? groupExpressions.concat(sortExpressions) : sortExpressions;
        let result: ITreeGridRecord[];
        if (!expressions.length) {
            result = hierarchicalData;
        } else {
            result = DataUtil.treeGridSort(hierarchicalData, expressions, sorting, null, this.grid);
        }

        const filteredSortedData = [];
        this.flattenTreeGridRecords(result, filteredSortedData);
        this.grid.setFilteredSortedData(filteredSortedData, pinned);

        return result;
    }

    private flattenTreeGridRecords(records: ITreeGridRecord[], flatData: any[]) {
        if (records && records.length) {
            for (const record of records) {
                flatData.push(record.data);
                this.flattenTreeGridRecords(record.children, flatData);
            }
        }
    }
}

/** @hidden */
@Pipe({
    name: 'treeGridPaging',
    standalone: true
})
export class IgxTreeGridPagingPipe implements PipeTransform {

    constructor(@Inject(IGX_GRID_BASE) private grid: GridType) { }

    public transform(collection: ITreeGridRecord[], enabled: boolean, page = 0, perPage = 15, _: number): ITreeGridRecord[] {
        if (!enabled || this.grid.pagingMode !== GridPagingMode.Local) {
            return collection;
        }

        const len = this.grid._totalRecords >= 0 ? this.grid._totalRecords : collection.length;
        const totalPages = Math.ceil(len / perPage);

        const state = {
            index: (totalPages > 0 && page >= totalPages) ? totalPages - 1 : page,
            recordsPerPage: perPage
        };

        const result: ITreeGridRecord[] = DataUtil.page(cloneArray(collection), state, len);
        this.grid.pagingState = state;
        this.grid.page = state.index;

        return result;
    }
}
/** @hidden */
@Pipe({
    name: 'treeGridTransaction',
    standalone: true
})
export class IgxTreeGridTransactionPipe implements PipeTransform {


    constructor(@Inject(IGX_GRID_BASE) private grid: GridType) { }

    public transform(collection: any[], _: number): any[] {

        if (this.grid.transactions.enabled) {
            const aggregatedChanges = this.grid.transactions.getAggregatedChanges(true);
            if (aggregatedChanges.length > 0) {
                const primaryKey = this.grid.primaryKey;
                if (!primaryKey) {
                    return collection;
                }

                const childDataKey = this.grid.childDataKey;

                if (childDataKey) {
                    const hierarchicalDataClone = cloneHierarchicalArray(collection, childDataKey);
                    return DataUtil.mergeHierarchicalTransactions(
                        hierarchicalDataClone,
                        aggregatedChanges,
                        childDataKey,
                        this.grid.primaryKey,
                        this.grid.dataCloneStrategy
                    );
                } else {
                    const flatDataClone = cloneArray(collection);
                    return DataUtil.mergeTransactions(
                        flatDataClone,
                        aggregatedChanges,
                        this.grid.primaryKey,
                        this.grid.dataCloneStrategy);
                }
            }
        }
        return collection;
    }
}

/**
 * This pipe maps the original record to ITreeGridRecord format used in TreeGrid.
 */
@Pipe({
    name: 'treeGridNormalizeRecord',
    standalone: true
})
export class IgxTreeGridNormalizeRecordsPipe implements PipeTransform {

    constructor(@Inject(IGX_GRID_BASE) private grid: GridType) { }

    public transform(_: any[], __: number): any[] {
        const primaryKey = this.grid.primaryKey;
        // using flattened data because origin data may be hierarchical.
        const flatData = this.grid.flatData;
        const res = flatData ? flatData.map(rec =>
        ({
            rowID: this.grid.primaryKey ? rec[primaryKey] : rec,
            data: rec,
            level: 0,
            children: []
        })) : [];
        return res;
    }
}

@Pipe({
    name: 'treeGridAddRow',
    standalone: true
})
export class IgxTreeGridAddRowPipe implements PipeTransform {

    constructor(@Inject(IGX_GRID_BASE) private grid: GridType) { }

    public transform(collection: any, isPinned = false, _pipeTrigger: number) {
        if (!this.grid.rowEditable || !this.grid.crudService.row || this.grid.crudService.row.getClassName() !== IgxAddRow.name ||
            !this.grid.gridAPI.crudService.addRowParent || isPinned !== this.grid.gridAPI.crudService.addRowParent.isPinned) {
            return collection;
        }
        const copy = collection.slice(0);
        const rec = (this.grid.crudService.row as IgxAddRow).recordRef;
        if (this.grid.crudService.addRowParent.isPinned) {
            const parentRowIndex = copy.findIndex(record => record.rowID === this.grid.crudService.addRowParent.rowID);
            copy.splice(parentRowIndex + 1, 0, rec);
        } else {
            copy.splice(this.grid.crudService.row.index, 0, rec);
        }
        this.grid.records.set(rec.key, rec);
        return copy;
    }
}

1	import { Inject, Pipe, PipeTransform } from '@angular/core';
2	import { cloneArray, cloneHierarchicalArray } from '../../core/utils';
3	import { DataUtil } from '../../data-operations/data-util';
4	import { ITreeGridRecord } from './tree-grid.interfaces';
5	import { GridType, IGX_GRID_BASE } from '../common/grid.interface';
6	import { GridPagingMode } from '../common/enums';
7	import { TransactionType } from '../../services/public_api';
8	import { IgxAddRow } from '../common/crud.service';
9	import { ISortingExpression } from '../../data-operations/sorting-strategy';
10	import { IGridSortingStrategy } from '../common/strategy';
11	import { IGroupingExpression } from '../../data-operations/grouping-expression.interface';
12
13	/**
14	* @hidden
15	*/
16	@Pipe({
17	name: 'treeGridHierarchizing',
18	standalone: true
19	})
20	export class IgxTreeGridHierarchizingPipe implements PipeTransform {	2✔
21
UNCOV 22	constructor(@Inject(IGX_GRID_BASE) private grid: GridType) { }	×
23
24	public transform(collection: any[], primaryKey: string, foreignKey: string, childDataKey: string, _: number): ITreeGridRecord[] {
UNCOV 25	let hierarchicalRecords: ITreeGridRecord[] = [];	×
UNCOV 26	const treeGridRecordsMap = new Map<any, ITreeGridRecord>();	×
UNCOV 27	const flatData: any[] = [];	×
28
UNCOV 29	if (!collection \|\| !collection.length) {	×
UNCOV 30	this.grid.flatData = collection;	×
UNCOV 31	this.grid.records = treeGridRecordsMap;	×
UNCOV 32	this.grid.rootRecords = collection;	×
UNCOV 33	return collection;	×
34	}
35
UNCOV 36	if (childDataKey) {	×
UNCOV 37	hierarchicalRecords = this.hierarchizeRecursive(collection, primaryKey, childDataKey, undefined,	×
38	flatData, 0, treeGridRecordsMap);
UNCOV 39	} else if (primaryKey) {	×
UNCOV 40	hierarchicalRecords = this.hierarchizeFlatData(collection, primaryKey, foreignKey, treeGridRecordsMap, flatData);	×
41	}
42
UNCOV 43	this.grid.flatData = this.grid.transactions.enabled ?	×
44	flatData.filter(rec => {
UNCOV 45	const state = this.grid.transactions.getState(this.getRowID(primaryKey, rec));	×
UNCOV 46	return !state \|\| state.type !== TransactionType.ADD;	×
47	}) : flatData;
UNCOV 48	this.grid.records = treeGridRecordsMap;	×
UNCOV 49	this.grid.rootRecords = hierarchicalRecords;	×
UNCOV 50	return hierarchicalRecords;	×
51	}
52
53	private getRowID(primaryKey: any, rowData: any) {
UNCOV 54	return primaryKey ? rowData[primaryKey] : rowData;	×
55	}
56
57	private hierarchizeFlatData(collection: any[], primaryKey: string, foreignKey: string,
58	map: Map<any, ITreeGridRecord>, flatData: any[]):
59	ITreeGridRecord[] {
UNCOV 60	const result: ITreeGridRecord[] = [];	×
UNCOV 61	const missingParentRecords: ITreeGridRecord[] = [];	×
UNCOV 62	collection.forEach(row => {	×
UNCOV 63	const record: ITreeGridRecord = {	×
64	key: this.getRowID(primaryKey, row),
65	data: row,
66	children: []
67	};
UNCOV 68	const parent = map.get(row[foreignKey]);	×
UNCOV 69	if (parent) {	×
UNCOV 70	record.parent = parent;	×
UNCOV 71	parent.children.push(record);	×
72	} else {
UNCOV 73	missingParentRecords.push(record);	×
74	}
75
UNCOV 76	map.set(row[primaryKey], record);	×
77	});
78
UNCOV 79	missingParentRecords.forEach(record => {	×
UNCOV 80	const parent = map.get(record.data[foreignKey]);	×
UNCOV 81	if (parent) {	×
UNCOV 82	record.parent = parent;	×
UNCOV 83	parent.children.push(record);	×
84	} else {
UNCOV 85	result.push(record);	×
86	}
87	});
88
UNCOV 89	this.setIndentationLevels(result, 0, flatData);	×
90
UNCOV 91	return result;	×
92	}
93
94	private setIndentationLevels(collection: ITreeGridRecord[], indentationLevel: number, flatData: any[]) {
UNCOV 95	for (const record of collection) {	×
UNCOV 96	record.level = indentationLevel;	×
UNCOV 97	record.expanded = this.grid.gridAPI.get_row_expansion_state(record);	×
UNCOV 98	flatData.push(record.data);	×
99
UNCOV 100	if (record.children && record.children.length > 0) {	×
UNCOV 101	this.setIndentationLevels(record.children, indentationLevel + 1, flatData);	×
102	}
103	}
104	}
105
106	private hierarchizeRecursive(collection: any[], primaryKey: string, childDataKey: string,
107	parent: ITreeGridRecord, flatData: any[], indentationLevel: number, map: Map<any, ITreeGridRecord>): ITreeGridRecord[] {
UNCOV 108	const result: ITreeGridRecord[] = [];	×
109
UNCOV 110	for (const item of collection) {	×
UNCOV 111	const record: ITreeGridRecord = {	×
112	key: this.getRowID(primaryKey, item),
113	data: item,
114	parent,
115	level: indentationLevel
116	};
UNCOV 117	record.expanded = this.grid.gridAPI.get_row_expansion_state(record);	×
UNCOV 118	flatData.push(item);	×
UNCOV 119	map.set(record.key, record);	×
UNCOV 120	record.children = item[childDataKey] ?	×
121	this.hierarchizeRecursive(item[childDataKey], primaryKey, childDataKey, record, flatData, indentationLevel + 1, map) :
122	undefined;
UNCOV 123	result.push(record);	×
124	}
125
UNCOV 126	return result;	×
127	}
128	}
129
130	/**
131	* @hidden
132	*/
133	@Pipe({
134	name: 'treeGridFlattening',
135	standalone: true
136	})
137	export class IgxTreeGridFlatteningPipe implements PipeTransform {	2✔
138
UNCOV 139	constructor(@Inject(IGX_GRID_BASE) private grid: GridType) { }	×
140
141	public transform(collection: ITreeGridRecord[],
142	expandedLevels: number, expandedStates: Map<any, boolean>, _: number): any[] {
143
UNCOV 144	const data: ITreeGridRecord[] = [];	×
145
UNCOV 146	this.grid.processedRootRecords = collection;	×
UNCOV 147	this.grid.processedRecords = new Map<any, ITreeGridRecord>();	×
148
UNCOV 149	this.getFlatDataRecursive(collection, data, expandedLevels, expandedStates, true);	×
150
UNCOV 151	this.grid.processedExpandedFlatData = data.map(r => r.data);	×
152
UNCOV 153	return data;	×
154	}
155
156	private getFlatDataRecursive(collection: ITreeGridRecord[], data: ITreeGridRecord[],
157	expandedLevels: number, expandedStates: Map<any, boolean>, parentExpanded: boolean) {
UNCOV 158	if (!collection \|\| !collection.length) {	×
UNCOV 159	return;	×
160	}
161
UNCOV 162	for (const hierarchicalRecord of collection) {	×
UNCOV 163	if (parentExpanded) {	×
UNCOV 164	data.push(hierarchicalRecord);	×
165	}
166
UNCOV 167	hierarchicalRecord.expanded = this.grid.gridAPI.get_row_expansion_state(hierarchicalRecord);	×
168
UNCOV 169	this.updateNonProcessedRecordExpansion(this.grid, hierarchicalRecord);	×
170
UNCOV 171	this.grid.processedRecords.set(hierarchicalRecord.key, hierarchicalRecord);	×
172
UNCOV 173	this.getFlatDataRecursive(hierarchicalRecord.children, data, expandedLevels,	×
174	expandedStates, parentExpanded && hierarchicalRecord.expanded);	×
175	}
176	}
177
178	private updateNonProcessedRecordExpansion(grid: GridType, record: ITreeGridRecord) {
UNCOV 179	const rec = grid.records.get(record.key);	×
UNCOV 180	rec.expanded = record.expanded;	×
181	}
182	}
183
184	/** @hidden */
185	@Pipe({
186	name: 'treeGridSorting',
187	standalone: true
188	})
189	export class IgxTreeGridSortingPipe implements PipeTransform {	2✔
190
UNCOV 191	constructor(@Inject(IGX_GRID_BASE) private grid: GridType) { }	×
192
193	public transform(
194	hierarchicalData: ITreeGridRecord[],
195	sortExpressions: ISortingExpression[],
196	groupExpressions: IGroupingExpression[],
197	sorting: IGridSortingStrategy,
198	_: number,
199	pinned?: boolean): ITreeGridRecord[] {
200
UNCOV 201	const expressions = groupExpressions ? groupExpressions.concat(sortExpressions) : sortExpressions;	×
202	let result: ITreeGridRecord[];
UNCOV 203	if (!expressions.length) {	×
UNCOV 204	result = hierarchicalData;	×
205	} else {
UNCOV 206	result = DataUtil.treeGridSort(hierarchicalData, expressions, sorting, null, this.grid);	×
207	}
208
UNCOV 209	const filteredSortedData = [];	×
UNCOV 210	this.flattenTreeGridRecords(result, filteredSortedData);	×
UNCOV 211	this.grid.setFilteredSortedData(filteredSortedData, pinned);	×
212
UNCOV 213	return result;	×
214	}
215
216	private flattenTreeGridRecords(records: ITreeGridRecord[], flatData: any[]) {
UNCOV 217	if (records && records.length) {	×
UNCOV 218	for (const record of records) {	×
UNCOV 219	flatData.push(record.data);	×
UNCOV 220	this.flattenTreeGridRecords(record.children, flatData);	×
221	}
222	}
223	}
224	}
225
226	/** @hidden */
227	@Pipe({
228	name: 'treeGridPaging',
229	standalone: true
230	})
231	export class IgxTreeGridPagingPipe implements PipeTransform {	2✔
232
UNCOV 233	constructor(@Inject(IGX_GRID_BASE) private grid: GridType) { }	×
234
235	public transform(collection: ITreeGridRecord[], enabled: boolean, page = 0, perPage = 15, _: number): ITreeGridRecord[] {	×
UNCOV 236	if (!enabled \|\| this.grid.pagingMode !== GridPagingMode.Local) {	×
UNCOV 237	return collection;	×
238	}
239
UNCOV 240	const len = this.grid._totalRecords >= 0 ? this.grid._totalRecords : collection.length;	×
UNCOV 241	const totalPages = Math.ceil(len / perPage);	×
242
UNCOV 243	const state = {	×
244	index: (totalPages > 0 && page >= totalPages) ? totalPages - 1 : page,	×
245	recordsPerPage: perPage
246	};
247
UNCOV 248	const result: ITreeGridRecord[] = DataUtil.page(cloneArray(collection), state, len);	×
UNCOV 249	this.grid.pagingState = state;	×
UNCOV 250	this.grid.page = state.index;	×
251
UNCOV 252	return result;	×
253	}
254	}
255	/** @hidden */
256	@Pipe({
257	name: 'treeGridTransaction',
258	standalone: true
259	})
260	export class IgxTreeGridTransactionPipe implements PipeTransform {	2✔
261
262
UNCOV 263	constructor(@Inject(IGX_GRID_BASE) private grid: GridType) { }	×
264
265	public transform(collection: any[], _: number): any[] {
266
UNCOV 267	if (this.grid.transactions.enabled) {	×
UNCOV 268	const aggregatedChanges = this.grid.transactions.getAggregatedChanges(true);	×
UNCOV 269	if (aggregatedChanges.length > 0) {	×
UNCOV 270	const primaryKey = this.grid.primaryKey;	×
UNCOV 271	if (!primaryKey) {	×
272	return collection;	×
273	}
274
UNCOV 275	const childDataKey = this.grid.childDataKey;	×
276
UNCOV 277	if (childDataKey) {	×
UNCOV 278	const hierarchicalDataClone = cloneHierarchicalArray(collection, childDataKey);	×
UNCOV 279	return DataUtil.mergeHierarchicalTransactions(	×
280	hierarchicalDataClone,
281	aggregatedChanges,
282	childDataKey,
283	this.grid.primaryKey,
284	this.grid.dataCloneStrategy
285	);
286	} else {
UNCOV 287	const flatDataClone = cloneArray(collection);	×
UNCOV 288	return DataUtil.mergeTransactions(	×
289	flatDataClone,
290	aggregatedChanges,
291	this.grid.primaryKey,
292	this.grid.dataCloneStrategy);
293	}
294	}
295	}
UNCOV 296	return collection;	×
297	}
298	}
299
300	/**
301	* This pipe maps the original record to ITreeGridRecord format used in TreeGrid.
302	*/
303	@Pipe({
304	name: 'treeGridNormalizeRecord',
305	standalone: true
306	})
307	export class IgxTreeGridNormalizeRecordsPipe implements PipeTransform {	2✔
308
UNCOV 309	constructor(@Inject(IGX_GRID_BASE) private grid: GridType) { }	×
310
311	public transform(_: any[], __: number): any[] {
UNCOV 312	const primaryKey = this.grid.primaryKey;	×
313	// using flattened data because origin data may be hierarchical.
UNCOV 314	const flatData = this.grid.flatData;	×
UNCOV 315	const res = flatData ? flatData.map(rec =>	×
UNCOV 316	({	×
317	rowID: this.grid.primaryKey ? rec[primaryKey] : rec,	×
318	data: rec,
319	level: 0,
320	children: []
321	})) : [];
UNCOV 322	return res;	×
323	}
324	}
325
326	@Pipe({
327	name: 'treeGridAddRow',
328	standalone: true
329	})
330	export class IgxTreeGridAddRowPipe implements PipeTransform {	2✔
331
UNCOV 332	constructor(@Inject(IGX_GRID_BASE) private grid: GridType) { }	×
333
334	public transform(collection: any, isPinned = false, _pipeTrigger: number) {	×
UNCOV 335	if (!this.grid.rowEditable \|\| !this.grid.crudService.row \|\| this.grid.crudService.row.getClassName() !== IgxAddRow.name \|\|	×
336	!this.grid.gridAPI.crudService.addRowParent \|\| isPinned !== this.grid.gridAPI.crudService.addRowParent.isPinned) {
UNCOV 337	return collection;	×
338	}
UNCOV 339	const copy = collection.slice(0);	×
UNCOV 340	const rec = (this.grid.crudService.row as IgxAddRow).recordRef;	×
UNCOV 341	if (this.grid.crudService.addRowParent.isPinned) {	×
UNCOV 342	const parentRowIndex = copy.findIndex(record => record.rowID === this.grid.crudService.addRowParent.rowID);	×
UNCOV 343	copy.splice(parentRowIndex + 1, 0, rec);	×
344	} else {
UNCOV 345	copy.splice(this.grid.crudService.row.index, 0, rec);	×
346	}
UNCOV 347	this.grid.records.set(rec.key, rec);	×
UNCOV 348	return copy;	×
349	}
350	}

IgniteUI / igniteui-angular / 13331632524

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