5ba5b9d7-3ca9-4ff2-bbba-bde58c0f849f

Committed 22 Feb 2024 09:41AM UTC coverage: 90.604%. Remained the same

Build # 5ba5b9d7-3ca9-4ff2-bbba-bde58c0f849f

Build Type

Pull #3027

circleci

Committed by

minlovehua

Commit Message

feat(schematics): provide schematics for removing the suffix of standalone components #INFR-11662

Pull Request Pull Request #3027: refactor: remove the component suffix for standalone components and provide schematics #INFR-10654

Run Details

5425 of 6642 branches covered (81.68%)

Branch coverage included in aggregate %.

323 of 333 new or added lines in 193 files covered. (97.0%)

36 existing lines in 8 files now uncovered.

13504 of 14250 relevant lines covered (94.76%)

981.28 hits per line

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

91.57

/src/transfer/transfer-list.component.ts

import { CdkDrag, CdkDragDrop, CdkDropList, CdkDropListGroup, moveItemInArray, transferArrayItem } from '@angular/cdk/drag-drop';
import {
    Component,
    DoCheck,
    EventEmitter,
    HostBinding,
    Input,
    IterableChanges,
    IterableDiffer,
    IterableDiffers,
    OnInit,
    Output,
    TemplateRef,
    ViewEncapsulation
} from '@angular/core';

import { NgClass, NgFor, NgIf, NgTemplateOutlet } from '@angular/common';
import { ThyList, ThyListItem } from 'ngx-tethys/list';
import { ThyDragDropDirective } from 'ngx-tethys/shared';
import { InnerTransferDragEvent, ThyTransferDragEvent, ThyTransferItem, ThyTransferSelectEvent } from './transfer.interface';

/**
 * @private
 */
@Component({
    selector: 'thy-transfer-list',
    templateUrl: './transfer-list.component.html',
    encapsulation: ViewEncapsulation.None,
    standalone: true,
    imports: [NgIf, CdkDropListGroup, ThyList, CdkDropList, ThyDragDropDirective, NgFor, ThyListItem, CdkDrag, NgClass, NgTemplateOutlet]
})
export class ThyTransferList implements OnInit, DoCheck {
    public lockItems: ThyTransferItem[] = [];

    public unlockItems: ThyTransferItem[] = [];

    private _diff: IterableDiffer<ThyTransferItem>;

    private _lockDiff: IterableDiffer<ThyTransferItem>;

    private _unlockDiff: IterableDiffer<ThyTransferItem>;

    @Input() title: string;

    @Input() items: ThyTransferItem[];

    @Input() draggable: boolean;

    @Input() canLock: boolean;

    @Input() maxLock: number;

    @Input() max: number;

    @Input() disabled: boolean;

    @Input() template: TemplateRef<any>;

    @Input('renderContentRef') contentRef: TemplateRef<any>;

    @Output() draggableUpdate: EventEmitter<InnerTransferDragEvent> = new EventEmitter<InnerTransferDragEvent>();

    @Output() selectItem: EventEmitter<ThyTransferSelectEvent> = new EventEmitter<ThyTransferSelectEvent>();

    @Output() unselectItem: EventEmitter<ThyTransferSelectEvent> = new EventEmitter<ThyTransferSelectEvent>();

    @HostBinding('class') hostClass = 'thy-transfer-list';

    constructor(private differs: IterableDiffers) {}

    ngOnInit() {
        this._combineTransferData();
        if (this.canLock) {
            this._lockDiff = this.differs.find(this.lockItems).create();
            this._unlockDiff = this.differs.find(this.unlockItems).create();
        } else {
            this._unlockDiff = this.differs.find(this.unlockItems).create();
        }
        this._diff = this.differs.find(this.items).create();
    }

    private _combineTransferData() {
        this.lockItems = [];
        this.unlockItems = [];
        if (this.canLock) {
            (this.items || []).forEach(item => {
                if (item.isLock) {
                    this.lockItems.push(item);
                } else {
                    this.unlockItems.push(item);
                }
            });
        } else {
            this.unlockItems = this.items;
        }
    }

    private _afterChangeItems(changes: IterableChanges<ThyTransferItem>, items: ThyTransferItem[]) {
        // 数据发生变化时，更改order值
        changes.forEachAddedItem(record => {
            record.item.order = record.currentIndex;
        });
        changes.forEachRemovedItem(() => {
            items.forEach((item, index) => {
                item.order = index;
            });
        });
        changes.forEachMovedItem(() => {
            items.forEach((item, index) => {
                item.order = index;
            });
        });
    }

    ngDoCheck() {
        const changes = this._diff.diff(this.items);
        if (changes) {
            this._afterChangeItems(changes, this.items);
            this._combineTransferData();
        }
        if (this._lockDiff) {
            const lockChanges = this._lockDiff.diff(this.lockItems);
            if (lockChanges) {
                this._afterChangeItems(lockChanges, this.lockItems);
            }
        }
        const unlockChanges = this._unlockDiff.diff(this.unlockItems);
        if (unlockChanges) {
            this._afterChangeItems(unlockChanges, this.unlockItems);
        }
    }

    lockListEnterPredicate = () => {
        return this.lockItems.length < this.maxLock;
    };

    unlockListEnterPredicate = (event: CdkDrag<ThyTransferItem>) => {
        return !event.data.isFixed;
    };

    onSelectItem = (item: ThyTransferItem) => {
        this.selectItem.emit({ item });
    };

    onUnselectItem = (item: ThyTransferItem) => {
        this.unselectItem.emit({ item });
    };

    drop(event: CdkDragDrop<ThyTransferItem[]>) {
        if (event.previousContainer === event.container) {
            moveItemInArray(event.container.data, event.previousIndex, event.currentIndex);
        } else {
            transferArrayItem(event.previousContainer.data, event.container.data, event.previousIndex, event.currentIndex);
            (event.previousContainer.data || []).forEach(item => {
                item.isLock = event.previousContainer.id === 'lock';
            });

            (event.container.data || []).forEach(item => {
                item.isLock = event.container.id === 'lock';
            });
        }
        const dragEvent: ThyTransferDragEvent = {
            model: event.item.data,
            models: event.container.data,
            oldIndex: event.previousIndex,
            newIndex: event.currentIndex
        };
        this.draggableUpdate.emit({
            dragEvent: dragEvent,
            listData: { lock: this.lockItems, unlock: this.unlockItems }
        });
    }
}

1	import { CdkDrag, CdkDragDrop, CdkDropList, CdkDropListGroup, moveItemInArray, transferArrayItem } from '@angular/cdk/drag-drop';
2	import {
3	Component,
4	DoCheck,
5	EventEmitter,
6	HostBinding,
7	Input,
8	IterableChanges,
9	IterableDiffer,
10	IterableDiffers,
11	OnInit,	1✔
12	Output,
13	TemplateRef,	38✔
14	ViewEncapsulation	38✔
15	} from '@angular/core';	38✔
16		38✔
17	import { NgClass, NgFor, NgIf, NgTemplateOutlet } from '@angular/common';	38✔
18	import { ThyList, ThyListItem } from 'ngx-tethys/list';	38✔
19	import { ThyDragDropDirective } from 'ngx-tethys/shared';	38✔
20	import { InnerTransferDragEvent, ThyTransferDragEvent, ThyTransferItem, ThyTransferSelectEvent } from './transfer.interface';	38✔
21		×
22	/**
23	* @private	38✔
24	*/	×
25	@Component({
26	selector: 'thy-transfer-list',	38✔
27	templateUrl: './transfer-list.component.html',	1✔
28	encapsulation: ViewEncapsulation.None,
29	standalone: true,	38✔
30	imports: [NgIf, CdkDropListGroup, ThyList, CdkDropList, ThyDragDropDirective, NgFor, ThyListItem, CdkDrag, NgClass, NgTemplateOutlet]	2✔
31	})
32	export class ThyTransferList implements OnInit, DoCheck {
33	public lockItems: ThyTransferItem[] = [];
34		38✔
35	public unlockItems: ThyTransferItem[] = [];	38✔
36		15✔
37	private _diff: IterableDiffer<ThyTransferItem>;	15✔
38
39	private _lockDiff: IterableDiffer<ThyTransferItem>;
40		23✔
41	private _unlockDiff: IterableDiffer<ThyTransferItem>;
42		38✔
43	@Input() title: string;
44
45	@Input() items: ThyTransferItem[];	91✔
46		91✔
47	@Input() draggable: boolean;	91✔
48		42!
49	@Input() canLock: boolean;	211✔
50		40✔
51	@Input() maxLock: number;
52
53	@Input() max: number;	171✔
54
55	@Input() disabled: boolean;
56
57	@Input() template: TemplateRef<any>;
58		49✔
59	@Input('renderContentRef') contentRef: TemplateRef<any>;
60
61	@Output() draggableUpdate: EventEmitter<InnerTransferDragEvent> = new EventEmitter<InnerTransferDragEvent>();
62
63	@Output() selectItem: EventEmitter<ThyTransferSelectEvent> = new EventEmitter<ThyTransferSelectEvent>();	125✔
64		582✔
65	@Output() unselectItem: EventEmitter<ThyTransferSelectEvent> = new EventEmitter<ThyTransferSelectEvent>();
66		125✔
67	@HostBinding('class') hostClass = 'thy-transfer-list';	52✔
68		208✔
69	constructor(private differs: IterableDiffers) {}
70
71	ngOnInit() {	125✔
72	this._combineTransferData();	18✔
73	if (this.canLock) {	70✔
74	this._lockDiff = this.differs.find(this.lockItems).create();
75	this._unlockDiff = this.differs.find(this.unlockItems).create();
76	} else {
77	this._unlockDiff = this.differs.find(this.unlockItems).create();
78	}	108✔
79	this._diff = this.differs.find(this.items).create();	108✔
80	}	53✔
81		53✔
82	private _combineTransferData() {
83	this.lockItems = [];	108✔
84	this.unlockItems = [];	47✔
85	if (this.canLock) {	47✔
86	(this.items \|\| []).forEach(item => {	21✔
87	if (item.isLock) {
88	this.lockItems.push(item);
89	} else {	108✔
90	this.unlockItems.push(item);	108✔
91	}	51✔
92	});
93	} else {
94	this.unlockItems = this.items;
95	}	4!
UNCOV 96	}	×
97
98	private _afterChangeItems(changes: IterableChanges<ThyTransferItem>, items: ThyTransferItem[]) {
99	// 数据发生变化时，更改order值	4✔
100	changes.forEachAddedItem(record => {	4!
101	record.item.order = record.currentIndex;	16✔
102	});
103	changes.forEachRemovedItem(() => {	4!
104	items.forEach((item, index) => {	16✔
105	item.order = index;
106	});
107	});	4✔
108	changes.forEachMovedItem(() => {
109	items.forEach((item, index) => {
110	item.order = index;
111	});
112	});
113	}	4✔
114
115	ngDoCheck() {
116	const changes = this._diff.diff(this.items);
117	if (changes) {
118	this._afterChangeItems(changes, this.items);	1✔
119	this._combineTransferData();
120	}
121	if (this._lockDiff) {	1✔
122	const lockChanges = this._lockDiff.diff(this.lockItems);
123	if (lockChanges) {
124	this._afterChangeItems(lockChanges, this.lockItems);
125	}
126	}
127	const unlockChanges = this._unlockDiff.diff(this.unlockItems);
128	if (unlockChanges) {
129	this._afterChangeItems(unlockChanges, this.unlockItems);
130	}
131	}
132
133	lockListEnterPredicate = () => {
134	return this.lockItems.length < this.maxLock;
135	};
136
137	unlockListEnterPredicate = (event: CdkDrag<ThyTransferItem>) => {	1✔
138	return !event.data.isFixed;
139	};
140
141	onSelectItem = (item: ThyTransferItem) => {
142	this.selectItem.emit({ item });
143	};
144
145	onUnselectItem = (item: ThyTransferItem) => {
146	this.unselectItem.emit({ item });
147	};
148
149	drop(event: CdkDragDrop<ThyTransferItem[]>) {
150	if (event.previousContainer === event.container) {
151	moveItemInArray(event.container.data, event.previousIndex, event.currentIndex);
152	} else {
153	transferArrayItem(event.previousContainer.data, event.container.data, event.previousIndex, event.currentIndex);
154	(event.previousContainer.data \|\| []).forEach(item => {
155	item.isLock = event.previousContainer.id === 'lock';
156	});
157
158	(event.container.data \|\| []).forEach(item => {
159	item.isLock = event.container.id === 'lock';
160	});
161	}
162	const dragEvent: ThyTransferDragEvent = {
163	model: event.item.data,
164	models: event.container.data,
165	oldIndex: event.previousIndex,
166	newIndex: event.currentIndex
167	};
168	this.draggableUpdate.emit({
169	dragEvent: dragEvent,
170	listData: { lock: this.lockItems, unlock: this.unlockItems }
171	});
172	}
173	}

atinc / ngx-tethys / 5ba5b9d7-3ca9-4ff2-bbba-bde58c0f849f

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