zavadil-ts-common 1.0.0

package/src/component/RestClient.ts

@@ -0,0 +1,153 @@
+import { StringUtil } from "../util";
+import {PagingRequest, SortingField, SortingRequest} from "../type";
+
+export type RestClientHeaders = {};
+
+export class RestClient {
+
+	private baseUrl: string;
+
+	constructor(baseUrl: string) {
+		this.baseUrl = baseUrl;
+	}
+
+	static sortingFieldToString(s: SortingField): string | undefined {
+		return s.desc ? `${s.name} DESC` : s.name;
+	}
+
+	static sortingRequestToString(s: SortingRequest): string | undefined {
+		return s.map((s: SortingField) => RestClient.sortingFieldToString(s)).join(',');
+	}
+
+	static pagingRequestToQueryParams(pr: PagingRequest): any {
+		const result: any = {
+			page: pr.page,
+			size: pr.size
+		}
+		if (pr.search) {
+			result.search = pr.search;
+		}
+		if (pr.sorting) {
+			result.sorting = RestClient.sortingRequestToString(pr.sorting);
+		}
+		return result;
+	}
+
+	/**
+	 * Override this to customize http headers.
+	 */
+	getHeaders(): Promise<RestClientHeaders> {
+		return Promise.resolve(
+			{
+				'Content-Type': 'application/json'
+			}
+		);
+	}
+
+	getUrl(endpoint: string) {
+		return [StringUtil.trimSlashes(this.baseUrl), StringUtil.trimSlashes(endpoint)].join('/');
+	}
+
+	getRequestOptions(method: string = 'GET', data: object | null = null): Promise<any> {
+		return this.getHeaders()
+			.then(
+				(headers) => {
+					return {
+						method: method,
+						headers: headers,
+						body: data === null ? null : JSON.stringify(data)
+					};
+				}
+			);
+	}
+
+	processRequest(endpoint: string, requestOptions?: object): Promise<Response> {
+		return fetch(this.getUrl(endpoint), requestOptions)
+			.then((response) => {
+				if (!response.ok) {
+					const options = {cause: response.status};
+					if (response.headers.get('Content-Type') === 'application/json') {
+						return response
+							.json()
+							.then((json) => {
+								if (json.message) {
+									// @ts-ignore
+									throw new Error(json.message, options);
+								}
+								if (json.error) {
+									// @ts-ignore
+									throw new Error(json.error, options);
+								}
+								// @ts-ignore
+								throw new Error(response.statusText, options);
+							}, () => {
+								// @ts-ignore
+								throw new Error(response.statusText, options);
+							});
+					} else {
+						return response.text().then(
+							(t) => {
+								if (StringUtil.isEmpty(t)) {
+									// @ts-ignore
+									throw new Error(response.statusText, options);
+								} else {
+									// @ts-ignore
+									throw new Error(t, options);
+								}
+							},
+							() => {
+								// @ts-ignore
+								throw new Error(response.statusText, options);
+							}
+						);
+					}
+				}
+				return response;
+			});
+	}
+
+	processRequestJson(url: string, requestOptions?: object | undefined): Promise<any> {
+		return this.processRequest(url, requestOptions)
+			.then((response) => {
+				return response.json();
+			});
+	}
+
+	getJson(url: string, params?: any): Promise<any> {
+		if (params) {
+			const original = new URLSearchParams(params);
+			const cleaned = new URLSearchParams();
+			original.forEach((value, key) => {
+				if (value !== '' && value !== undefined && value !== "undefined")
+					cleaned.set(key, value);
+			});
+			url = `${url}?${cleaned.toString()}`;
+		}
+		return this.getRequestOptions().then(o => this.processRequestJson(url, o));
+	}
+
+	postJson(url: string, data: object | null = null): Promise<any> {
+		return this.getRequestOptions('POST', data).then(o => this.processRequestJson(url, o));
+	}
+
+	putJson(url: string, data: object | null = null): Promise<any> {
+		return this.getRequestOptions('PUT', data).then(o => this.processRequestJson(url, o));
+	}
+
+	get(url: string): Promise<Response> {
+		return this.getRequestOptions().then(o => this.processRequest(url, o));
+	}
+
+	del(url: string): Promise<Response> {
+		return this.getRequestOptions('DELETE').then(o => this.processRequest(url, o));
+	}
+
+	post(url: string, data: object | null = null): Promise<Response> {
+		return this.getRequestOptions('POST', data).then(o => this.processRequest(url, o));
+	}
+
+	put(url: string, data: object | null = null): Promise<Response> {
+		return this.getRequestOptions('PUT', data).then(o => this.processRequest(url, o));
+	}
+
+}

package/src/component/UserAlerts.ts

@@ -0,0 +1,73 @@
+import {UserAlert} from "../type";
+import {EventManager, Func} from "./EventManager";
+
+export class UserAlerts {
+
+	private lifetimeMs: number = 10000;
+
+	private em: EventManager;
+
+	public alerts: Array<UserAlert>;
+
+	constructor() {
+		this.em = new EventManager();
+		this.alerts = [];
+		setInterval(() => this.flushAlerts(), 1000)
+	}
+
+	flushAlerts() {
+		const now = new Date();
+		const threshold = now.getTime() - this.lifetimeMs;
+		this.alerts = this.alerts.filter((a) => a.time.getTime() > threshold);
+		this.triggerChange();
+	}
+
+	addOnChangeHandler(h: Func) {
+		this.em.addEventListener('change', h);
+	}
+
+	removeOnChangeHandler(h: Func) {
+		this.em.removeEventListener('change', h);
+	}
+
+	triggerChange() {
+		this.em.triggerEvent('change');
+	}
+
+	reset() {
+		this.alerts = [];
+		this.triggerChange();
+	}
+
+	remove(alert: UserAlert) {
+		this.alerts.splice(this.alerts.indexOf(alert), 1);
+		this.triggerChange();
+	};
+
+	add(alert: UserAlert) {
+		this.alerts.push(alert);
+		this.triggerChange();
+	}
+
+	custom(type: string, title: string, message: string) {
+		this.add({
+			time: new Date(),
+			type: type,
+			title: title,
+			message: message
+		});
+	}
+
+	err(message: string) {
+		this.custom('danger', 'Error', message);
+	}
+
+	warn(message: string) {
+		this.custom('warning', 'Warning', message);
+	}
+
+	info(message: string) {
+		this.custom('info', 'Warning', message);
+	}
+
+}

package/src/component/index.ts

@@ -0,0 +1,7 @@
+export * from './EventManager';
+export * from './UserAlerts';
+export * from './RestClient';
+export * from './OAuthRestClient';
+export * from './OAuthSessionManager';
+export * from './OAuthSubject';
+export * from './CancellablePromise';

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './type';
+export * from './util';
+export * from './component';

package/src/type/Paging.ts

@@ -0,0 +1,21 @@
+export type SortingField = {
+	name: string;
+	desc?: boolean;
+};
+
+export type SortingRequest = Array<SortingField>;
+
+export type PagingRequest = {
+	page: number;
+	size: number;
+	search?: string | null;
+	sorting: SortingRequest;
+};
+
+export type Page<Type> = {
+	totalPages: number;
+	totalElements: number;
+	number: number;
+	content: Array<Type>;
+};
+

package/src/type/UserAlert.ts

@@ -0,0 +1,6 @@
+export type UserAlert = {
+	time: Date;
+	type: string;
+	title?: string;
+	message: string;
+}

package/src/type/index.ts

@@ -0,0 +1,3 @@
+export * from './Paging';
+export * from './UserAlert';
+

package/src/util/ArrayUtil.ts

@@ -0,0 +1,20 @@
+import { ObjectUtil } from "./ObjectUtil";
+
+export class ArrayUtil {
+
+	static isEmpty(arr?: Array<any> | null): boolean {
+		// @ts-ignore
+		return ObjectUtil.isEmpty(arr) || arr.length === 0;
+	}
+
+	static notEmpty(arr?: Array<any> | null): boolean {
+		return !ArrayUtil.isEmpty(arr);
+	}
+
+	static remove(arr?: Array<any> | null, element?: any): Array<any> {
+		if (ArrayUtil.isEmpty(arr)) return [];
+		// @ts-ignore
+		return arr?.filter(e => e !== element);
+	}
+
+}

package/src/util/AsyncUtil.ts

@@ -0,0 +1,3 @@
+export class AsyncUtil {
+	static sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+}

package/src/util/ByteUtil.ts

@@ -0,0 +1,11 @@
+export class ByteUtil {
+
+	static formatByteSize(size?: number | null): string {
+		const n = Number(size);
+		if (n === null || Number.isNaN(n)) return '';
+		if (n === 0) return '0';
+		const l = Math.floor(Math.log(n) / Math.log(1024));
+		return +((n / Math.pow(1024, l)).toFixed(2)) * 1 + ' ' + ['B', 'kB', 'MB', 'GB', 'TB'][l];
+	}
+
+}

package/src/util/ObjectUtil.ts

@@ -0,0 +1,21 @@
+export class ObjectUtil {
+
+	static isEmpty(obj: any) {
+		return obj === undefined || obj === null;
+	}
+
+	static notEmpty(obj: any) {
+		return !ObjectUtil.isEmpty(obj);
+	}
+
+	static clone<T>(obj: T): T {
+		if (obj === null) {
+			throw new Error("Null cannot be cloned!");
+		}
+		if (typeof obj !== 'object') {
+			throw new Error("Not an object, cannot be cloned!");
+		}
+		return {...obj};
+	}
+
+}

package/src/util/StringUtil.ts

@@ -0,0 +1,65 @@
+import { ObjectUtil } from "./ObjectUtil";
+
+export class StringUtil extends ObjectUtil {
+
+	static isEmpty(str: string | null | undefined): boolean {
+		return ObjectUtil.isEmpty(str) || str?.trim().length === 0;
+	}
+
+	static notEmpty(str: string | null | undefined): boolean {
+		return !StringUtil.isEmpty(str);
+	}
+
+	static substr(str: string | null | undefined, start: number, length?: number): string {
+		if (this.isEmpty(str)) return '';
+
+		// @ts-ignore
+		return str.substring(start, length);
+	}
+
+	static replace(str: string | null | undefined, find?: null | string, replace?: string): string {
+		if (this.isEmpty(str) || this.isEmpty(find)) return '';
+
+		// @ts-ignore
+		return str.replace(find, String(replace));
+	}
+
+	static containsLineBreaks(str: string | null | undefined): boolean {
+		if (str === null || str === undefined || str.trim().length === 0) return false;
+		return str.includes("\n");
+	}
+
+	static trimSlashes(str: string | null): string {
+		if (this.isEmpty(str)) return '';
+
+		// @ts-ignore
+		return str.replace(/^\/|\/$/g, '');
+	}
+
+	static safeTruncate(str: string | null | undefined, len: number, ellipsis: string = ''): string {
+		if (StringUtil.isEmpty(str) || !str) return '';
+		if (str.length <= len) return String(str);
+		return str.substring(0, len - ellipsis.length) + ellipsis;
+	}
+
+	static ellipsis(str: string | null | undefined, len: number, ellipsis: string = '...'): string {
+		return StringUtil.safeTruncate(str, len, ellipsis);
+	}
+
+	static safeTrim(str: string | null | undefined): string {
+		if (StringUtil.isEmpty(str) || !str) return '';
+		return str.trim();
+	}
+
+	static toBigInt(str: string | null): bigint | null {
+		if (this.isEmpty(str)) return null;
+
+		// @ts-ignore
+		return BigInt(str);
+	}
+
+	static getNonEmpty(...args: Array<string | null | undefined>): string {
+		return args.find(a => StringUtil.notEmpty(a)) || "";
+	}
+
+}

package/src/util/index.ts

@@ -0,0 +1,5 @@
+export { ObjectUtil } from './ObjectUtil';
+export { StringUtil } from './StringUtil';
+export { ArrayUtil } from './ArrayUtil';
+export { AsyncUtil } from './AsyncUtil';
+export { ByteUtil } from './ByteUtil';

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+	"compilerOptions": {
+		"moduleResolution": "node",
+		"target": "es5",
+		"module": "ESNext",
+		"lib": [
+			"es6",
+			"dom",
+			"es2020.bigint"
+		],
+		"outDir": "./dist",
+		"rootDir": "./src",
+		"declaration": true,
+		"strict": true,
+		"esModuleInterop": true,
+		"skipLibCheck": true
+	},
+	"include": [
+		"src",
+		"*.tsx",
+		"*.ts"
+	],
+	"exclude": [
+		"node_modules/**",
+		"dist",
+		"docker-compose.yml",
+		".env-example"
+	]
+}