11666041265

Committed 04 Nov 2024 02:16PM UTC coverage: 98.269% (-0.04%) from 98.311%

Build # 11666041265

Build Type

Pull #1352

github

Committed by

web-flow

Commit Message

Merge 315623715 into aad60d385

Pull Request Pull Request #1352: Refactor Tab component

Run Details

3839 of 4044 branches covered (94.93%)

Branch coverage included in aggregate %.

416 of 429 new or added lines in 4 files covered. (96.97%)

1 existing line in 1 file now uncovered.

24440 of 24733 relevant lines covered (98.82%)

451.4 hits per line

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

95.29

/src/components/common/util.ts

export interface PartNameInfo {
  readonly [name: string]: string | boolean | number;
}

export const partNameMap = (partNameInfo: PartNameInfo) => {
  return Object.keys(partNameInfo)
    .filter((key) => partNameInfo[key])
    .join(' ');
};

export function noop() {}

export const asPercent = (part: number, whole: number) => (part / whole) * 100;

export const clamp = (number: number, min: number, max: number) =>
  Math.max(min, Math.min(number, max));

export function numberInRangeInclusive(
  value: number,
  min: number,
  max: number
) {
  return value >= min && value <= max;
}

export function sameObject(a: object, b: object) {
  return JSON.stringify(a) === JSON.stringify(b);
}

export function createCounter() {
  let i = 0;
  return () => {
    i++;
    return i;
  };
}

/**
 * Returns whether an element has a Left-to-Right directionality.
 */
export function isLTR(element: HTMLElement) {
  return element.matches(':dir(ltr)');
}

/**
 * Builds a string from format specifiers and replacement parameters.
 * Will coerce non-string parameters to their string representations.
 *
 * @example
 * ```typescript
 * formatString('{0} says "{1}".', 'John', 'Hello'); // 'John says "Hello".'
 * formatString('{1} is greater than {0}', 0, 1); // '1 is greater than 0'
 * ```
 */
export function formatString(template: string, ...params: unknown[]): string {
  const length = params.length;

  return template.replace(/{(\d+)}/g, (match: string, index: number) =>
    index >= length ? match : `${params[index]}`
  );
}

/**
 * Parse the passed `value` as a number or return the `fallback` if it can't be done.
 *
 * @example
 * ```typescript
 * asNumber('5'); // 5
 * asNumber('3.14'); // 3.14
 * asNumber('five'); // 0
 * asNUmber('five', 5); // 5
 * ```
 */
export function asNumber(value: unknown, fallback = 0) {
  const parsed = Number.parseFloat(value as string);
  return Number.isNaN(parsed) ? fallback : parsed;
}

/**
 * Returns the value wrapped between the min and max bounds.
 *
 * If the value is greater than max, returns the min and vice-versa.
 * If the value is between the bounds, it is returned unchanged.
 *
 * @example
 * ```typescript
 * wrap(1, 4, 2); // 2
 * wrap(1, 4, 5); // 1
 * wrap(1, 4, -1); // 4
 * ```
 */
export function wrap(min: number, max: number, value: number) {
  if (value < min) {
    return max;
  }
  if (value > max) {
    return min;
  }

  return value;
}

export function isDefined<T = unknown>(value: T) {
  return value !== undefined;
}

export function* iterNodes<T = Node>(
  root: Node,
  whatToShow?: keyof typeof NodeFilter,
  filter?: (node: T) => boolean
): Generator<T> {
  if (!isDefined(globalThis.document)) {
    return;
  }

  const iter = globalThis.document.createTreeWalker(
    root,
    NodeFilter[whatToShow ?? 'SHOW_ALL']
  );

  let node = iter.nextNode() as T;

  while (node) {
    if (filter) {
      if (filter(node)) {
        yield node;
      }
    } else {
      yield node;
    }

    node = iter.nextNode() as T;
  }
}

export function getElementByIdFromRoot(root: HTMLElement, id: string) {
  return (root.getRootNode() as Document | ShadowRoot).getElementById(id);
}

export function isElement(node: unknown): node is Element {
  return node instanceof Node && node.nodeType === Node.ELEMENT_NODE;
}

export function getElementsFromEventPath<T extends Element>(event: Event) {
  return event.composedPath().filter((item) => isElement(item)) as T[];
}

export function findElementFromEventPath<T extends Element>(
  predicate: string | ((element: Element) => boolean),
  event: Event
) {
  const func = isString(predicate)
    ? (e: Element) => e.matches(predicate)
    : (e: Element) => predicate(e);

  return getElementsFromEventPath(event).find(func) as T | undefined;
}

export function groupBy<T>(array: T[], key: keyof T | ((item: T) => any)) {
  const result: Record<string, T[]> = {};
  const _get = isFunction(key) ? key : (item: T) => item[key];

  for (const item of array) {
    const category = _get(item);
    const group = result[category];

    if (Array.isArray(group)) {
      group.push(item);
    } else {
      result[category] = [item];
    }
  }

  return result;
}

export function first<T>(arr: T[]) {
  return arr.at(0) as T;
}

export function last<T>(arr: T[]) {
  return arr.at(-1) as T;
}

export function modulo(n: number, d: number) {
  return ((n % d) + d) % d;
}

/**
 * Creates an array of `n` elements from a given iterator.
 *
 */
export function take<T>(iterable: IterableIterator<T>, n: number) {
  const result: T[] = [];
  let i = 0;
  let current = iterable.next();

  while (i < n && !current.done) {
    result.push(current.value);
    current = iterable.next();
    i++;
  }

  return result;
}

/**
 * Splits an array into chunks of length `size` and returns a generator
 * yielding each chunk.
 * The last chunk may contain less than `size` elements.
 *
 * @example
 * ```typescript
 * const arr = [0,1,2,3,4,5,6,7,8,9];
 *
 * Array.from(chunk(arr, 2)) // [[0, 1], [2, 3], [4, 5], [6, 7], [8, 9]]
 * Array.from(chunk(arr, 3)) // [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]]
 * Array.from(chunk([], 3)) // []
 * Array.from(chunk(arr, -3)) // Error
 * ```
 */
export function* chunk<T>(arr: T[], size: number) {
  if (size < 1) {
    throw new Error('size must be an integer >= 1');
  }
  for (let i = 0; i < arr.length; i += size) {
    yield arr.slice(i, i + size);
  }
}

export function splitToWords(text: string) {
  const input = text.replaceAll(/[^a-zA-Z0-9\s-_]/g, '');
  if (/[\s-_]+/.test(input)) return input.split(/[\s-_]+/);
  return input.split(/(?=[A-Z])+/);
}

export function toKebabCase(text: string): string {
  const input = text.trim();
  return splitToWords(input).join('-').toLocaleLowerCase();
}

export function isFunction(value: unknown): value is CallableFunction {
  return typeof value === 'function';
}

export function isString(value: unknown): value is string {
  return typeof value === 'string';
}

/**
 * Returns whether a given collection has at least one member.
 */
export function isEmpty<T, U extends string>(
  x: ArrayLike<T> | Set<T> | Map<U, T>
): boolean {
  return 'length' in x ? x.length < 1 : x.size < 1;
}

export function scrollIntoView(
  element?: HTMLElement,
  config?: ScrollIntoViewOptions
): void {
  if (!element) {
    return;
  }

  element.scrollIntoView(
    Object.assign(
      {
        behavior: 'auto',
        block: 'nearest',
        inline: 'nearest',
      },
      config
    )
  );
}

1	export interface PartNameInfo {	58✔
2	readonly [name: string]: string \| boolean \| number;	58✔
3	}	58✔
4		58✔
5	export const partNameMap = (partNameInfo: PartNameInfo) => {	58✔
6	return Object.keys(partNameInfo)	42,229✔
7	.filter((key) => partNameInfo[key])	42,229✔
8	.join(' ');	42,229✔
9	};	42,229✔
10		58✔
11	export function noop() {}	58✔
12		58✔
13	export const asPercent = (part: number, whole: number) => (part / whole) * 100;	58✔
14		58✔
15	export const clamp = (number: number, min: number, max: number) =>	58✔
16	Math.max(min, Math.min(number, max));	58✔
17		58✔
18	export function numberInRangeInclusive(	58✔
19	value: number,	4✔
20	min: number,	4✔
21	max: number	4✔
22	) {	4✔
23	return value >= min && value <= max;	4!
24	}	4✔
25		58✔
26	export function sameObject(a: object, b: object) {	58✔
27	return JSON.stringify(a) === JSON.stringify(b);	621✔
28	}	621✔
29		58✔
30	export function createCounter() {	58✔
31	let i = 0;	133✔
32	return () => {	133✔
33	i++;	2,020✔
34	return i;	2,020✔
35	};	133✔
36	}	133✔
37		58✔
38	/**	58✔
39	* Returns whether an element has a Left-to-Right directionality.	58✔
40	*/	58✔
41	export function isLTR(element: HTMLElement) {	58✔
42	return element.matches(':dir(ltr)');	2,946✔
43	}	2,946✔
44		58✔
45	/**	58✔
46	* Builds a string from format specifiers and replacement parameters.	58✔
47	* Will coerce non-string parameters to their string representations.	58✔
48	*	58✔
49	* @example	58✔
50	* ```typescript	58✔
51	* formatString('{0} says "{1}".', 'John', 'Hello'); // 'John says "Hello".'	58✔
52	* formatString('{1} is greater than {0}', 0, 1); // '1 is greater than 0'	58✔
53	* ```	58✔
54	*/	58✔
55	export function formatString(template: string, ...params: unknown[]): string {	58✔
56	const length = params.length;	606✔
57		606✔
58	return template.replace(/{(\d+)}/g, (match: string, index: number) =>	606✔
59	index >= length ? match : `${params[index]}`	882✔
60	);	606✔
61	}	606✔
62		58✔
63	/**	58✔
64	* Parse the passed `value` as a number or return the `fallback` if it can't be done.	58✔
65	*	58✔
66	* @example	58✔
67	* ```typescript	58✔
68	* asNumber('5'); // 5	58✔
69	* asNumber('3.14'); // 3.14	58✔
70	* asNumber('five'); // 0	58✔
71	* asNUmber('five', 5); // 5	58✔
72	* ```	58✔
73	*/	58✔
74	export function asNumber(value: unknown, fallback = 0) {	58✔
75	const parsed = Number.parseFloat(value as string);	303✔
76	return Number.isNaN(parsed) ? fallback : parsed;	303✔
77	}	303✔
78		58✔
79	/**	58✔
80	* Returns the value wrapped between the min and max bounds.	58✔
81	*	58✔
82	* If the value is greater than max, returns the min and vice-versa.	58✔
83	* If the value is between the bounds, it is returned unchanged.	58✔
84	*	58✔
85	* @example	58✔
86	* ```typescript	58✔
87	* wrap(1, 4, 2); // 2	58✔
88	* wrap(1, 4, 5); // 1	58✔
89	* wrap(1, 4, -1); // 4	58✔
90	* ```	58✔
91	*/	58✔
92	export function wrap(min: number, max: number, value: number) {	58✔
93	if (value < min) {	37✔
94	return max;	11✔
95	}	11✔
96	if (value > max) {	37✔
97	return min;	3✔
98	}	3✔
99		23✔
100	return value;	23✔
101	}	23✔
102		58✔
103	export function isDefined<T = unknown>(value: T) {	58✔
104	return value !== undefined;	1,400✔
105	}	1,400✔
106		58✔
107	export function* iterNodes<T = Node>(	58✔
108	root: Node,	1,054✔
109	whatToShow?: keyof typeof NodeFilter,	1,054✔
110	filter?: (node: T) => boolean	1,054✔
111	): Generator<T> {	1,054✔
112	if (!isDefined(globalThis.document)) {	1,054!
113	return;	×
114	}	×
115		1,054✔
116	const iter = globalThis.document.createTreeWalker(	1,054✔
117	root,	1,054✔
118	NodeFilter[whatToShow ?? 'SHOW_ALL']	1,054!
119	);	1,054✔
120		1,054✔
121	let node = iter.nextNode() as T;	1,054✔
122		1,054✔
123	while (node) {	1,054✔
124	if (filter) {	10,810✔
125	if (filter(node)) {	10,810✔
126	yield node;	4,254✔
127	}	4,254✔
128	} else {	10,810!
129	yield node;	×
130	}	×
131		10,810✔
132	node = iter.nextNode() as T;	10,810✔
133	}	10,810✔
134	}	1,054✔
135		58✔
136	export function getElementByIdFromRoot(root: HTMLElement, id: string) {	58✔
137	return (root.getRootNode() as Document \| ShadowRoot).getElementById(id);	100✔
138	}	100✔
139		58✔
140	export function isElement(node: unknown): node is Element {	58✔
141	return node instanceof Node && node.nodeType === Node.ELEMENT_NODE;	11,774✔
142	}	11,774✔
143		58✔
144	export function getElementsFromEventPath<T extends Element>(event: Event) {	58✔
145	return event.composedPath().filter((item) => isElement(item)) as T[];	1,154✔
146	}	1,154✔
147		58✔
148	export function findElementFromEventPath<T extends Element>(	58✔
149	predicate: string \| ((element: Element) => boolean),	1,154✔
150	event: Event	1,154✔
151	) {	1,154✔
152	const func = isString(predicate)	1,154✔
153	? (e: Element) => e.matches(predicate)	1,154✔
154	: (e: Element) => predicate(e);	1,154✔
155		1,154✔
156	return getElementsFromEventPath(event).find(func) as T \| undefined;	1,154✔
157	}	1,154✔
158		58✔
159	export function groupBy<T>(array: T[], key: keyof T \| ((item: T) => any)) {	58✔
160	const result: Record<string, T[]> = {};	300✔
161	const _get = isFunction(key) ? key : (item: T) => item[key];	300!
162		300✔
163	for (const item of array) {	300✔
164	const category = _get(item);	1,748✔
165	const group = result[category];	1,748✔
166		1,748✔
167	if (Array.isArray(group)) {	1,748✔
168	group.push(item);	1,156✔
169	} else {	1,748✔
170	result[category] = [item];	592✔
171	}	592✔
172	}	1,748✔
173		300✔
174	return result;	300✔
175	}	300✔
176		58✔
177	export function first<T>(arr: T[]) {	58✔
178	return arr.at(0) as T;	11,514✔
179	}	11,514✔
180		58✔
181	export function last<T>(arr: T[]) {	58✔
182	return arr.at(-1) as T;	9,577✔
183	}	9,577✔
184		58✔
185	export function modulo(n: number, d: number) {	58✔
186	return ((n % d) + d) % d;	984✔
187	}	984✔
188		58✔
189	/**	58✔
190	* Creates an array of `n` elements from a given iterator.	58✔
191	*	58✔
192	*/	58✔
193	export function take<T>(iterable: IterableIterator<T>, n: number) {	58✔
194	const result: T[] = [];	409✔
195	let i = 0;	409✔
196	let current = iterable.next();	409✔
197		409✔
198	while (i < n && !current.done) {	409✔
199	result.push(current.value);	2,863✔
200	current = iterable.next();	2,863✔
201	i++;	2,863✔
202	}	2,863✔
203		409✔
204	return result;	409✔
205	}	409✔
206		58✔
207	/**	58✔
208	* Splits an array into chunks of length `size` and returns a generator	58✔
209	* yielding each chunk.	58✔
210	* The last chunk may contain less than `size` elements.	58✔
211	*	58✔
212	* @example	58✔
213	* ```typescript	58✔
214	* const arr = [0,1,2,3,4,5,6,7,8,9];	58✔
215	*	58✔
216	* Array.from(chunk(arr, 2)) // [[0, 1], [2, 3], [4, 5], [6, 7], [8, 9]]	58✔
217	* Array.from(chunk(arr, 3)) // [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]]	58✔
218	* Array.from(chunk([], 3)) // []	58✔
219	* Array.from(chunk(arr, -3)) // Error	58✔
220	* ```	58✔
221	*/	58✔
222	export function* chunk<T>(arr: T[], size: number) {	58✔
223	if (size < 1) {	485!
224	throw new Error('size must be an integer >= 1');	×
225	}	×
226	for (let i = 0; i < arr.length; i += size) {	485✔
227	yield arr.slice(i, i + size);	2,795✔
228	}	2,795✔
229	}	485✔
230		58✔
231	export function splitToWords(text: string) {	58✔
232	const input = text.replaceAll(/[^a-zA-Z0-9\s-_]/g, '');	3,982✔
233	if (/[\s-_]+/.test(input)) return input.split(/[\s-_]+/);	3,982!
234	return input.split(/(?=[A-Z])+/);	3,982✔
235	}	3,982✔
236		58✔
237	export function toKebabCase(text: string): string {	58✔
238	const input = text.trim();	3,982✔
239	return splitToWords(input).join('-').toLocaleLowerCase();	3,982✔
240	}	3,982✔
241		58✔
242	export function isFunction(value: unknown): value is CallableFunction {	58✔
243	return typeof value === 'function';	530✔
244	}	530✔
245		58✔
246	export function isString(value: unknown): value is string {	58✔
247	return typeof value === 'string';	1,303✔
248	}	1,303✔
249		58✔
250	/**	58✔
251	* Returns whether a given collection has at least one member.	58✔
252	*/	58✔
253	export function isEmpty<T, U extends string>(	58✔
254	x: ArrayLike<T> \| Set<T> \| Map<U, T>	6,436✔
255	): boolean {	6,436✔
256	return 'length' in x ? x.length < 1 : x.size < 1;	6,436✔
257	}	6,436✔
258		58✔
259	export function scrollIntoView(	58✔
260	element?: HTMLElement,	80✔
261	config?: ScrollIntoViewOptions	80✔
262	): void {	80✔
263	if (!element) {	80!
NEW 264	return;	×
NEW 265	}	×
266		80✔
267	element.scrollIntoView(	80✔
268	Object.assign(	80✔
269	{	80✔
270	behavior: 'auto',	80✔
271	block: 'nearest',	80✔
272	inline: 'nearest',	80✔
273	},	80✔
274	config	80✔
275	)	80✔
276	);	80✔
277	}	80✔

IgniteUI / igniteui-webcomponents / 11666041265

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