eaebe679-eeb4-4c09-8c03-618fee19a08f

Committed 18 Nov 2024 06:00AM UTC coverage: 90.347% (-0.005%) from 90.352%

Build # eaebe679-eeb4-4c09-8c03-618fee19a08f

Build Type

Pull #3242

circleci

Committed by

minlovehua

Commit Message

feat(i18n): i18n design and review #TINFR-916

Pull Request Pull Request #3242: feat(i18n): i18n design and review #TINFR-916

Run Details

5522 of 6760 branches covered (81.69%)

Branch coverage included in aggregate %.

32 of 35 new or added lines in 10 files covered. (91.43%)

20 existing lines in 3 files now uncovered.

13196 of 13958 relevant lines covered (94.54%)

996.5 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,
    Signal,
    TemplateRef,
    ViewEncapsulation,
    inject
} from '@angular/core';

import { NgClass, 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';
import { injectLocale, ThyTransferLocale } from 'ngx-tethys/i18n';

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

    public lockItems: ThyTransferItem[] = [];

    public unlockItems: ThyTransferItem[] = [];

    private _diff: IterableDiffer<ThyTransferItem>;

    private _lockDiff: IterableDiffer<ThyTransferItem>;

    private _unlockDiff: IterableDiffer<ThyTransferItem>;

    locale: Signal<ThyTransferLocale> = injectLocale('transfer');

    @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';

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

atinc / ngx-tethys / eaebe679-eeb4-4c09-8c03-618fee19a08f

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