@oardi/ts-utils 0.0.20 → 0.0.21

package/extensions/array-extension.ts

@@ -0,0 +1,54 @@
+import { sortHelper } from '../helpers';
+import { Dictionary } from '../types';
+
+export {};
+
+declare global {
+	interface Array<T> {
+		distinct<T>(comparator?: (obj1: unknown, obj2: unknown) => boolean): T[];
+		filterBy<T>(valueGetter: (a: T) => boolean): T[];
+		first(): T;
+		groupBy(valueGetter: (a: T) => string): Dictionary<T[]>;
+		orderBy<T, G>(valueGetter: (a: T) => G, ascending?: boolean): T[];
+		removeBy<T, G>(valueGetter: (a: T) => G, val: G): T[];
+	}
+}
+
+Array.prototype.distinct = function <T>(comparator?: (obj1: unknown, obj2: unknown) => boolean): T[] {
+	const thisAsArray: T[] = this as T[];
+	const result: T[] = comparator
+		? thisAsArray.filter((value, index, array) => array.findIndex((o) => comparator(o, value)) === index)
+		: thisAsArray.filter((value, index, array) => array.indexOf(value) === index);
+	return result;
+};
+
+Array.prototype.filterBy = function <T>(valueGetter: (a: T) => boolean): T[] {
+	return this.filter((obj) => {
+		return valueGetter(obj);
+	});
+};
+
+Array.prototype.first = function <T>(): Nullable<T> {
+	return this?.length > 0 ? this[0] : null;
+};
+
+Array.prototype.groupBy = function <T>(valueGetter: (a: T) => string): Dictionary<T> {
+	return this.reduce((curr, obj) => {
+		const key: string = valueGetter(obj);
+		(curr[key] = curr[key] || []).push(obj);
+		return curr;
+	}, {});
+};
+
+Array.prototype.orderBy = function <T, G>(valueGetter: (a: T) => G, ascending: boolean = true): T[] {
+	this?.sort((a, b) => sortHelper(a, b, valueGetter, ascending));
+	return this;
+};
+
+Array.prototype.removeBy = function <T, G>(valueGetter: (a: T) => G, val: G): T[] {
+	return this.filter((curr) => {
+		const key: G = valueGetter(curr);
+		// change to split to remove only first item found
+		return key !== val;
+	});
+};

package/extensions/date-extension.ts

@@ -0,0 +1,69 @@
+import type { ConfigType, ManipulateType, OpUnitType, UnitType } from 'dayjs';
+import dayjs from 'dayjs';
+import localizedFormat from 'dayjs/plugin/localizedFormat';
+dayjs.extend(localizedFormat);
+
+declare global {
+	interface Date {
+		isAfter(date: ConfigType, unit?: OpUnitType): boolean;
+		isBefore(date: ConfigType, unit?: OpUnitType): boolean;
+		format(template?: string): string;
+		isValid(): boolean;
+		add(value: number, unit?: ManipulateType): Date;
+		subtract(value: number, unit?: ManipulateType): Date;
+		firstDayOfMonth(): Date;
+		lastDayOfMonth(): Date;
+		set(unit: UnitType, value: number): Date;
+		diff(date: Date, unit?: UnitType): number;
+		startOf(unit: UnitType): Date;
+		endOf(unit: UnitType): Date;
+	}
+}
+
+Date.prototype.isAfter = function (date: dayjs.ConfigType, unit?: dayjs.OpUnitType): boolean {
+	return dayjs(this).isAfter(date, unit);
+};
+
+Date.prototype.isBefore = function (date: dayjs.ConfigType, unit?: dayjs.OpUnitType): boolean {
+	return dayjs(this).isBefore(date, unit);
+};
+
+Date.prototype.format = function (template?: string): string {
+	return dayjs(this).format(template);
+};
+
+Date.prototype.isValid = function (): boolean {
+	return dayjs(this).isValid();
+};
+
+Date.prototype.add = function (value: number, unit?: ManipulateType): Date {
+	return dayjs(this).add(value, unit).toDate();
+};
+
+Date.prototype.subtract = function (value: number, unit?: ManipulateType): Date {
+	return dayjs(this).subtract(value, unit).toDate();
+};
+
+Date.prototype.firstDayOfMonth = function (): Date {
+	return dayjs(this).startOf('month').toDate();
+};
+
+Date.prototype.lastDayOfMonth = function (): Date {
+	return dayjs(this).endOf('month').toDate();
+};
+
+Date.prototype.set = function (unit: UnitType, value: number): Date {
+	return dayjs(this).set(unit, value).toDate();
+};
+
+Date.prototype.diff = function (date: Date, unit?: UnitType): number {
+	return dayjs(this).diff(date, unit);
+};
+
+Date.prototype.startOf = function (unit: UnitType): Date {
+	return dayjs(this).startOf(unit).toDate();
+};
+
+Date.prototype.endOf = function (unit: UnitType): Date {
+	return dayjs(this).endOf(unit).toDate();
+};

package/extensions/{index.d.ts → index.ts}

@@ -1,4 +1,3 @@
 export * from './array-extension';
 export * from './date-extension';
 export * from './string-extensions';
-//# sourceMappingURL=index.d.ts.map

package/extensions/string-extensions.ts

@@ -0,0 +1,21 @@
+export {};
+
+declare global {
+	interface String {
+		capitalize(): string;
+		isNumber(): boolean;
+		isEmpty(): boolean;
+	}
+}
+
+String.prototype.capitalize = function (): string {
+	return this.charAt(0).toUpperCase() + this.slice(1);
+};
+
+String.prototype.isNumber = function (): boolean {
+	return !isNaN(Number(this)) && this.trim() !== '';
+};
+
+String.prototype.isEmpty = function (): boolean {
+	return this === undefined || !this || this.length === 0;
+};

package/helpers/browser/browser-type.enum.ts

@@ -0,0 +1,13 @@
+export enum BrowserType {
+	opera = 'opera',
+	firefox = 'firefox',
+	safari = 'safari',
+	ie = 'ie',
+	edge = 'edge',
+	edg = 'edg',
+	electron = 'electron',
+	chrome = 'chrome',
+	iOsSafari = 'iOsSafari',
+	edgiOs = 'edgiOs',
+	headlessChrome = 'headlessChrome',
+}

package/helpers/browser/browser.helper.ts

@@ -0,0 +1,95 @@
+import { BrowserType } from './browser-type.enum';
+
+export class BrowserHelper {
+	static isOpera(): boolean {
+		return (
+			typeof window !== 'undefined' &&
+			((!!(window as any).opr && !!(window as any).opr.addons) ||
+				!!(window as any).opera ||
+				navigator.userAgent.includes('OPR/'))
+		);
+	}
+
+	static isFirefox(): boolean {
+		return typeof (globalThis as any).InstallTrigger !== 'undefined';
+	}
+
+	static isSafari(): boolean {
+		if (typeof window === 'undefined') return false;
+		return (
+			/constructor/i.test((window as any).HTMLElement) ||
+			((p: any) => p.toString() === '[object SafariRemoteNotification]')(
+				!(window as any)['safari'] || ((window as any)['safari'] && (window as any)['safari'].pushNotification)
+			)
+		);
+	}
+
+	static isEdge(): boolean {
+		if (typeof window === 'undefined') return false;
+		return !BrowserHelper.isIE() && !!(window as any).StyleMedia;
+	}
+
+	static isIE(): boolean {
+		if (typeof document === 'undefined') return false;
+		return !!(document as any).documentMode;
+	}
+
+	static isEdg(): boolean {
+		if (typeof navigator === 'undefined') return false;
+		return navigator.userAgent.toLowerCase().includes('edg');
+	}
+
+	static isElectron(userAgentLower: string): boolean {
+		return userAgentLower.includes('electron');
+	}
+
+	static isChrome(): boolean {
+		if (typeof window === 'undefined') return false;
+		return (
+			!!(window as any).chrome &&
+			!BrowserHelper.isOpera() &&
+			!BrowserHelper.isEdge() &&
+			!BrowserHelper.isEdg() &&
+			!BrowserHelper.isFirefox() &&
+			!BrowserHelper.isSafari() &&
+			!BrowserHelper.isIE()
+		);
+	}
+
+	static isIOsSafari(userAgentLower: string): boolean {
+		return (
+			userAgentLower.includes('iphone') ||
+			userAgentLower.includes('ipad') ||
+			(userAgentLower.includes('macintosh') &&
+				typeof document !== 'undefined' &&
+				'ontouchend' in document &&
+				userAgentLower.includes('safari'))
+		);
+	}
+
+	static isEdgiOs(userAgentLower: string): boolean {
+		return userAgentLower.includes('edgios');
+	}
+
+	static isHeadlessChrome(userAgentLower: string): boolean {
+		return userAgentLower.includes('headlesschrome');
+	}
+
+	public getCurrentBrowser(): BrowserType {
+		const userAgent = navigator.userAgent.toLowerCase();
+
+		if (BrowserHelper.isOpera()) return BrowserType.opera;
+		if (BrowserHelper.isFirefox()) return BrowserType.firefox;
+		if (BrowserHelper.isSafari()) return BrowserType.safari;
+		if (BrowserHelper.isIE()) return BrowserType.ie;
+		if (BrowserHelper.isEdge()) return BrowserType.edge;
+		if (BrowserHelper.isEdg()) return BrowserType.edg;
+		if (BrowserHelper.isElectron(userAgent)) return BrowserType.electron;
+		if (BrowserHelper.isChrome()) return BrowserType.chrome;
+		if (BrowserHelper.isIOsSafari(userAgent)) return BrowserType.iOsSafari;
+		if (BrowserHelper.isEdgiOs(userAgent)) return BrowserType.edgiOs;
+		if (BrowserHelper.isHeadlessChrome(userAgent)) return BrowserType.headlessChrome;
+
+		throw new Error('Browser could not be detected: ' + userAgent);
+	}
+}

package/helpers/browser/{index.d.ts → index.ts}

@@ -1,3 +1,2 @@
 export * from './browser.helper';
 export * from './browser-type.enum';
-//# sourceMappingURL=index.d.ts.map

package/helpers/clipboard.helper.ts

@@ -0,0 +1,3 @@
+export function copyToClipboard(text: string): Promise<void> {
+	return navigator.clipboard.writeText(text);
+}

package/helpers/csv.helper.ts

@@ -0,0 +1,23 @@
+import type { ParseResult, UnparseConfig, UnparseObject } from 'papaparse';
+import pkg from 'papaparse';
+const { parse, unparse } = pkg;
+
+export class CsvHelper {
+	static unparse<T>(data: T[] | UnparseObject<T>, config?: UnparseConfig): string {
+		return unparse(data, config);
+	}
+
+	static parse<T>(content: string | File): Promise<ParseResult<T>> {
+		return new Promise((resolve, reject) => {
+			parse(content, {
+				header: true,
+				complete: (results: ParseResult<T>) => resolve(results),
+				error: (err: Error) => reject(err),
+			});
+		});
+	}
+}
+
+// usage
+// const csvData: string = CsvHelper.unparse(data);
+// const result: ParseResult<TranslationCsvDataModel> = CsvHelper.parse(file);

package/helpers/download.helper.ts

@@ -0,0 +1,127 @@
+export type SaveSource = Blob | ArrayBuffer | Uint8Array | string;
+
+export interface SaveOptions {
+	mimeType?: string;	/** MIME-Type, falls `source` kein Blob ist (z. B. "application/pdf") */
+	showSaveFilePicker?: boolean;
+}
+
+/**
+ * save file on client
+ *
+ * 1) File System Access API (showSaveFilePicker) – if supported
+ * 2) Fallback: <a download> + blob: URL
+ * 3) iOS-/Safari-Fallback: open new Tab if download-attribute is being ignored
+ */
+export async function saveAs(source: SaveSource, fileName: string, options?: SaveOptions): Promise<void> {
+	const mime: string = options?.mimeType ?? guessMimeFromFilename(fileName);
+	const blob: Blob = ensureBlob(source, mime);
+
+	// 1) experimental - feature check
+	if ('showSaveFilePicker' in window && options?.showSaveFilePicker) {
+		try {
+			const handle: FileSystemFileHandle = await (
+				window as unknown as {
+					showSaveFilePicker: (opts: {
+						suggestedName?: string;
+						types?: { description?: string; accept: Record<string, string[]> }[];
+					}) => Promise<FileSystemFileHandle>;
+				}
+			).showSaveFilePicker({
+				suggestedName: fileName,
+				types: [{ description: 'Datei', accept: { [mime]: [`.${extOf(fileName)}`] } }],
+			});
+
+			const writable: FileSystemWritableFileStream = await handle.createWritable();
+			await writable.write(blob);
+			await writable.close();
+			return;
+		} catch (err) {
+			// Abbruch durch Nutzer oder fehlende Berechtigung -> auf Fallback gehen
+			// (keine Early-Return mitten in der Funktion – wir laufen weiter)
+		}
+	}
+
+	// 2) classic: <a download> + blob: URL
+	const url: string = URL.createObjectURL(blob);
+
+	// In iOS Safari kann `download` für blob:-URLs ignoriert werden.
+	// Wir versuchen es zuerst regulär, und fallbacken dann auf "neuen Tab öffnen".
+	const anchor: HTMLAnchorElement = document.createElement('a');
+	anchor.href = url;
+	anchor.download = fileName;
+	anchor.rel = 'noopener'; // gute Praxis
+	anchor.style.display = 'none';
+	document.body.appendChild(anchor);
+
+	triggerClick(anchor);
+
+	// Kurzer Delay, dann Cleanup + optionaler iOS-Fallback
+	window.setTimeout(() => {
+		document.body.removeChild(anchor);
+		URL.revokeObjectURL(url);
+	}, 0);
+
+	// Heuristik: Wenn Safari das download-Attribut ignoriert, bleibt häufig dieselbe Seite,
+	// ohne dass ein Download-Dialog erscheint. Wir bieten dann eine Sicht-Alternative an.
+	// (Bewusst defensiv: wir öffnen nur, wenn `download` potenziell ignoriert wird.)
+	if (isProbablyIOSorOldSafari()) {
+		// Öffnet die Ressource in einem neuen Tab, damit der Nutzer manuell speichern kann.
+		// (Für PDFs & Bilder oft ausreichend; für Binärdateien hilft korrekter MIME-Type.)
+		window.open(url, '_blank', 'noopener,noreferrer');
+	}
+}
+
+function ensureBlob(source: SaveSource, mime: string): Blob {
+	if (source instanceof Blob) {
+		return source.type ? source : new Blob([source], { type: mime });
+	}
+	if (source instanceof ArrayBuffer || source instanceof Uint8Array) {
+		const buf: Uint8Array<ArrayBufferLike> = source instanceof Uint8Array ? source : new Uint8Array(source);
+		return new Blob([buf as BlobPart], { type: mime });
+	}
+	// string -> als Text-BLOB speichern
+	return new Blob([source], { type: mime || 'text/plain;charset=utf-8' });
+}
+
+function guessMimeFromFilename(filename: string): string {
+	const ext: string = extOf(filename).toLowerCase();
+	switch (ext) {
+		case 'txt':
+			return 'text/plain;charset=utf-8';
+		case 'csv':
+			return 'text/csv;charset=utf-8';
+		case 'json':
+			return 'application/json;charset=utf-8';
+		case 'pdf':
+			return 'application/pdf';
+		case 'png':
+			return 'image/png';
+		case 'jpg':
+		case 'jpeg':
+			return 'image/jpeg';
+		case 'svg':
+			return 'image/svg+xml';
+		case 'zip':
+			return 'application/zip';
+		default:
+			return 'application/octet-stream';
+	}
+}
+
+function extOf(filename: string): string {
+	const idx: number = filename.lastIndexOf('.');
+	return idx >= 0 && idx < filename.length - 1 ? filename.slice(idx + 1) : '';
+}
+
+function triggerClick(el: HTMLElement): void {
+	const evt: MouseEvent = document.createEvent('MouseEvents');
+	evt.initMouseEvent('click', true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
+	el.dispatchEvent(evt);
+}
+
+function isProbablyIOSorOldSafari(): boolean {
+	const userAgent: string = navigator.userAgent;
+	const isIOS: boolean = /iPad|iPhone|iPod/.test(userAgent);
+	const isSafari: boolean = /^((?!chrome|android).)*safari/i.test(userAgent);
+	return isIOS || isSafari;
+}

package/helpers/enum.helper.ts

@@ -0,0 +1,20 @@
+import { IKeyValue } from '../interfaces/keyvalue.interface';
+
+export class EnumHelper {
+	static getEnumValue<T extends object>(enumObj: T, key: string): T[keyof T] {
+		if (!(key in enumObj)) {
+			throw Error(`${key} not found in ${enumObj}`);
+		} else {
+			return enumObj[key as keyof T];
+		}
+	}
+
+	static getKeyValues<T extends object>(enumObj: T): IKeyValue<string>[] {
+		return Object.keys(enumObj)
+			.filter(key => !isNaN(Number(key)))
+			.map(key => ({
+				key: Number(key),
+				value: enumObj[key as unknown as keyof T] as string,
+			}));
+	}
+}

package/helpers/file.helper.ts

@@ -0,0 +1,105 @@
+import { saveAs } from './download.helper';
+
+export class FileHelper {
+	static getFileExtension(filename: string): string {
+		let result: string = '';
+		const index: number = filename.lastIndexOf('.');
+		const hasExtension: boolean = index > 0 && index < filename.length - 1; // index > 0 verhindert z.B.: ".bashrc" als Extension
+		if (hasExtension) {
+			const ext: string = filename.substring(index + 1);
+			result = `.${ext.toLowerCase()}`;
+		}
+		return result;
+	}
+
+	/**
+	 * read content from a file or blob
+	 */
+	static readAsText(file: File): Promise<string> {
+		const fileReader: FileReader = new FileReader();
+		return new Promise((resolve, reject) => {
+			fileReader.onload = (): void => {
+				fileReader.onload = null;
+				fileReader.onerror = null;
+				if (typeof fileReader.result === 'string') {
+					resolve(fileReader.result);
+				} else {
+					reject(new Error('Unexpected result type'));
+				}
+			};
+			fileReader.onerror = (): void => {
+				const error = fileReader.error ?? new Error('FileReader error');
+				fileReader.onload = null;
+				fileReader.onerror = null;
+				reject(error);
+			};
+			fileReader.readAsText(file);
+		});
+	}
+
+	static readAsArrayBuffer(file: File): Promise<ArrayBuffer> {
+		const fileReader: FileReader = new FileReader();
+		return new Promise((resolve, reject) => {
+			fileReader.onload = (): void => {
+				fileReader.onload = null;
+				fileReader.onerror = null;
+				if (fileReader.result instanceof ArrayBuffer) {
+					resolve(fileReader.result);
+				} else {
+					reject(new Error('Unexpected result type'));
+				}
+			};
+			fileReader.onerror = (): void => {
+				const error = fileReader.error ?? new Error('FileReader error');
+				fileReader.onload = null;
+				fileReader.onerror = null;
+				reject(error);
+			};
+			fileReader.readAsArrayBuffer(file);
+		});
+	}
+
+	static readAsDataUrl(file: File): Promise<ProgressEvent<FileReader>> {
+		const reader: FileReader = new FileReader();
+		return new Promise((resolve, reject) => {
+			reader.onload = (event: ProgressEvent<FileReader>): void => {
+				resolve(event);
+			};
+			reader.onerror = (error): void => reject(error);
+			reader.readAsDataURL(file);
+		});
+	}
+
+	/** usage:
+	 * const file = new File(['Hello'], 'test.txt');
+	 * FileHelper.formatFileSize(file.size);
+	 * */
+	static formatFileSize(bytes: number, decimals: number = 2, unit?: 'Bytes' | 'KB' | 'MB' | 'GB' | 'TB'): string {
+		if (bytes === 0) {
+			return '0 Bytes';
+		}
+
+		const k = 1024;
+		const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+
+		let i = Math.floor(Math.log(bytes) / Math.log(k));
+
+		if (unit && sizes.includes(unit)) {
+			i = sizes.indexOf(unit);
+		}
+
+		const value = bytes / Math.pow(k, i);
+		const fixed = parseFloat(value.toFixed(decimals));
+
+		return `${fixed} ${sizes[i]}`;
+	}
+
+	static save(content: BlobPart, fileName: string, fileType: string): void {
+		const blob: Blob = new Blob([content], { type: fileType });
+		saveAs(blob, fileName);
+	}
+}
+
+// usage
+// const extension: string = FileHelper.getFileExtension('asdf.txt');
+// -> .txt

package/helpers/{index.d.ts → index.ts}

@@ -7,4 +7,3 @@ export * from './local-storage.helper';
 export * from './logger';
 export * from './sort.helper';
 export * from './token';
-//# sourceMappingURL=index.d.ts.map

package/helpers/local-storage.helper.ts

@@ -0,0 +1,30 @@
+export class LocalStorageHelper {
+	static set<T>(key: string, value: T): void {
+		localStorage.setItem(key, JSON.stringify(value));
+	}
+
+	static get<T>(key: string): Nullable<T> {
+		let result: Nullable<T> = null;
+		const local: Nullable<string> = localStorage.getItem(key);
+		if (local) {
+			result = JSON.parse(local);
+		}
+		return result;
+	}
+
+	static remove(key: string): boolean {
+		let result: boolean = !!LocalStorageHelper.get(key);
+		if (result) {
+			localStorage.removeItem(key);
+		}
+		return result;
+	}
+
+	static removeAll(): void {
+		localStorage.clear();
+	}
+
+	static getKeysBy(key: string): string[] {
+		return Object.keys(localStorage).filter(k => k.startsWith(key));
+	}
+}

package/helpers/logger/index.ts

@@ -0,0 +1 @@
+export * from './logger.helper';

package/helpers/logger/logger-type.enum.ts

@@ -0,0 +1,7 @@
+export enum LoggerType {
+	log = 'log',
+	info = 'info',
+	warn = 'warn',
+	debug = 'debug',
+	error = 'error',
+}

package/helpers/logger/logger.helper.ts

@@ -0,0 +1,63 @@
+import { LoggerType } from './logger-type.enum';
+import { LoggerListener, LoggerPayload } from './logger.types';
+
+export class LoggerHelper {
+	private static listeners: Set<LoggerListener> = new Set();
+
+	public static log(...args: unknown[]): void {
+		LoggerHelper.doLog(LoggerType.log, args);
+	}
+
+	public static info(...args: unknown[]): void {
+		LoggerHelper.doLog(LoggerType.info, args);
+	}
+
+	public static warn(...args: unknown[]): void {
+		LoggerHelper.doLog(LoggerType.warn, args);
+	}
+
+	public static debug(...args: unknown[]): void {
+		LoggerHelper.doLog(LoggerType.debug, args);
+	}
+
+	public static error(...args: unknown[]): void {
+		LoggerHelper.doLog(LoggerType.error, args);
+	}
+
+	private static doLog(level: LoggerType, args: unknown[]): void {
+		const payload: LoggerPayload = {
+			type: level,
+			args,
+			timestamp: new Date().toISOString(),
+		};
+		for (const listener of LoggerHelper.listeners) {
+			try {
+				const res = listener(payload);
+				if (res === false) {
+					return; // cancelled by listener
+				}
+			} catch {
+				// swallow listener errors so logging never breaks the app
+			}
+		}
+
+		(console as Console)[level].apply(console, args);
+	}
+
+	public static onLog(listener: LoggerListener, once = false): () => void {
+		if (once) {
+			const wrapper: LoggerListener = (payload) => {
+				try {
+					return listener(payload);
+				} finally {
+					LoggerHelper.listeners.delete(wrapper);
+				}
+			};
+			LoggerHelper.listeners.add(wrapper);
+			return () => LoggerHelper.listeners.delete(wrapper);
+		}
+
+		LoggerHelper.listeners.add(listener);
+		return () => LoggerHelper.listeners.delete(listener);
+	}
+}

package/helpers/logger/{logger.types.d.ts → logger.types.ts}

@@ -1,8 +1,9 @@
 import { LoggerType } from './logger-type.enum';
+
 export type LoggerPayload = {
-    type: LoggerType;
-    args: unknown[];
-    timestamp: string;
+	type: LoggerType;
+	args: unknown[];
+	timestamp: string;
 };
+
 export type LoggerListener = (payload: LoggerPayload) => void | boolean;
-//# sourceMappingURL=logger.types.d.ts.map