12136789779

Committed 03 Dec 2024 09:33AM UTC coverage: 98.372% (+0.04%) from 98.332%

Build # 12136789779

Build Type

Pull #1464

github

Committed by

web-flow

Commit Message

Merge bb96795a2 into 34dba9638

Pull Request Pull Request #1464: feat: Expose defaultValue/defaultChecked property for React bindings

Run Details

3932 of 4123 branches covered (95.37%)

Branch coverage included in aggregate %.

1110 of 1121 new or added lines in 22 files covered. (99.02%)

1 existing line in 1 file now uncovered.

24772 of 25056 relevant lines covered (98.87%)

488.73 hits per line

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

94.35

/src/components/combo/controllers/selection.ts

import type { ReactiveController } from 'lit';

import { asArray, isEmpty } from '../../common/util.js';
import type {
  ComboHost,
  ComboValue,
  IgcComboChangeEventArgs,
  Item,
  Keys,
  Values,
} from '../types.js';
import type { DataController } from './data.js';

export class SelectionController<T extends object>
  implements ReactiveController
{
  private _selected: Set<T> = new Set();

  /** Whether the current selection is empty */
  public get isEmpty() {
    return isEmpty(this._selected);
  }

  /** Returns the current selection as an array */
  public get asArray() {
    return Array.from(this._selected);
  }

  /** Whether the current selection has the given item */
  public has(item?: T) {
    return this._selected.has(item!);
  }

  /** Clears the current selection */
  public clear() {
    this._selected.clear();
  }

  public getSelectedValuesByKey(key?: Keys<T>) {
    return this.asArray.map((item) => item[key!] ?? item);
  }

  public getValue(items: T[], key: Keys<T>): ComboValue<T>[] {
    return items.map((item) => item[key] ?? item);
  }

  private handleChange(detail: IgcComboChangeEventArgs) {
    return this.host.emitEvent('igcChange', { cancelable: true, detail });
  }

  private getItemsByValueKey(keys: Values<T>[]) {
    const _keys = new Set(keys);
    return this.host.data.filter((item) =>
      _keys.has(item[this.host.valueKey!])
    );
  }

  private selectValueKeys(keys: Values<T>[]) {
    if (isEmpty(keys)) {
      return;
    }

    for (const item of this.getItemsByValueKey(keys)) {
      this._selected.add(item);
    }
  }

  private deselectValueKeys(keys: Values<T>[]) {
    if (isEmpty(keys)) {
      return;
    }

    for (const item of this.getItemsByValueKey(keys)) {
      this._selected.delete(item);
    }
  }

  private selectObjects(items: T[]) {
    if (isEmpty(items)) {
      return;
    }

    const dataSet = new Set(this.host.data);

    for (const item of items) {
      if (dataSet.has(item)) {
        this._selected.add(item);
      }
    }
  }

  private deselectObjects(items: T[]) {
    if (isEmpty(items)) {
      return;
    }

    const dataSet = new Set(this.host.data);

    for (const item of items) {
      if (dataSet.has(item)) {
        this._selected.delete(item);
      }
    }
  }

  private selectAll() {
    this._selected = new Set(this.host.data);
    this.host.requestUpdate();
  }

  private deselectAll() {
    this.clear();
    this.host.requestUpdate();
  }

  public async select(items?: Item<T> | Item<T>[], emit = false) {
    let _items = asArray(items);
    const singleSelect = this.host.singleSelect;

    if (singleSelect) {
      this.clear();
      this.state.searchTerm = '';
    }

    if (isEmpty(_items)) {
      if (!singleSelect) {
        this.selectAll();
      }
      return;
    }

    if (singleSelect) {
      _items = _items.slice(0, 1);
    }

    const values = this.host.valueKey
      ? this.getItemsByValueKey(_items as Values<T>[])
      : _items;
    const selected = Array.from(this._selected.values());
    const payload = [...values, ...selected] as T[];

    if (
      emit &&
      !this.handleChange({
        newValue: this.getValue(payload, this.host.valueKey!),
        items: values as T[],
        type: 'selection',
      })
    ) {
      return;
    }

    if (this.host.valueKey) {
      this.selectValueKeys(_items as Values<T>[]);
    } else {
      this.selectObjects(_items as T[]);
    }

    this.host.requestUpdate();
  }

  public async deselect(items?: Item<T> | Item<T>[], emit = false) {
    let _items = asArray(items);

    if (isEmpty(_items)) {
      if (
        emit &&
        !this.handleChange({
          newValue: [],
          items: this.asArray,
          type: 'deselection',
        })
      ) {
        return;
      }

      this.deselectAll();
      return;
    }

    if (this.host.singleSelect) {
      _items = _items.slice(0, 1);
    }

    const values = this.host.valueKey
      ? this.getItemsByValueKey(_items as Values<T>[])
      : _items;
    const selected = Array.from(this._selected.values());
    const payload = selected.filter((item) => item !== values[0]);

    if (
      emit &&
      !this.handleChange({
        newValue: this.getValue(payload, this.host.valueKey!),
        items: values as T[],
        type: 'deselection',
      })
    ) {
      return;
    }

    if (this.host.valueKey) {
      this.deselectValueKeys(_items as Values<T>[]);
    } else {
      this.deselectObjects(_items as T[]);
    }

    this.host.requestUpdate();
  }

  public changeSelection(index: number) {
    const valueKey = this.host.valueKey;
    const record = this.host.data[index];
    const item = valueKey ? record[valueKey] : record;

    this.has(record) ? this.deselect(item, true) : this.select(item, true);
  }

  public selectByIndex(index: number) {
    const valueKey = this.host.valueKey;
    const item = this.host.data[index];

    this.select(valueKey ? item[valueKey] : item, true);
  }

  constructor(
    protected host: ComboHost<T>,
    protected state: DataController<T>
  ) {
    this.host.addController(this);
  }

  public hostConnected() {}

  public hostDisconnected() {}
}

1	import type { ReactiveController } from 'lit';	11✔
2		11✔
3	import { asArray, isEmpty } from '../../common/util.js';	11✔
4	import type {	11✔
5	ComboHost,	11✔
6	ComboValue,	11✔
7	IgcComboChangeEventArgs,	11✔
8	Item,	11✔
9	Keys,	11✔
10	Values,	11✔
11	} from '../types.js';	11✔
12	import type { DataController } from './data.js';	11✔
13		11✔
14	export class SelectionController<T extends object>	11✔
15	implements ReactiveController	11✔
16	{	11✔
17	private _selected: Set<T> = new Set();	11✔
18		11✔
19	/** Whether the current selection is empty */	11✔
20	public get isEmpty() {	11✔
21	return isEmpty(this._selected);	480✔
22	}	480✔
23		11✔
24	/** Returns the current selection as an array */	11✔
25	public get asArray() {	11✔
26	return Array.from(this._selected);	365✔
27	}	365✔
28		11✔
29	/** Whether the current selection has the given item */	11✔
30	public has(item?: T) {	11✔
31	return this._selected.has(item!);	431✔
32	}	431✔
33		11✔
34	/** Clears the current selection */	11✔
35	public clear() {	11✔
36	this._selected.clear();	161✔
37	}	161✔
38		11✔
39	public getSelectedValuesByKey(key?: Keys<T>) {	11✔
40	return this.asArray.map((item) => item[key!] ?? item);	344✔
41	}	344✔
42		11✔
43	public getValue(items: T[], key: Keys<T>): ComboValue<T>[] {	11✔
44	return items.map((item) => item[key] ?? item);	15✔
45	}	15✔
46		11✔
47	private handleChange(detail: IgcComboChangeEventArgs) {	11✔
48	return this.host.emitEvent('igcChange', { cancelable: true, detail });	16✔
49	}	16✔
50		11✔
51	private getItemsByValueKey(keys: Values<T>[]) {	11✔
52	const _keys = new Set(keys);	132✔
53	return this.host.data.filter((item) =>	132✔
54	_keys.has(item[this.host.valueKey!])	788✔
55	);	132✔
56	}	132✔
57		11✔
58	private selectValueKeys(keys: Values<T>[]) {	11✔
59	if (isEmpty(keys)) {	58!
NEW 60	return;	×
NEW 61	}	×
62		58✔
63	for (const item of this.getItemsByValueKey(keys)) {	58✔
64	this._selected.add(item);	87✔
65	}	87✔
66	}	58✔
67		11✔
68	private deselectValueKeys(keys: Values<T>[]) {	11✔
69	if (isEmpty(keys)) {	7!
NEW 70	return;	×
NEW 71	}	×
72		7✔
73	for (const item of this.getItemsByValueKey(keys)) {	7✔
74	this._selected.delete(item);	7✔
75	}	7✔
76	}	7✔
77		11✔
78	private selectObjects(items: T[]) {	11✔
79	if (isEmpty(items)) {	6!
NEW 80	return;	×
NEW 81	}	×
82		6✔
83	const dataSet = new Set(this.host.data);	6✔
84		6✔
85	for (const item of items) {	6✔
86	if (dataSet.has(item)) {	8✔
87	this._selected.add(item);	8✔
88	}	8✔
89	}	8✔
90	}	6✔
91		11✔
92	private deselectObjects(items: T[]) {	11✔
93	if (isEmpty(items)) {	2!
NEW 94	return;	×
NEW 95	}	×
96		2✔
97	const dataSet = new Set(this.host.data);	2✔
98		2✔
99	for (const item of items) {	2✔
100	if (dataSet.has(item)) {	2✔
101	this._selected.delete(item);	2✔
102	}	2✔
103	}	2✔
104	}	2✔
105		11✔
106	private selectAll() {	11✔
107	this._selected = new Set(this.host.data);	3✔
108	this.host.requestUpdate();	3✔
109	}	3✔
110		11✔
111	private deselectAll() {	11✔
112	this.clear();	119✔
113	this.host.requestUpdate();	119✔
114	}	119✔
115		11✔
116	public async select(items?: Item<T> \| Item<T>[], emit = false) {	11✔
117	let _items = asArray(items);	69✔
118	const singleSelect = this.host.singleSelect;	69✔
119		69✔
120	if (singleSelect) {	69✔
121	this.clear();	22✔
122	this.state.searchTerm = '';	22✔
123	}	22✔
124		69✔
125	if (isEmpty(_items)) {	69✔
126	if (!singleSelect) {	4✔
127	this.selectAll();	3✔
128	}	3✔
129	return;	4✔
130	}	4✔
131		65✔
132	if (singleSelect) {	69✔
133	_items = _items.slice(0, 1);	21✔
134	}	21✔
135		65✔
136	const values = this.host.valueKey	65✔
137	? this.getItemsByValueKey(_items as Values<T>[])	69✔
138	: _items;	69✔
139	const selected = Array.from(this._selected.values());	69✔
140	const payload = [...values, ...selected] as T[];	69✔
141		69✔
142	if (	69✔
143	emit &&	69✔
144	!this.handleChange({	11✔
145	newValue: this.getValue(payload, this.host.valueKey!),	11✔
146	items: values as T[],	11✔
147	type: 'selection',	11✔
148	})	11✔
149	) {	69✔
150	return;	1✔
151	}	1✔
152		64✔
153	if (this.host.valueKey) {	69✔
154	this.selectValueKeys(_items as Values<T>[]);	58✔
155	} else {	69✔
156	this.selectObjects(_items as T[]);	6✔
157	}	6✔
158		64✔
159	this.host.requestUpdate();	64✔
160	}	64✔
161		11✔
162	public async deselect(items?: Item<T> \| Item<T>[], emit = false) {	11✔
163	let _items = asArray(items);	129✔
164		129✔
165	if (isEmpty(_items)) {	129✔
166	if (	119✔
167	emit &&	119✔
168	!this.handleChange({	1✔
169	newValue: [],	1✔
170	items: this.asArray,	1✔
171	type: 'deselection',	1✔
172	})	1✔
173	) {	119!
174	return;	×
175	}	×
176		119✔
177	this.deselectAll();	119✔
178	return;	119✔
179	}	119✔
180		10✔
181	if (this.host.singleSelect) {	129✔
182	_items = _items.slice(0, 1);	3✔
183	}	3✔
184		10✔
185	const values = this.host.valueKey	10✔
186	? this.getItemsByValueKey(_items as Values<T>[])	129✔
187	: _items;	129✔
188	const selected = Array.from(this._selected.values());	129✔
189	const payload = selected.filter((item) => item !== values[0]);	129✔
190		129✔
191	if (	129✔
192	emit &&	129✔
193	!this.handleChange({	4✔
194	newValue: this.getValue(payload, this.host.valueKey!),	4✔
195	items: values as T[],	4✔
196	type: 'deselection',	4✔
197	})	4✔
198	) {	129✔
199	return;	1✔
200	}	1✔
201		9✔
202	if (this.host.valueKey) {	129✔
203	this.deselectValueKeys(_items as Values<T>[]);	7✔
204	} else {	129✔
205	this.deselectObjects(_items as T[]);	2✔
206	}	2✔
207		9✔
208	this.host.requestUpdate();	9✔
209	}	9✔
210		11✔
211	public changeSelection(index: number) {	11✔
212	const valueKey = this.host.valueKey;	9✔
213	const record = this.host.data[index];	9✔
214	const item = valueKey ? record[valueKey] : record;	9!
215		9✔
216	this.has(record) ? this.deselect(item, true) : this.select(item, true);	9✔
217	}	9✔
218		11✔
219	public selectByIndex(index: number) {	11✔
220	const valueKey = this.host.valueKey;	4✔
221	const item = this.host.data[index];	4✔
222		4✔
223	this.select(valueKey ? item[valueKey] : item, true);	4!
224	}	4✔
225		11✔
226	constructor(	11✔
227	protected host: ComboHost<T>,	88✔
228	protected state: DataController<T>	88✔
229	) {	88✔
230	this.host.addController(this);	88✔
231	}	88✔
232		11✔
233	public hostConnected() {}	11✔
234		11✔
235	public hostDisconnected() {}	11✔
236	}	11✔

IgniteUI / igniteui-webcomponents / 12136789779

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