Added PUT method to http helper

package-lock.json

@@ -1,12 +1,12 @@
 {
 	"name": "@ztimson/utils",
-	"version": "0.10.4",
+	"version": "0.15.3",
 	"lockfileVersion": 3,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "@ztimson/utils",
-			"version": "0.10.4",
+			"version": "0.15.3",
 			"license": "MIT",
 			"devDependencies": {
 				"@types/jest": "^29.5.12",

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ztimson/utils",
-	"version": "0.14.0",
+	"version": "0.15.5",
 	"description": "Utility library",
 	"author": "Zak Timson",
 	"license": "MIT",
@@ -9,13 +9,13 @@
 		"type": "git",
 		"url": "https://git.zakscode.com/ztimson/js-utilities"
 	},
-	"main": "./dist/utils.cjs",
+	"main": "./dist/index.cjs",
-	"module": "./dist/utils.mjs",
+	"module": "./dist/index.mjs",
 	"types": "./dist/index.d.ts",
 	"exports": {
 		".": {
-			"import": "./dist/utils.mjs",
+			"import": "./dist/index.mjs",
-			"require": "./dist/utils.cjs",
+			"require": "./dist/index.cjs",
 			"types": "./dist/index.d.ts"
 		}
 	},

src/aset.ts

@@ -1,57 +1,108 @@
+/**
+ * An array which functions as a set. It guarantees unique elements
+ * and provides set functions for comparisons
+ */
 export class ASet<T> extends Array {
+	/** Number of elements in set */
 	get size() {
 		return this.length;
 	}
 
+	/**
+	 * Array to create set from, duplicate values will be removed
+	 * @param {T[]} elements Elements which will be added to set
+	 */
 	constructor(elements: T[] = []) {
 		super();
 		if(!!elements?.['forEach'])
 			elements.forEach(el => this.add(el));
 	}
 
+	/**
+	 * Add single element to set if unique
+	 * @param {T} el Element to add
+	 */
 	add(el: T) {
 		if(!this.has(el)) this.push(el);
 	}
 
+	/**
+	 * Delete element from set
+	 * @param {T} el Element that will be deleted
+	 */
 	delete(el: T) {
 		const index = this.indexOf(el);
 		if(index != -1) this.slice(index, 1);
 	}
 
+	/**
+	 * Create list of elements this set has which the comparison set does not
+	 * @param {ASet<T>} set Set to compare against
+	 * @return {ASet<T>} Different elements
+	 */
 	difference(set: ASet<T>) {
-		return new ASet<T>(this.reduce((acc, el) => {
+		return new ASet<T>(this.filter(el => !set.has(el)));
-			if(!set.has(el)) acc.push(el);
-			return acc;
-		}, []));
 	}
 
+	/**
+	 * Check if set includes element
+	 * @param {T} el Element to look for
+	 * @return {boolean} True if element was found, false otherwise
+	 */
 	has(el: T) {
 		return this.indexOf(el) != -1;
 	}
 
+	/**
+	 * Create list of elements this set has in common with the comparison set
+	 * @param {ASet<T>} set Set to compare against
+	 * @return {boolean} Set of common elements
+	 */
 	intersection(set: ASet<T>) {
-		return new ASet<T>(this.reduce((acc, el) => {
+		return new ASet<T>(this.filter(el => set.has(el)));
-			if(set.has(el)) acc.push(el);
-			return acc;
-		}, []));
 	}
 
+	/**
+	 * Check if this set has no elements in common with the comparison set
+	 * @param {ASet<T>} set Set to compare against
+	 * @return {boolean} True if nothing in common, false otherwise
+	 */
 	isDisjointFrom(set: ASet<T>) {
 		return this.intersection(set).size == 0;
 	}
 
+	/**
+	 * Check if all elements in this set are included in the comparison set
+	 * @param {ASet<T>} set Set to compare against
+	 * @return {boolean} True if all elements are included, false otherwise
+	 */
 	isSubsetOf(set: ASet<T>) {
 		return this.findIndex(el => !set.has(el)) == -1;
 	}
 
+	/**
+	 * Check if all elements from comparison set are included in this set
+	 * @param {ASet<T>} set Set to compare against
+	 * @return {boolean} True if all elements are included, false otherwise
+	 */
 	isSuperset(set: ASet<T>) {
 		return set.findIndex(el => !this.has(el)) == -1;
 	}
 
+	/**
+	 * Create list of elements that are only in one set but not both (XOR)
+	 * @param {ASet<T>} set Set to compare against
+	 * @return {ASet<T>} New set of unique elements
+	 */
 	symmetricDifference(set: ASet<T>) {
 		return new ASet([...this.difference(set), ...set.difference(this)]);
 	}
 
+	/**
+	 * Create joined list of elements included in this & the comparison set
+	 * @param {ASet<T>} set Set join
+	 * @return {ASet<T>} New set of both previous sets combined
+	 */
 	union(set: ASet<T> | Array<T>) {
 		return new ASet([...this, ...set]);
 	}

src/errors.ts

@@ -53,6 +53,18 @@ export class UnauthorizedError extends CustomError {
 	}
 }
 
+export class PaymentRequiredError extends CustomError {
+	static code = 402;
+
+	constructor(message: string = 'Payment Required') {
+		super(message);
+	}
+
+	static instanceof(err: Error) {
+		return (<any>err).constructor.code == this.code;
+	}
+}
+
 export class ForbiddenError extends CustomError {
 	static code = 403;
 
@@ -77,6 +89,30 @@ export class NotFoundError extends CustomError {
 	}
 }
 
+export class MethodNotAllowedError extends CustomError {
+	static code = 405;
+
+	constructor(message: string = 'Method Not Allowed') {
+		super(message);
+	}
+
+	static instanceof(err: Error) {
+		return (<any>err).constructor.code == this.code;
+	}
+}
+
+export class NotAcceptableError extends CustomError {
+	static code = 406;
+
+	constructor(message: string = 'Not Acceptable') {
+		super(message);
+	}
+
+	static instanceof(err: Error) {
+		return (<any>err).constructor.code == this.code;
+	}
+}
+
 export class InternalServerError extends CustomError {
 	static code = 500;
 
@@ -88,3 +124,89 @@ export class InternalServerError extends CustomError {
 		return (<any>err).constructor.code == this.code;
 	}
 }
+
+export class NotImplementedError extends CustomError {
+	static code = 501;
+
+	constructor(message: string = 'Not Implemented') {
+		super(message);
+	}
+
+	static instanceof(err: Error) {
+		return (<any>err).constructor.code == this.code;
+	}
+}
+
+export class BadGatewayError extends CustomError {
+	static code = 502;
+
+	constructor(message: string = 'Bad Gateway') {
+		super(message);
+	}
+
+	static instanceof(err: Error) {
+		return (<any>err).constructor.code == this.code;
+	}
+}
+
+export class ServiceUnavailableError extends CustomError {
+	static code = 503;
+
+	constructor(message: string = 'Service Unavailable') {
+		super(message);
+	}
+
+	static instanceof(err: Error) {
+		return (<any>err).constructor.code == this.code;
+	}
+}
+
+export class GatewayTimeoutError extends CustomError {
+	static code = 504;
+
+	constructor(message: string = 'Gateway Timeout') {
+		super(message);
+	}
+
+	static instanceof(err: Error) {
+		return (<any>err).constructor.code == this.code;
+	}
+}
+
+/**
+ * Create the correct error object from a status code
+ * @param {number} code Will be converted to respective error (ex. 404 -> NotFoundError)
+ * @param {string} message Override default error message
+ * @return {CustomError} The proper error type
+ */
+export function errorFromCode(code: number, message?: string) {
+	if(code >= 200 && code < 300) return null;
+	switch(code) {
+		case 400:
+			return new BadRequestError(message);
+		case 401:
+			return new UnauthorizedError(message);
+		case 402:
+			return new PaymentRequiredError(message);
+		case 403:
+			return new ForbiddenError(message);
+		case 404:
+			return new NotFoundError(message);
+		case 405:
+			return new MethodNotAllowedError(message);
+		case 406:
+			return new NotAcceptableError(message);
+		case 500:
+			return new InternalServerError(message);
+		case 501:
+			return new NotImplementedError(message);
+		case 502:
+			return new BadGatewayError(message);
+		case 503:
+			return new ServiceUnavailableError(message);
+		case 504:
+			return new GatewayTimeoutError(message);
+		default:
+			return new CustomError(message, code);
+	}
+}

src/files.ts

@@ -1,4 +1,5 @@
-import {PromiseProgress} from './promise-progress.ts';
+import {deepCopy, JSONAttemptParse} from './objects.ts';
+import {PromiseProgress} from './promise-progress';
 
 export function download(href: any, name: string) {
 	const a = document.createElement('a');
@@ -31,24 +32,25 @@ export function fileBrowser(options: {accept?: string, multiple?: boolean} = {})
 	});
 }
 
-export function uploadWithProgress(options: {
+export function uploadWithProgress<T>(options: {
 	url: string;
-	file: File;
+	files: File[];
 	headers?: {[key: string]: string};
 	withCredentials?: boolean;
-}) {
+}): PromiseProgress<T> {
-	return new PromiseProgress((res, rej, prog) => {
+	return new PromiseProgress<T>((res, rej, prog) => {
 		const xhr = new XMLHttpRequest();
 		const formData = new FormData();
-		formData.append('file', options.file);
+		options.files.forEach(f => formData.append('file', f));
 
-		xhr.withCredentials = !!options.withCredentials
+		xhr.withCredentials = !!options.withCredentials;
-		Object.entries(options.headers || {}).forEach(([key, value]) => xhr.setRequestHeader(key, value));
 		xhr.upload.addEventListener('progress', (event) => event.lengthComputable ? prog(event.loaded / event.total) : null);
-		xhr.upload.addEventListener('load', (resp) => res(resp));
+		xhr.addEventListener('loadend', () => res(<T>JSONAttemptParse(xhr.responseText)));
-		xhr.upload.addEventListener('error', (err) => rej(err));
+		xhr.addEventListener('error', () => rej(JSONAttemptParse(xhr.responseText)));
+		xhr.addEventListener('timeout', () => rej({error: 'Request timed out'}));
 
 		xhr.open('POST', options.url);
+		Object.entries(options.headers || {}).forEach(([key, value]) => xhr.setRequestHeader(key, value));
 		xhr.send(formData);
 	});
 }

src/http.ts

@@ -1,17 +1,18 @@
 import {clean} from './objects';
 import {PromiseProgress} from './promise-progress';
 
-export type DecodedResponse<T> = Response & {data?: T}
+export type DecodedResponse<T> = Response & {data: T | null}
 
 export type HttpInterceptor = (response: Response, next: () => void) => void;
 
 export type HttpRequestOptions = {
-	url?: string;
-	fragment?: string;
-	query?: {key: string, value: string}[] | {[key: string]: string};
-	method?: 'GET' | 'POST' | 'PATCH' | 'DELETE';
 	body?: any;
+	decode?: boolean;
+	fragment?: string;
 	headers?: {[key: string | symbol]: string | null | undefined};
+	method?: 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE';
+	query?: {key: string, value: string}[] | {[key: string]: string};
+	url?: string;
 	[key: string]: any;
 }
 
@@ -70,7 +71,7 @@ export class Http {
 		});
 
 		if(typeof opts.body == 'object' && opts.body != null && headers['Content-Type'] == 'application/json')
-			opts.body = JSON.stringify(opts.json);
+			opts.body = JSON.stringify(opts.body);
 
 		// Send request
 		return new PromiseProgress((res, rej, prog) => {
@@ -78,14 +79,11 @@ export class Http {
 				headers,
 				method: opts.method || (opts.body ? 'POST' : 'GET'),
 				body: opts.body
-			}).then(async (resp: DecodedResponse<T>) => {
+			}).then(async (resp: any) => {
-				console.log('done!');
 				for(let fn of [...Object.values(Http.interceptors), ...Object.values(this.interceptors)]) {
 					await new Promise<void>(res => fn(resp, () => res()));
 				}
 
-				if(!resp.ok) rej(resp);
-
 				const contentLength = resp.headers.get('Content-Length');
 				const total = contentLength ? parseInt(contentLength, 10) : 0;
 				let loaded = 0;
@@ -94,28 +92,29 @@ export class Http {
 				const stream = new ReadableStream({
 					start(controller) {
 						function push() {
-							reader?.read().then(({done, value}) => {
+							reader?.read().then((event: any) => {
-								if(done) return controller.close();
+								if(event.done) return controller.close();
-								loaded += value.byteLength;
+								loaded += event.value.byteLength;
 								prog(loaded / total);
-								controller.enqueue(value);
+								controller.enqueue(event.value);
 								push();
-							}).catch(error => {
+							}).catch((error: any) => controller.error(error));
-								controller.error(error);
-							});
 						}
 						push();
 					}
 				});
 
-				const data = new Response(stream);
+				resp.data = new Response(stream);
-
+				if(opts.decode == null || opts.decode) {
 					const content = resp.headers.get('Content-Type')?.toLowerCase();
-				if(content?.includes('json')) resp.data = <T>await data.json();
+					if(content?.includes('form')) resp.data = <T>await resp.data.formData();
-				else if(content?.includes('text')) resp.data = <T>await data.text();
+					else if(content?.includes('json')) resp.data = <T>await resp.data.json();
-				else if(content?.includes('form')) resp.data = <T>await data.formData();
+					else if(content?.includes('text')) resp.data = <T>await resp.data.text();
-				else if(content?.includes('application')) resp.data = <T>await data.blob();
+					else if(content?.includes('application')) resp.data = <T>await resp.data.blob();
-				res(resp);
+				}
+
+				if(resp.ok) res(resp);
+				else rej(resp);
 			})
 		});
 	}

src/misc.ts

@@ -1,17 +1,5 @@
 import {md5} from './string';
 
-/**
- * Convert data into a form encoded format.
- *
- * @param {any} data - data to convert
- * @returns {string} - Ecodeded form data
- */
-export function formEncode(data: any): string {
-	return Object.entries(data).map(([key, value]) =>
-		encodeURIComponent(key) + '=' + encodeURIComponent(<any>value)
-	).join('&');
-}
-
 /**
  * Get profile image from Gravatar
  *

src/objects.ts

@@ -119,6 +119,17 @@ export function flattenObj(obj: any, parent?: any, result: any = {}) {
 	}
 }
 
+/**
+ * Convert object to FormData
+ * @param target - Object to convert
+ * @return {FormData} - Form object
+ */
+export function formData(target: any): FormData {
+	const data = new FormData();
+	Object.entries(target).forEach(([key, value]) => data.append(key, <any>value));
+	return data;
+}
+
 /**
  * Check that an object has the following values
  *
@@ -175,7 +186,12 @@ export function mixin(target: any, constructors: any[]) {
 	});
 }
 
-export function sanitizedJSON(obj: any, space?: number) {
+export function JSONAttemptParse<T>(json: string): T | string {
+	try { return JSON.parse(json); }
+	catch { return json; }
+}
+
+export function JSONSanitized(obj: any, space?: number) {
 	let cache: any[] = [];
 	return JSON.parse(JSON.stringify(obj, (key, value) => {
 		if (typeof value === 'object' && value !== null) {
@@ -185,3 +201,15 @@ export function sanitizedJSON(obj: any, space?: number) {
 		return value;
 	}, space));
 }
+
+/**
+ * Convert object into URL encoded string
+ *
+ * @param {any} data - data to convert
+ * @returns {string} - Encoded form data
+ */
+export function urlEncode(data: any): string {
+	return Object.entries(data).map(([key, value]) =>
+		encodeURIComponent(key) + '=' + encodeURIComponent(<any>value)
+	).join('&');
+}

src/time.ts

@@ -1,32 +1,3 @@
-/**
- * Calculate the number of milliseconds until date/time
- *
- * @param {Date | number} date - Target
- * @returns {number} - Number of milliseconds until target
- */
-export function timeUntil(date: Date | number): number {
-	return (date instanceof Date ? date.getTime() : date) - (new Date()).getTime();
-}
-
-/**
- * Use in conjunction with `await` to pause an async script
- *
- * @example
- * ```ts
- * async () => {
- *      ...
- *      await sleep(1000) // Pause for 1 second
- *	    ...
- * }
- * ```
- *
- * @param {number} ms - Time to pause for in milliseconds
- * @returns {Promise<unknown>} - Resolves promise when it's time to resume
- */
-export function sleep(ms: number) {
-	return new Promise(res => setTimeout(res, ms));
-}
-
 export function formatDate(date: Date | number | string) {
 	const d = date instanceof Date ? date : new Date(date);
 	return new Intl.DateTimeFormat("en-us", {
@@ -38,3 +9,44 @@ export function formatDate(date: Date | number | string) {
 		hour12: true
 	}).format(d);
 }
+
+/**
+ * Use in conjunction with `await` to pause an async script
+ *
+ * @example
+ * ```js
+ * await sleep(1000) // Pause for 1 second
+ * ```
+ * @param {number} ms - Time to pause for in milliseconds
+ * @returns {Promise<unknown>} - Resolves promise when it's time to resume
+ */
+export function sleep(ms: number): Promise<void> {
+	return new Promise(res => setTimeout(res, ms));
+}
+
+/**
+ * Sleep while function returns true
+ *
+ * @example
+ * ```js
+ * let loading = true;
+ * setTimeout(() => wait = false, 1000);
+ * await sleepUntil(() => loading); // Won't continue until loading flag is false
+ * ```
+ * @param {() => boolean} fn Return true to continue
+ * @param {number} checkInterval Run function ever x milliseconds
+ * @return {Promise<void>} Callback when sleep is over
+ */
+export async function sleepUntil(fn : () => boolean, checkInterval=100): Promise<void> {
+	while(fn()) await sleep(checkInterval);
+}
+
+/**
+ * Calculate the number of milliseconds until date/time
+ *
+ * @param {Date | number} date - Target
+ * @returns {number} - Number of milliseconds until target
+ */
+export function timeUntil(date: Date | number): number {
+	return (date instanceof Date ? date.getTime() : date) - (new Date()).getTime();
+}

vite.config.ts

@@ -8,8 +8,8 @@ export default defineConfig({
 			entry: resolve(process.cwd(), 'src/index.ts'),
 			name: 'utils',
 			fileName: (module, entryName) => {
-				if(module == 'es') return 'utils.mjs';
+				if(module == 'es') return 'index.mjs';
-				if(module == 'umd') return 'utils.cjs';
+				if(module == 'umd') return 'index.cjs';
 			}
 		},
 		emptyOutDir: true,