23353730325

Committed 20 Mar 2026 05:03PM UTC coverage: 9.784% (-79.5%) from 89.264%

Build # 23353730325

Build Type

Pull #17069

github

Committed by

web-flow

Commit Message

Merge cfa7e86d1 into a4dc50177

Pull Request Pull Request #17069: fix(IgxGrid): Do not apply width constraint to groups.

Coverage Stats

921 of 16963 branches covered (5.43%)

Branch coverage included in aggregate %.

1 of 3 new or added lines in 1 file covered. (33.33%)

25213 existing lines in 340 files now uncovered.

3842 of 31721 relevant lines covered (12.11%)

6.13 hits per line

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

29.29

/projects/igniteui-angular/core/src/core/utils.ts

import { isPlatformBrowser } from '@angular/common';
import { Injectable, InjectionToken, PLATFORM_ID, inject } from '@angular/core';
import { mergeWith } from 'lodash-es';
import { NEVER, Observable } from 'rxjs';
import { isDevMode } from '@angular/core';
import type { IgxTheme } from '../services/theme/theme.token';

/** @hidden @internal */
export const ELEMENTS_TOKEN = /*@__PURE__*/new InjectionToken<boolean>('elements environment');

/**
 * @hidden
 */
export const showMessage = (message: string, isMessageShown: boolean): boolean => {
    if (!isMessageShown && isDevMode()) {
        console.warn(message);
    }

    return true;
};

/**
 *
 * @hidden @internal
 */
export const getResizeObserver = () => globalThis.window?.ResizeObserver;

/**
 * @hidden
 */
export function cloneArray<T>(array: T[], deep = false): T[] {
    return deep ? (array ?? []).map(cloneValue) : (array ?? []).slice();
}

/**
 * @hidden
 */
export function areEqualArrays<T>(arr1: T[], arr2: T[]): boolean {
    if (arr1.length !== arr2.length) return false;
        for (let i = 0; i < arr1.length; i++) {
          if (arr1[i] !== arr2[i]) return false;
        }
        return true;
}

/**
 * Doesn't clone leaf items
 *
 * @hidden
 */
export const cloneHierarchicalArray = (array: any[], childDataKey: any): any[] => {
    const result: any[] = [];
    if (!array) {
        return result;
    }

    for (const item of array) {
        const clonedItem = cloneValue(item);
        if (Array.isArray(item[childDataKey])) {
            clonedItem[childDataKey] = cloneHierarchicalArray(clonedItem[childDataKey], childDataKey);
        }
        result.push(clonedItem);
    }
    return result;
};

/**
 * Creates an object with prototype from provided source and copies
 * all properties descriptors from provided source
 * @param obj Source to copy prototype and descriptors from
 * @returns New object with cloned prototype and property descriptors
 */
export const copyDescriptors = (obj) => {
    if (obj) {
        return Object.create(
            Object.getPrototypeOf(obj),
            Object.getOwnPropertyDescriptors(obj)
        );
    }
}


/**
 * Deep clones all first level keys of Obj2 and merges them to Obj1
 *
 * @param obj1 Object to merge into
 * @param obj2 Object to merge from
 * @returns Obj1 with merged cloned keys from Obj2
 * @hidden
 */
export const mergeObjects = (obj1: any, obj2: any): any => mergeWith(obj1, obj2, (objValue, srcValue) => {
    if (Array.isArray(srcValue)) {
        return objValue = srcValue;
    }
});

/**
 * Creates deep clone of provided value.
 * Supports primitive values, dates and objects.
 * If passed value is array returns shallow copy of the array.
 *
 * @param value value to clone
 * @returns Deep copy of provided value
 * @hidden
 */
export const cloneValue = (value: any): any => {
    if (isDate(value)) {
        return new Date(value.getTime());
    }
    if (Array.isArray(value)) {
        return value.slice();
    }

    if (value instanceof Map || value instanceof Set) {
        return value;
    }

    if (isObject(value)) {
        const result = {};

        for (const key of Object.keys(value)) {
            if (key === "externalObject") {
                continue;
            }
            result[key] = cloneValue(value[key]);
        }
        return result;
    }
    return value;
};

/**
 * Creates deep clone of provided value.
 * Supports primitive values, dates and objects.
 * If passed value is array returns shallow copy of the array.
 * For Objects property values and references are cached and reused.
 * This allows for circular references to same objects.
 *
 * @param value value to clone
 * @param cache map of cached values already parsed
 * @returns Deep copy of provided value
 * @hidden
 */
export const cloneValueCached = (value: any, cache: Map<any, any>): any => {
    if (isDate(value)) {
        return new Date(value.getTime());
    }
    if (Array.isArray(value)) {
        return [...value];
    }

    if (value instanceof Map || value instanceof Set) {
        return value;
    }

    if (isObject(value)) {
        if (cache.has(value)) {
            return cache.get(value);
        }

        const result = {};
        cache.set(value, result);

        for (const key of Object.keys(value)) {
            result[key] = cloneValueCached(value[key], cache);
        }
        return result;
    }
    return value;
};

/**
 * Parse provided input to Date.
 *
 * @param value input to parse
 * @returns Date if parse succeed or null
 * @hidden
 */
export const parseDate = (value: any): Date | null => {
    // if value is Invalid Date return null
    if (isDate(value)) {
        return !isNaN(value.getTime()) ? value : null;
    }
    return value ? new Date(value) : null;
};

/**
 * Returns an array with unique dates only.
 *
 * @param columnValues collection of date values (might be numbers or ISO 8601 strings)
 * @returns collection of unique dates.
 * @hidden
 */
export const uniqueDates = (columnValues: any[]) => columnValues.reduce((a, c) => {
    if (!a.cache[c.label]) {
        a.result.push(c);
    }
    a.cache[c.label] = true;
    return a;
}, { result: [], cache: {} }).result;

/**
 * Checks if provided variable is Object
 *
 * @param value Value to check
 * @returns true if provided variable is Object
 * @hidden
 */
export const isObject = (value: any): boolean => !!(value && value.toString() === '[object Object]');

/**
 * Checks if provided variable is Date
 *
 * @param value Value to check
 * @returns true if provided variable is Date
 * @hidden
 */
export const isDate = (value: any): value is Date => {
    return Object.prototype.toString.call(value) === "[object Date]";
}

/**
 * Checks if the two passed arguments are equal
 * Currently supports date objects
 *
 * @param obj1
 * @param obj2
 * @returns: `boolean`
 * @hidden
 */
export const isEqual = (obj1, obj2): boolean => {
    if (isDate(obj1) && isDate(obj2)) {
        return obj1.getTime() === obj2.getTime();
    }
    return obj1 === obj2;
};

/**
 * Limits a number to a range between a minimum and a maximum value.
 *
 * @param number
 * @param min
 * @param max
 * @returns: `number`
 * @hidden
 */
export const clamp = (number: number, min: number, max: number) =>
    Math.max(min, Math.min(number, max));


/**
 * Utility service taking care of various utility functions such as
 * detecting browser features, general cross browser DOM manipulation, etc.
 *
 * @hidden @internal
 */
@Injectable({ providedIn: 'root' })
export class PlatformUtil {
    private platformId = inject(PLATFORM_ID);

    public isBrowser: boolean = isPlatformBrowser(this.platformId);
    public isIOS = this.isBrowser && /iPad|iPhone|iPod/.test(navigator.userAgent) && !('MSStream' in window);
    public isSafari = this.isBrowser && /Safari[\/\s](\d+\.\d+)/.test(navigator.userAgent);
    public isFirefox = this.isBrowser && /Firefox[\/\s](\d+\.\d+)/.test(navigator.userAgent);
    public isEdge = this.isBrowser && /Edge[\/\s](\d+\.\d+)/.test(navigator.userAgent);
    public isChromium = this.isBrowser && (/Chrom|e?ium/g.test(navigator.userAgent) ||
        /Google Inc/g.test(navigator.vendor)) && !/Edge/g.test(navigator.userAgent);
    public browserVersion = this.isBrowser ? parseFloat(navigator.userAgent.match(/Version\/([\d.]+)/)?.at(1)) : 0;

    /** @hidden @internal */
    public isElements = inject(ELEMENTS_TOKEN, { optional: true });

    public KEYMAP = {
        ENTER: 'Enter',
        SPACE: ' ',
        ESCAPE: 'Escape',
        ARROW_DOWN: 'ArrowDown',
        ARROW_UP: 'ArrowUp',
        ARROW_LEFT: 'ArrowLeft',
        ARROW_RIGHT: 'ArrowRight',
        END: 'End',
        HOME: 'Home',
        PAGE_DOWN: 'PageDown',
        PAGE_UP: 'PageUp',
        F2: 'F2',
        TAB: 'Tab',
        SEMICOLON: ';',
        // https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values#editing_keys
        DELETE: 'Delete',
        BACKSPACE: 'Backspace',
        CONTROL: 'Control',
        X: 'x',
        Y: 'y',
        Z: 'z'
    } as const;

    /**
     * @hidden @internal
     * Returns the actual size of the node content, using Range
     * ```typescript
     * let range = document.createRange();
     * let column = this.grid.columnList.filter(c => c.field === 'ID')[0];
     *
     * let size = getNodeSizeViaRange(range, column.cells[0].nativeElement);
     *
     * @remarks
     * The last parameter is useful when the size of the element to measure is modified by a
     * parent element that has explicit size. In such cases the calculated size is never lower
     * and the function may instead remove the parent size while measuring to get the correct value.
     * ```
     */
    public getNodeSizeViaRange(range: Range, node: HTMLElement, sizeHoldingNode?: HTMLElement) {
        let overflow = null;
        let nodeStyles: string[];

        if (!this.isFirefox) {
            overflow = node.style.overflow;
            // we need that hack - otherwise content won't be measured correctly in IE/Edge
            node.style.overflow = 'visible';
        }

        if (sizeHoldingNode) {
            const style = sizeHoldingNode.style;
            nodeStyles = [style.width, style.minWidth, style.flexBasis];
            style.width = '';
            style.minWidth = '';
            style.flexBasis = '';
        }

        range.selectNodeContents(node);
        const scale = node.getBoundingClientRect().width / node.offsetWidth;
        const width = range.getBoundingClientRect().width / scale;

        if (!this.isFirefox) {
            // we need that hack - otherwise content won't be measured correctly in IE/Edge
            node.style.overflow = overflow;
        }

        if (sizeHoldingNode) {
            sizeHoldingNode.style.width = nodeStyles[0];
            sizeHoldingNode.style.minWidth = nodeStyles[1];
            sizeHoldingNode.style.flexBasis = nodeStyles[2];
        }

        return width;
    }


    /**
     * Returns true if the current keyboard event is an activation key (Enter/Space bar)
     *
     * @hidden
     * @internal
     *
     * @memberof PlatformUtil
     */
    public isActivationKey(event: KeyboardEvent) {
        return event.key === this.KEYMAP.ENTER || event.key === this.KEYMAP.SPACE;
    }

    /**
     * Returns true if the current keyboard event is a combination that closes the filtering UI of the grid. (Escape/Ctrl+Shift+L)
     *
     * @hidden
     * @internal
     * @param event
     * @memberof PlatformUtil
     */
    public isFilteringKeyCombo(event: KeyboardEvent) {
        return event.key === this.KEYMAP.ESCAPE || (event.ctrlKey && event.shiftKey && event.key.toLowerCase() === 'l');
    }

    /**
     * @hidden @internal
     */
    public isLeftClick(event: PointerEvent | MouseEvent) {
        return event.button === 0;
    }

    /**
     * @hidden @internal
     */
    public isNavigationKey(key: string) {
        return [
            this.KEYMAP.HOME, this.KEYMAP.END, this.KEYMAP.SPACE,
            this.KEYMAP.ARROW_DOWN, this.KEYMAP.ARROW_LEFT, this.KEYMAP.ARROW_RIGHT, this.KEYMAP.ARROW_UP
        ].includes(key as any);
    }
}

/**
 * @hidden
 */
export const flatten = (arr: any[]) => {
    let result = [];

    arr.forEach(el => {
        result.push(el);
        if (el.children) {
            const children = Array.isArray(el.children) ? el.children : el.children.toArray();
            result = result.concat(flatten(children));
        }
    });
    return result;
};

export interface CancelableEventArgs {
    /**
     * Provides the ability to cancel the event.
     */
    cancel: boolean;
}

export interface IBaseEventArgs {
    /**
     * Provides reference to the owner component.
     */
    owner?: any;
}

export interface CancelableBrowserEventArgs extends CancelableEventArgs {
    /* blazorSuppress */
    /** Browser event */
    event?: Event;
}

export interface IBaseCancelableBrowserEventArgs extends CancelableBrowserEventArgs, IBaseEventArgs { }

export interface IBaseCancelableEventArgs extends CancelableEventArgs, IBaseEventArgs { }

export const NAVIGATION_KEYS = new Set([
    'down',
    'up',
    'left',
    'right',
    'arrowdown',
    'arrowup',
    'arrowleft',
    'arrowright',
    'home',
    'end',
    'space',
    'spacebar',
    ' '
]);

/**
 * @hidden
 * @internal
 *
 * Creates a new ResizeObserver on `target` and returns it as an Observable.
 * Run the resizeObservable outside angular zone, because it patches the MutationObserver which causes an infinite loop.
 * Related issue: https://github.com/angular/angular/issues/31712
 */
export const resizeObservable = (target: HTMLElement): Observable<ResizeObserverEntry[]> => {
    const resizeObserver = getResizeObserver();
    // check whether we are on server env or client env
    if (resizeObserver) {
        return new Observable((observer) => {
            const instance = new resizeObserver((entries: ResizeObserverEntry[]) => {
                observer.next(entries);
            });
            instance.observe(target);
            const unsubscribe = () => instance.disconnect();
            return unsubscribe;
        });
    }
    // if on a server env return a empty observable that does not complete immediately
    return NEVER;

}

/**
 * @hidden
 * @internal
 *
 * Compares two maps.
 */
export const compareMaps = (map1: Map<any, any>, map2: Map<any, any>): boolean => {
    if (!map2) {
        return !map1;
    }
    if (map1.size !== map2.size) {
        return false;
    }
    let match = true;
    const keys = Array.from(map2.keys());
    for (const key of keys) {
        if (map1.has(key)) {
            match = map1.get(key) === map2.get(key);
        } else {
            match = false;
        }
        if (!match) {
            break;
        }
    }
    return match;
};

function _isObject(entity: unknown): entity is object {
    return entity != null && typeof entity === 'object';
}

export function columnFieldPath(path?: string): string[] {
    return path?.split('.') ?? [];
}

/**
 * Given a property access path in the format `x.y.z` resolves and returns
 * the value of the `z` property in the passed object.
 *
 * @hidden
 * @internal
 */
export function resolveNestedPath<T extends object, U>(obj: unknown, pathParts: string[], defaultValue?: U): T | U | undefined {
    if (!_isObject(obj) || pathParts.length < 1) {
        return defaultValue;
    }

    let current = obj;

    for (const key of pathParts) {
        if (_isObject(current) && key in (current as T)) {
            current = current[key];
        } else {
            return defaultValue;
        }
    }

    return current as T;
}

/**
 *
 * Given a property access path in the format `x.y.z` and a value
 * this functions builds and returns an object following the access path.
 *
 * @example
 * ```typescript
 * console.log('x.y.z.', 42);
 * >> { x: { y: { z: 42 } } }
 * ```
 *
 * @hidden
 * @internal
 */
export const reverseMapper = (path: string, value: any) => {
    const obj = {};
    const parts = path?.split('.') ?? [];

    let _prop = parts.shift();
    let mapping: any;

    // Initial binding for first level bindings
    obj[_prop] = value;
    mapping = obj;

    parts.forEach(prop => {
        // Start building the hierarchy
        mapping[_prop] = {};
        // Go down a level
        mapping = mapping[_prop];
        // Bind the value and move the key
        mapping[prop] = value;
        _prop = prop;
    });

    return obj;
};

export const isConstructor = (ref: any) => typeof ref === 'function' && Boolean(ref.prototype) && Boolean(ref.prototype.constructor);

/** Converts pixel values to their rem counterparts for a base value */
export const rem = (value: number | string) => {
    const base = parseFloat(globalThis.window?.getComputedStyle(globalThis.document?.documentElement).getPropertyValue('--ig-base-font-size'))
    return Number(value) / base;
}

/** Get the size of the component as derived from the CSS size variable */
export function getComponentSize(el: Element) {
    return globalThis.window?.getComputedStyle(el).getPropertyValue('--component-size');
}

/** Get the first item in an array */
export function first<T>(arr: T[]) {
    return arr.at(0) as T;
}

/** Get the last item in an array */
export function last<T>(arr: T[]) {
    return arr.at(-1) as T;
}

/** Calculates the modulo of two numbers, ensuring a non-negative result. */
export function modulo(n: number, d: number) {
    return ((n % d) + d) % d;
}

/**
 * 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* intoChunks<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);
    }
}

/**
 * @param size
 * @returns string that represents the --component-size default value
 */
export function getComponentCssSizeVar(size: string) {
    switch (size) {
        case "1":
            return 'var(--ig-size, var(--ig-size-small))';
        case "2":
            return 'var(--ig-size, var(--ig-size-medium))';
        default:
            return 'var(--ig-size, var(--ig-size-large))';
    }
}

/**
 * @param path - The URI path to be normalized.
 * @returns string encoded using the encodeURI function.
 */
export function normalizeURI(path: string) {
    return path?.split('/').map(encodeURI).join('/');
}

export function getComponentTheme(el: Element) {
    return globalThis.window
        ?.getComputedStyle(el)
        .getPropertyValue('--theme')
        .trim() as IgxTheme;
}

/**
 * Collection re-created w/ the built in track by identity will always log
 * warning even for valid cases of recalculating all collection items.
 * See https://github.com/angular/angular/blob/55581b4181639568fb496e91055142a1b489e988/packages/core/src/render3/instructions/control_flow.ts#L393-L409
 * Current solution explicit track function doing the same as suggested in:
 * https://github.com/angular/angular/issues/56471#issuecomment-2180315803
 * This should be used with moderation and when necessary.
 * @internal
 */
export function trackByIdentity<T>(item: T): T {
    return item;
}

1	import { isPlatformBrowser } from '@angular/common';
2	import { Injectable, InjectionToken, PLATFORM_ID, inject } from '@angular/core';
3	import { mergeWith } from 'lodash-es';
4	import { NEVER, Observable } from 'rxjs';
5	import { isDevMode } from '@angular/core';
6	import type { IgxTheme } from '../services/theme/theme.token';
7
8	/** @hidden @internal */
9	export const ELEMENTS_TOKEN = /@__PURE__/new InjectionToken<boolean>('elements environment');	3✔
10
11	/**
12	* @hidden
13	*/
14	export const showMessage = (message: string, isMessageShown: boolean): boolean => {	3✔
15	if (!isMessageShown && isDevMode()) {	×
16	console.warn(message);	×
17	}
18
19	return true;	×
20	};
21
22	/**
23	*
24	* @hidden @internal
25	*/
26	export const getResizeObserver = () => globalThis.window?.ResizeObserver;	39✔
27
28	/**
29	* @hidden
30	*/
31	export function cloneArray<T>(array: T[], deep = false): T[] {	×
UNCOV 32	return deep ? (array ?? []).map(cloneValue) : (array ?? []).slice();	×
33	}
34
35	/**
36	* @hidden
37	*/
38	export function areEqualArrays<T>(arr1: T[], arr2: T[]): boolean {
39	if (arr1.length !== arr2.length) return false;	11!
40	for (let i = 0; i < arr1.length; i++) {	11✔
UNCOV 41	if (arr1[i] !== arr2[i]) return false;	×
42	}
43	return true;	11✔
44	}
45
46	/**
47	* Doesn't clone leaf items
48	*
49	* @hidden
50	*/
51	export const cloneHierarchicalArray = (array: any[], childDataKey: any): any[] => {	3✔
UNCOV 52	const result: any[] = [];	×
UNCOV 53	if (!array) {	×
54	return result;	×
55	}
56
UNCOV 57	for (const item of array) {	×
UNCOV 58	const clonedItem = cloneValue(item);	×
UNCOV 59	if (Array.isArray(item[childDataKey])) {	×
UNCOV 60	clonedItem[childDataKey] = cloneHierarchicalArray(clonedItem[childDataKey], childDataKey);	×
61	}
UNCOV 62	result.push(clonedItem);	×
63	}
UNCOV 64	return result;	×
65	};
66
67	/**
68	* Creates an object with prototype from provided source and copies
69	* all properties descriptors from provided source
70	* @param obj Source to copy prototype and descriptors from
71	* @returns New object with cloned prototype and property descriptors
72	*/
73	export const copyDescriptors = (obj) => {	3✔
UNCOV 74	if (obj) {	×
UNCOV 75	return Object.create(	×
76	Object.getPrototypeOf(obj),
77	Object.getOwnPropertyDescriptors(obj)
78	);
79	}
80	}
81
82
83	/**
84	* Deep clones all first level keys of Obj2 and merges them to Obj1
85	*
86	* @param obj1 Object to merge into
87	* @param obj2 Object to merge from
88	* @returns Obj1 with merged cloned keys from Obj2
89	* @hidden
90	*/
91	export const mergeObjects = (obj1: any, obj2: any): any => mergeWith(obj1, obj2, (objValue, srcValue) => {	3✔
UNCOV 92	if (Array.isArray(srcValue)) {	×
UNCOV 93	return objValue = srcValue;	×
94	}
95	});
96
97	/**
98	* Creates deep clone of provided value.
99	* Supports primitive values, dates and objects.
100	* If passed value is array returns shallow copy of the array.
101	*
102	* @param value value to clone
103	* @returns Deep copy of provided value
104	* @hidden
105	*/
106	export const cloneValue = (value: any): any => {	3✔
UNCOV 107	if (isDate(value)) {	×
UNCOV 108	return new Date(value.getTime());	×
109	}
UNCOV 110	if (Array.isArray(value)) {	×
UNCOV 111	return value.slice();	×
112	}
113
UNCOV 114	if (value instanceof Map \|\| value instanceof Set) {	×
UNCOV 115	return value;	×
116	}
117
UNCOV 118	if (isObject(value)) {	×
UNCOV 119	const result = {};	×
120
UNCOV 121	for (const key of Object.keys(value)) {	×
UNCOV 122	if (key === "externalObject") {	×
123	continue;	×
124	}
UNCOV 125	result[key] = cloneValue(value[key]);	×
126	}
UNCOV 127	return result;	×
128	}
UNCOV 129	return value;	×
130	};
131
132	/**
133	* Creates deep clone of provided value.
134	* Supports primitive values, dates and objects.
135	* If passed value is array returns shallow copy of the array.
136	* For Objects property values and references are cached and reused.
137	* This allows for circular references to same objects.
138	*
139	* @param value value to clone
140	* @param cache map of cached values already parsed
141	* @returns Deep copy of provided value
142	* @hidden
143	*/
144	export const cloneValueCached = (value: any, cache: Map<any, any>): any => {	3✔
145	if (isDate(value)) {	×
146	return new Date(value.getTime());	×
147	}
148	if (Array.isArray(value)) {	×
149	return [...value];	×
150	}
151
152	if (value instanceof Map \|\| value instanceof Set) {	×
153	return value;	×
154	}
155
156	if (isObject(value)) {	×
157	if (cache.has(value)) {	×
158	return cache.get(value);	×
159	}
160
161	const result = {};	×
162	cache.set(value, result);	×
163
164	for (const key of Object.keys(value)) {	×
165	result[key] = cloneValueCached(value[key], cache);	×
166	}
167	return result;	×
168	}
169	return value;	×
170	};
171
172	/**
173	* Parse provided input to Date.
174	*
175	* @param value input to parse
176	* @returns Date if parse succeed or null
177	* @hidden
178	*/
179	export const parseDate = (value: any): Date \| null => {	3✔
180	// if value is Invalid Date return null
UNCOV 181	if (isDate(value)) {	×
UNCOV 182	return !isNaN(value.getTime()) ? value : null;	×
183	}
UNCOV 184	return value ? new Date(value) : null;	×
185	};
186
187	/**
188	* Returns an array with unique dates only.
189	*
190	* @param columnValues collection of date values (might be numbers or ISO 8601 strings)
191	* @returns collection of unique dates.
192	* @hidden
193	*/
194	export const uniqueDates = (columnValues: any[]) => columnValues.reduce((a, c) => {	3✔
195	if (!a.cache[c.label]) {	×
196	a.result.push(c);	×
197	}
198	a.cache[c.label] = true;	×
199	return a;	×
200	}, { result: [], cache: {} }).result;
201
202	/**
203	* Checks if provided variable is Object
204	*
205	* @param value Value to check
206	* @returns true if provided variable is Object
207	* @hidden
208	*/
209	export const isObject = (value: any): boolean => !!(value && value.toString() === '[object Object]');	3!
210
211	/**
212	* Checks if provided variable is Date
213	*
214	* @param value Value to check
215	* @returns true if provided variable is Date
216	* @hidden
217	*/
218	export const isDate = (value: any): value is Date => {	3✔
UNCOV 219	return Object.prototype.toString.call(value) === "[object Date]";	×
220	}
221
222	/**
223	* Checks if the two passed arguments are equal
224	* Currently supports date objects
225	*
226	* @param obj1
227	* @param obj2
228	* @returns: `boolean`
229	* @hidden
230	*/
231	export const isEqual = (obj1, obj2): boolean => {	3✔
UNCOV 232	if (isDate(obj1) && isDate(obj2)) {	×
UNCOV 233	return obj1.getTime() === obj2.getTime();	×
234	}
UNCOV 235	return obj1 === obj2;	×
236	};
237
238	/**
239	* Limits a number to a range between a minimum and a maximum value.
240	*
241	* @param number
242	* @param min
243	* @param max
244	* @returns: `number`
245	* @hidden
246	*/
247	export const clamp = (number: number, min: number, max: number) =>	3✔
UNCOV 248	Math.max(min, Math.min(number, max));	×
249
250
251	/**
252	* Utility service taking care of various utility functions such as
253	* detecting browser features, general cross browser DOM manipulation, etc.
254	*
255	* @hidden @internal
256	*/
257	@Injectable({ providedIn: 'root' })
258	export class PlatformUtil {	3✔
259	private platformId = inject(PLATFORM_ID);	1✔
260
261	public isBrowser: boolean = isPlatformBrowser(this.platformId);	1✔
262	public isIOS = this.isBrowser && /iPad\|iPhone\|iPod/.test(navigator.userAgent) && !('MSStream' in window);	1!
263	public isSafari = this.isBrowser && /Safari[\/\s](\d+\.\d+)/.test(navigator.userAgent);	1✔
264	public isFirefox = this.isBrowser && /Firefox[\/\s](\d+\.\d+)/.test(navigator.userAgent);	1✔
265	public isEdge = this.isBrowser && /Edge[\/\s](\d+\.\d+)/.test(navigator.userAgent);	1✔
266	public isChromium = this.isBrowser && (/Chrom\|e?ium/g.test(navigator.userAgent) \|\|	1!
267	/Google Inc/g.test(navigator.vendor)) && !/Edge/g.test(navigator.userAgent);
268	public browserVersion = this.isBrowser ? parseFloat(navigator.userAgent.match(/Version\/([\d.]+)/)?.at(1)) : 0;	1!
269
270	/** @hidden @internal */
271	public isElements = inject(ELEMENTS_TOKEN, { optional: true });	1✔
272
273	public KEYMAP = {	1✔
274	ENTER: 'Enter',
275	SPACE: ' ',
276	ESCAPE: 'Escape',
277	ARROW_DOWN: 'ArrowDown',
278	ARROW_UP: 'ArrowUp',
279	ARROW_LEFT: 'ArrowLeft',
280	ARROW_RIGHT: 'ArrowRight',
281	END: 'End',
282	HOME: 'Home',
283	PAGE_DOWN: 'PageDown',
284	PAGE_UP: 'PageUp',
285	F2: 'F2',
286	TAB: 'Tab',
287	SEMICOLON: ';',
288	// https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values#editing_keys
289	DELETE: 'Delete',
290	BACKSPACE: 'Backspace',
291	CONTROL: 'Control',
292	X: 'x',
293	Y: 'y',
294	Z: 'z'
295	} as const;
296
297	/**
298	* @hidden @internal
299	* Returns the actual size of the node content, using Range
300	* ```typescript
301	* let range = document.createRange();
302	* let column = this.grid.columnList.filter(c => c.field === 'ID')[0];
303	*
304	* let size = getNodeSizeViaRange(range, column.cells[0].nativeElement);
305	*
306	* @remarks
307	* The last parameter is useful when the size of the element to measure is modified by a
308	* parent element that has explicit size. In such cases the calculated size is never lower
309	* and the function may instead remove the parent size while measuring to get the correct value.
310	* ```
311	*/
312	public getNodeSizeViaRange(range: Range, node: HTMLElement, sizeHoldingNode?: HTMLElement) {
UNCOV 313	let overflow = null;	×
314	let nodeStyles: string[];
315
UNCOV 316	if (!this.isFirefox) {	×
UNCOV 317	overflow = node.style.overflow;	×
318	// we need that hack - otherwise content won't be measured correctly in IE/Edge
UNCOV 319	node.style.overflow = 'visible';	×
320	}
321
UNCOV 322	if (sizeHoldingNode) {	×
UNCOV 323	const style = sizeHoldingNode.style;	×
UNCOV 324	nodeStyles = [style.width, style.minWidth, style.flexBasis];	×
UNCOV 325	style.width = '';	×
UNCOV 326	style.minWidth = '';	×
UNCOV 327	style.flexBasis = '';	×
328	}
329
UNCOV 330	range.selectNodeContents(node);	×
UNCOV 331	const scale = node.getBoundingClientRect().width / node.offsetWidth;	×
UNCOV 332	const width = range.getBoundingClientRect().width / scale;	×
333
UNCOV 334	if (!this.isFirefox) {	×
335	// we need that hack - otherwise content won't be measured correctly in IE/Edge
UNCOV 336	node.style.overflow = overflow;	×
337	}
338
UNCOV 339	if (sizeHoldingNode) {	×
UNCOV 340	sizeHoldingNode.style.width = nodeStyles[0];	×
UNCOV 341	sizeHoldingNode.style.minWidth = nodeStyles[1];	×
UNCOV 342	sizeHoldingNode.style.flexBasis = nodeStyles[2];	×
343	}
344
UNCOV 345	return width;	×
346	}
347
348
349	/**
350	* Returns true if the current keyboard event is an activation key (Enter/Space bar)
351	*
352	* @hidden
353	* @internal
354	*
355	* @memberof PlatformUtil
356	*/
357	public isActivationKey(event: KeyboardEvent) {
UNCOV 358	return event.key === this.KEYMAP.ENTER \|\| event.key === this.KEYMAP.SPACE;	×
359	}
360
361	/**
362	* Returns true if the current keyboard event is a combination that closes the filtering UI of the grid. (Escape/Ctrl+Shift+L)
363	*
364	* @hidden
365	* @internal
366	* @param event
367	* @memberof PlatformUtil
368	*/
369	public isFilteringKeyCombo(event: KeyboardEvent) {
UNCOV 370	return event.key === this.KEYMAP.ESCAPE \|\| (event.ctrlKey && event.shiftKey && event.key.toLowerCase() === 'l');	×
371	}
372
373	/**
374	* @hidden @internal
375	*/
376	public isLeftClick(event: PointerEvent \| MouseEvent) {
UNCOV 377	return event.button === 0;	×
378	}
379
380	/**
381	* @hidden @internal
382	*/
383	public isNavigationKey(key: string) {
UNCOV 384	return [	×
385	this.KEYMAP.HOME, this.KEYMAP.END, this.KEYMAP.SPACE,
386	this.KEYMAP.ARROW_DOWN, this.KEYMAP.ARROW_LEFT, this.KEYMAP.ARROW_RIGHT, this.KEYMAP.ARROW_UP
387	].includes(key as any);
388	}
389	}
390
391	/**
392	* @hidden
393	*/
394	export const flatten = (arr: any[]) => {	3✔
395	let result = [];	1,065✔
396
397	arr.forEach(el => {	1,065✔
398	result.push(el);	2,320✔
399	if (el.children) {	2,320✔
400	const children = Array.isArray(el.children) ? el.children : el.children.toArray();	427!
401	result = result.concat(flatten(children));	427✔
402	}
403	});
404	return result;	1,065✔
405	};
406
407	export interface CancelableEventArgs {
408	/**
409	* Provides the ability to cancel the event.
410	*/
411	cancel: boolean;
412	}
413
414	export interface IBaseEventArgs {
415	/**
416	* Provides reference to the owner component.
417	*/
418	owner?: any;
419	}
420
421	export interface CancelableBrowserEventArgs extends CancelableEventArgs {
422	/* blazorSuppress */
423	/** Browser event */
424	event?: Event;
425	}
426
427	export interface IBaseCancelableBrowserEventArgs extends CancelableBrowserEventArgs, IBaseEventArgs { }
428
429	export interface IBaseCancelableEventArgs extends CancelableEventArgs, IBaseEventArgs { }
430
431	export const NAVIGATION_KEYS = new Set([	3✔
432	'down',
433	'up',
434	'left',
435	'right',
436	'arrowdown',
437	'arrowup',
438	'arrowleft',
439	'arrowright',
440	'home',
441	'end',
442	'space',
443	'spacebar',
444	' '
445	]);
446
447	/**
448	* @hidden
449	* @internal
450	*
451	* Creates a new ResizeObserver on `target` and returns it as an Observable.
452	* Run the resizeObservable outside angular zone, because it patches the MutationObserver which causes an infinite loop.
453	* Related issue: https://github.com/angular/angular/issues/31712
454	*/
455	export const resizeObservable = (target: HTMLElement): Observable<ResizeObserverEntry[]> => {	3✔
456	const resizeObserver = getResizeObserver();	8✔
457	// check whether we are on server env or client env
458	if (resizeObserver) {	8✔
459	return new Observable((observer) => {	8✔
460	const instance = new resizeObserver((entries: ResizeObserverEntry[]) => {	8✔
UNCOV 461	observer.next(entries);	×
462	});
463	instance.observe(target);	8✔
464	const unsubscribe = () => instance.disconnect();	8✔
465	return unsubscribe;	8✔
466	});
467	}
468	// if on a server env return a empty observable that does not complete immediately
469	return NEVER;	×
470
471	}
472
473	/**
474	* @hidden
475	* @internal
476	*
477	* Compares two maps.
478	*/
479	export const compareMaps = (map1: Map<any, any>, map2: Map<any, any>): boolean => {	3✔
UNCOV 480	if (!map2) {	×
UNCOV 481	return !map1;	×
482	}
UNCOV 483	if (map1.size !== map2.size) {	×
484	return false;	×
485	}
UNCOV 486	let match = true;	×
UNCOV 487	const keys = Array.from(map2.keys());	×
UNCOV 488	for (const key of keys) {	×
UNCOV 489	if (map1.has(key)) {	×
UNCOV 490	match = map1.get(key) === map2.get(key);	×
491	} else {
492	match = false;	×
493	}
UNCOV 494	if (!match) {	×
UNCOV 495	break;	×
496	}
497	}
UNCOV 498	return match;	×
499	};
500
501	function _isObject(entity: unknown): entity is object {
502	return entity != null && typeof entity === 'object';	186✔
503	}
504
505	export function columnFieldPath(path?: string): string[] {
506	return path?.split('.') ?? [];	93!
507	}
508
509	/**
510	* Given a property access path in the format `x.y.z` resolves and returns
511	* the value of the `z` property in the passed object.
512	*
513	* @hidden
514	* @internal
515	*/
516	export function resolveNestedPath<T extends object, U>(obj: unknown, pathParts: string[], defaultValue?: U): T \| U \| undefined {
517	if (!_isObject(obj) \|\| pathParts.length < 1) {	93!
UNCOV 518	return defaultValue;	×
519	}
520
521	let current = obj;	93✔
522
523	for (const key of pathParts) {	93✔
524	if (_isObject(current) && key in (current as T)) {	93!
UNCOV 525	current = current[key];	×
526	} else {
527	return defaultValue;	93✔
528	}
529	}
530
UNCOV 531	return current as T;	×
532	}
533
534	/**
535	*
536	* Given a property access path in the format `x.y.z` and a value
537	* this functions builds and returns an object following the access path.
538	*
539	* @example
540	* ```typescript
541	* console.log('x.y.z.', 42);
542	* >> { x: { y: { z: 42 } } }
543	* ```
544	*
545	* @hidden
546	* @internal
547	*/
548	export const reverseMapper = (path: string, value: any) => {	3✔
UNCOV 549	const obj = {};	×
UNCOV 550	const parts = path?.split('.') ?? [];	×
551
UNCOV 552	let _prop = parts.shift();	×
553	let mapping: any;
554
555	// Initial binding for first level bindings
UNCOV 556	obj[_prop] = value;	×
UNCOV 557	mapping = obj;	×
558
UNCOV 559	parts.forEach(prop => {	×
560	// Start building the hierarchy
UNCOV 561	mapping[_prop] = {};	×
562	// Go down a level
UNCOV 563	mapping = mapping[_prop];	×
564	// Bind the value and move the key
UNCOV 565	mapping[prop] = value;	×
UNCOV 566	_prop = prop;	×
567	});
568
UNCOV 569	return obj;	×
570	};
571
572	export const isConstructor = (ref: any) => typeof ref === 'function' && Boolean(ref.prototype) && Boolean(ref.prototype.constructor);	20✔
573
574	/** Converts pixel values to their rem counterparts for a base value */
575	export const rem = (value: number \| string) => {	3✔
UNCOV 576	const base = parseFloat(globalThis.window?.getComputedStyle(globalThis.document?.documentElement).getPropertyValue('--ig-base-font-size'))	×
UNCOV 577	return Number(value) / base;	×
578	}
579
580	/** Get the size of the component as derived from the CSS size variable */
581	export function getComponentSize(el: Element) {
UNCOV 582	return globalThis.window?.getComputedStyle(el).getPropertyValue('--component-size');	×
583	}
584
585	/** Get the first item in an array */
586	export function first<T>(arr: T[]) {
UNCOV 587	return arr.at(0) as T;	×
588	}
589
590	/** Get the last item in an array */
591	export function last<T>(arr: T[]) {
UNCOV 592	return arr.at(-1) as T;	×
593	}
594
595	/** Calculates the modulo of two numbers, ensuring a non-negative result. */
596	export function modulo(n: number, d: number) {
UNCOV 597	return ((n % d) + d) % d;	×
598	}
599
600	/**
601	* Splits an array into chunks of length `size` and returns a generator
602	* yielding each chunk.
603	* The last chunk may contain less than `size` elements.
604	*
605	* @example
606	* ```typescript
607	* const arr = [0,1,2,3,4,5,6,7,8,9];
608	*
609	* Array.from(chunk(arr, 2)) // [[0, 1], [2, 3], [4, 5], [6, 7], [8, 9]]
610	* Array.from(chunk(arr, 3)) // [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]]
611	* Array.from(chunk([], 3)) // []
612	* Array.from(chunk(arr, -3)) // Error
613	* ```
614	*/
615	export function* intoChunks<T>(arr: T[], size: number) {
UNCOV 616	if (size < 1) {	×
617	throw new Error('size must be an integer >= 1');	×
618	}
UNCOV 619	for (let i = 0; i < arr.length; i += size) {	×
UNCOV 620	yield arr.slice(i, i + size);	×
621	}
622	}
623
624	/**
625	* @param size
626	* @returns string that represents the --component-size default value
627	*/
628	export function getComponentCssSizeVar(size: string) {
629	switch (size) {	×
630	case "1":
631	return 'var(--ig-size, var(--ig-size-small))';	×
632	case "2":
633	return 'var(--ig-size, var(--ig-size-medium))';	×
634	default:
635	return 'var(--ig-size, var(--ig-size-large))';	×
636	}
637	}
638
639	/**
640	* @param path - The URI path to be normalized.
641	* @returns string encoded using the encodeURI function.
642	*/
643	export function normalizeURI(path: string) {
UNCOV 644	return path?.split('/').map(encodeURI).join('/');	×
645	}
646
647	export function getComponentTheme(el: Element) {
UNCOV 648	return globalThis.window	×
649	?.getComputedStyle(el)
650	.getPropertyValue('--theme')
651	.trim() as IgxTheme;
652	}
653
654	/**
655	* Collection re-created w/ the built in track by identity will always log
656	* warning even for valid cases of recalculating all collection items.
657	* See https://github.com/angular/angular/blob/55581b4181639568fb496e91055142a1b489e988/packages/core/src/render3/instructions/control_flow.ts#L393-L409
658	* Current solution explicit track function doing the same as suggested in:
659	* https://github.com/angular/angular/issues/56471#issuecomment-2180315803
660	* This should be used with moderation and when necessary.
661	* @internal
662	*/
663	export function trackByIdentity<T>(item: T): T {
UNCOV 664	return item;	×
665	}

IgniteUI / igniteui-angular / 23353730325

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