@twobirds/microcomponents/public/src/helpers.ts

Micro Components Organization Class

'use strict';

export interface LooseObject {
	[key: string | symbol]: any;
}

export function isNativeObject(value: any): boolean {
	return value && value['constructor'] && value.constructor === Object;
}

export function sortObject(o: LooseObject): LooseObject {
	let result: LooseObject = {},
		keys = [...Object.keys(o)].sort();

	keys.forEach((key) => {
		if (isNativeObject(o[key])) {
			result[key] = sortObject(o[key]);
		} else {
			result[key] = o[key];
		}
	});

	return result;
}

export function flattenObject(
	o: LooseObject,
	doSort: boolean = true
): LooseObject {
	let result: LooseObject = {};

	[...Object.getOwnPropertyNames(o)].forEach((propName) => {
		if (
			o[propName] &&
			o[propName]['constructor'] &&
			o[propName].constructor === Object
		) {
			const temp = flattenObject(o[propName], false);
			for (const j in temp) {
				result[propName + '.' + j] = temp[j];
			}
		} else {
			result[propName] = o[propName];
		}
	});

	return doSort ? sortObject(result) : result;
}

export function deepEqual(o1: LooseObject, o2: LooseObject): boolean {
	return (
		JSON.stringify(flattenObject(o1)) === JSON.stringify(flattenObject(o2))
	);
}

export function nameSpace(ns: string | string[], obj: LooseObject = {}): any {
	let nsa = ns.constructor === String ? ns.split('.') : ns;

	if (!obj || !nsa[0] || !obj[nsa[0]]) {
		console.warn('ns', nsa[0], 'not in', obj);
		return;
	}
	if (obj[nsa[0]].constructor === Object && nsa.length > 1) {
		return nameSpace((nsa as string[]).splice(1), obj[nsa[0]]);
	}
	return obj[nsa[0]];
}

export function parse(what: string | Object | any[], parseThis: Object) {
	var args = Array.from(arguments);

	if (args.length > 2) {
		while (args.length > 1) {
			args[0] = parse(args[0], args[1]);
			args.splice(1, 1);
		}
		return args[0];
	}

	if (typeof what === 'string') {
		what.match(/\{[^\{\}]*\}/g)?.forEach(function (pPropname) {
			var propname = pPropname.substring(1, pPropname.length - 1),
				value = nameSpace(propname, parseThis);
			//console.log(propname, value);
			if (typeof value !== 'undefined') {
				what = (what as string).replace(pPropname, value);
			}
		});
	} else if (isNativeObject(what)) {
		switch (what.constructor) {
			case Object:
				Object.keys(what).forEach(function (pKey) {
					if (what.hasOwnProperty(pKey)) {
						(what as LooseObject)[pKey] = parse(
							(what as LooseObject)[pKey],
							parseThis
						);
					}
				});
				break;
			case Array:
				(what as Array<any>).forEach(function (pValue, pKey, original) {
					original[pKey] = parse((what as any)[pKey], parseThis);
				});
				break;
		}
	}

	return what;
}

export function kebabToPascal(str: string) {
	return str
		.split('-') // Split by hyphens
		.map((word) => word.charAt(0).toUpperCase() + word.slice(1)) // Capitalize each part
		.join(''); // Join without spaces
}

export function debounce(func: Function, milliseconds: number): Function {
	let timeout: any;
	return () => {
		clearTimeout(timeout);

		timeout = setTimeout(function () {
			func(...arguments);
		}, milliseconds);
	};
}

export function htmlToElements(html: string): HTMLElement[] {
	let template = document.createElement('template');

	html = html.replace(/<([A-Za-z0-9\-]*)([^>\/]*)(\/>)/gi, '<$1$2></$1>'); // replace XHTML closing tags by full closing tags

	template.innerHTML = html;

	template.content.normalize();

	return Array.from(template.content.childNodes) as HTMLElement[];
}

export function copyGettersSetters(source: LooseObject, target: LooseObject) {
	const descriptors = Object.getOwnPropertyDescriptors(source);
	for (const [key, descriptor] of Object.entries(descriptors)) {
		if ('get' in descriptor || 'set' in descriptor) {
			Object.defineProperty(target, key, descriptor);
		}
	}
}