@8ms/helpers 2.3.26 → 2.3.28

package/dist/url/server/index.mjs

@@ -0,0 +1,35 @@
+import { createDirectory } from "../../file/server/index.mjs";
+import axios from "axios";
+
+//#region src/url/server/writeUrlContents.ts
+/**
+* Downloads a given URL's contents to a local file.
+*
+* Requires fs-extra
+*/
+const writeUrlContents = async (filePath, url) => {
+	const fs = await import("fs-extra");
+	await createDirectory(filePath);
+	const writer = fs.createWriteStream(filePath);
+	await axios({
+		method: "get",
+		url,
+		responseType: "stream"
+	}).then((response) => {
+		return new Promise(async (resolve, reject) => {
+			response.data.pipe(writer);
+			let error = null;
+			writer.on("error", (err) => {
+				error = err;
+				writer.close();
+				reject(err);
+			});
+			writer.on("close", () => {
+				if (!error) resolve(true);
+			});
+		});
+	});
+};
+
+//#endregion
+export { writeUrlContents };

package/dist/util/index.d.mts

@@ -0,0 +1,50 @@
+//#region src/util/defaultTo.d.ts
+/**
+ * Function to default to a value, whilst filtering through an instance
+ */
+declare const defaultTo: (instance: any, keys: any | any[], defaultValue?: any) => any;
+//#endregion
+//#region src/util/getClean.d.ts
+type GetClean = {
+  hash?: boolean;
+  input: any;
+  lowercase?: boolean;
+  parameter?: boolean;
+};
+/**
+ * Return a clean URL with a few options.
+ */
+declare const getClean: (props: GetClean) => string;
+//#endregion
+//#region src/util/getError.d.ts
+declare const getError: (error: any) => string;
+//#endregion
+//#region src/util/getWithoutHash.d.ts
+/**
+ * Get a URL without the parameter query.
+ */
+declare const getWithoutHash: (input: string) => string;
+//#endregion
+//#region src/util/getWithoutParameter.d.ts
+/**
+ * Get a URL without the parameter query.
+ */
+declare const getWithoutParameter: (input: string) => string;
+//#endregion
+//#region src/util/isUndefined.d.ts
+/**
+ * Check to see if a value is undefined.
+ */
+declare const isUndefined: (instance: any, keys: any | any[]) => boolean;
+//#endregion
+//#region src/util/promiseChunks.d.ts
+/**
+ * Chunk a queue of promises into controlled chunks to prevent overloading.
+ * https://stackoverflow.com/a/53964407
+ */
+declare const promiseChunks: (promises: Promise<any>[], size: number, sleepSeconds?: number, callbackFunction?: Function) => Promise<unknown[]>;
+//#endregion
+//#region src/util/sleep.d.ts
+declare const sleep: (seconds: number) => Promise<void>;
+//#endregion
+export { defaultTo, getClean, getError, getWithoutHash, getWithoutParameter, isUndefined, promiseChunks, sleep };

package/dist/util/index.mjs

@@ -0,0 +1,107 @@
+import { chunk, flatten, isObject } from "../lodash/index.mjs";
+import { getArray } from "../array/index.mjs";
+
+//#region src/util/defaultTo.ts
+/**
+* Function to default to a value, whilst filtering through an instance
+*/
+const defaultTo = (instance, keys, defaultValue = null) => {
+	const keysArray = getArray(keys);
+	let found = true;
+	let pointer = instance;
+	if ("undefined" === typeof instance || null === pointer) found = false;
+	else keysArray.forEach((key) => {
+		if (found) if (isObject(pointer)) if (void 0 === pointer[key] || null === pointer[key]) found = false;
+		else pointer = pointer[key];
+		else found = false;
+	});
+	return found ? pointer : defaultValue;
+};
+
+//#endregion
+//#region src/util/getWithoutParameter.ts
+/**
+* Get a URL without the parameter query.
+*/
+const getWithoutParameter = (input) => {
+	let response = input;
+	if (-1 !== response.indexOf("?")) {
+		const split = response.split("?");
+		if (split.length > 1) response = split[0];
+	}
+	return response;
+};
+
+//#endregion
+//#region src/util/getWithoutHash.ts
+/**
+* Get a URL without the parameter query.
+*/
+const getWithoutHash = (input) => {
+	let response = input;
+	if (-1 !== response.indexOf("#")) {
+		const split = response.split("#");
+		if (split.length > 1) response = split[0];
+	}
+	return response;
+};
+
+//#endregion
+//#region src/util/getClean.ts
+/**
+* Return a clean URL with a few options.
+*/
+const getClean = (props) => {
+	let response = props.input.toString().trim();
+	if (props.parameter) response = getWithoutParameter(response);
+	if (props.hash) response = getWithoutHash(response);
+	if (props.lowercase) response = response.toLowerCase();
+	return response;
+};
+
+//#endregion
+//#region src/util/getError.ts
+const getError = (error) => {
+	let response = "";
+	if (typeof error === "string") response = error.toUpperCase();
+	else if (error instanceof Error) response = error.message;
+	return response;
+};
+
+//#endregion
+//#region src/util/isUndefined.ts
+const undefinedValue = "__!!UNDEFINED!!__";
+/**
+* Check to see if a value is undefined.
+*/
+const isUndefined = (instance, keys) => {
+	return undefinedValue === defaultTo(instance, keys, undefinedValue);
+};
+
+//#endregion
+//#region src/util/sleep.ts
+const sleep = (seconds) => {
+	return new Promise((resolve) => setTimeout(resolve, seconds * 1e3));
+};
+
+//#endregion
+//#region src/util/promiseChunks.ts
+/**
+* Chunk a queue of promises into controlled chunks to prevent overloading.
+* https://stackoverflow.com/a/53964407
+*/
+const promiseChunks = async (promises, size, sleepSeconds = 0, callbackFunction) => {
+	const batches = chunk(promises, size);
+	let results = [];
+	while (batches.length) {
+		const batch = batches.shift();
+		const result = await Promise.all(batch);
+		results.push(result);
+		if (callbackFunction) await callbackFunction(result);
+		await sleep(sleepSeconds);
+	}
+	return flatten(results);
+};
+
+//#endregion
+export { defaultTo, getClean, getError, getWithoutHash, getWithoutParameter, isUndefined, promiseChunks, sleep };

package/dist/util/server/index.d.mts

@@ -0,0 +1,27 @@
+import { BrotliOptions, ZlibOptions } from "zlib";
+
+//#region src/util/server/getBrotliCompressed.d.ts
+/**
+ * Compress a given input using Brotli.
+ */
+declare const getBrotliCompressed: (input: any, options?: BrotliOptions) => Promise<unknown>;
+//#endregion
+//#region src/util/server/getBrotliDecompressed.d.ts
+/**
+ * Decompress a given Brotli input into a string.
+ */
+declare const getBrotliDecompressed: (input: any, options?: BrotliOptions) => Promise<unknown>;
+//#endregion
+//#region src/util/server/getGzipCompressed.d.ts
+/**
+ * Compress a given input using Gzip.
+ */
+declare const getGzipCompressed: (input: any, options?: ZlibOptions) => Promise<string>;
+//#endregion
+//#region src/util/server/getGzipDecompressed.d.ts
+/**
+ * Decompress a given Gzip input into a string.
+ */
+declare const getGzipDecompressed: (input: any, options?: ZlibOptions) => Promise<unknown>;
+//#endregion
+export { getBrotliCompressed, getBrotliDecompressed, getGzipCompressed, getGzipDecompressed };

package/dist/util/server/index.mjs

@@ -0,0 +1,61 @@
+import zlib from "zlib";
+
+//#region src/util/server/getBrotliCompressed.ts
+/**
+* Compress a given input using Brotli.
+*/
+const getBrotliCompressed = async (input, options = {}) => {
+	return new Promise(async (resolve, reject) => {
+		zlib.brotliCompress(input || "", options || {}, (err, data) => {
+			if (err) reject(`Error compressing - ${err.message}`);
+			else resolve(data.toString("base64"));
+		});
+	});
+};
+
+//#endregion
+//#region src/util/server/getBrotliDecompressed.ts
+/**
+* Decompress a given Brotli input into a string.
+*/
+const getBrotliDecompressed = async (input, options = {}) => {
+	return new Promise(async (resolve, reject) => {
+		const compressedData = Buffer.from(input || "", "base64");
+		zlib.brotliDecompress(compressedData, options || {}, (err, data) => {
+			if (err) reject(`Error decompressing - ${err.message}`);
+			else resolve(data.toString("utf8"));
+		});
+	});
+};
+
+//#endregion
+//#region src/util/server/getGzipCompressed.ts
+/**
+* Compress a given input using Gzip.
+*/
+const getGzipCompressed = async (input, options = {}) => {
+	return new Promise(async (resolve, reject) => {
+		zlib.gzip(input || "", options || {}, (err, data) => {
+			if (err) reject(`Error compressing - ${err.message}`);
+			else resolve(data.toString("base64"));
+		});
+	});
+};
+
+//#endregion
+//#region src/util/server/getGzipDecompressed.ts
+/**
+* Decompress a given Gzip input into a string.
+*/
+const getGzipDecompressed = async (input, options = {}) => {
+	return new Promise(async (resolve, reject) => {
+		const compressedData = Buffer.from(input || "", "base64");
+		zlib.gunzip(compressedData, options || {}, (err, data) => {
+			if (err) reject(`Error decompressing - ${err.message}`);
+			else resolve(data.toString("utf8"));
+		});
+	});
+};
+
+//#endregion
+export { getBrotliCompressed, getBrotliDecompressed, getGzipCompressed, getGzipDecompressed };

package/dist/webWorker/index.d.mts

@@ -0,0 +1,11 @@
+//#region src/webWorker/webWorker.d.ts
+declare const WebWorkerState: {
+  IDLE: string;
+  CANCELLED: string;
+  PENDING: string;
+  ERROR: string;
+  SUCCESS: string;
+};
+type WebWorkerState = typeof WebWorkerState[keyof typeof WebWorkerState];
+//#endregion
+export { WebWorkerState };

package/dist/webWorker/index.mjs

@@ -0,0 +1,11 @@
+//#region src/webWorker/webWorker.ts
+const WebWorkerState = {
+	IDLE: "IDLE",
+	CANCELLED: "CANCELLED",
+	PENDING: "PENDING",
+	ERROR: "ERROR",
+	SUCCESS: "SUCCESS"
+};
+
+//#endregion
+export { WebWorkerState };

package/dist/xml/server/index.d.mts

@@ -0,0 +1,4 @@
+//#region src/xml/server/getXml.d.ts
+declare const getXml: (url: string) => Promise<string>;
+//#endregion
+export { getXml };

package/dist/xml/server/index.mjs

@@ -0,0 +1,17 @@
+import "../../api-DGKJDAfb.mjs";
+import { get } from "../../axios/index.mjs";
+
+//#region src/xml/server/getXml.ts
+const getXml = async (url) => {
+	let response = "";
+	const apiResponse = await get(url);
+	if (apiResponse.isSuccess()) {
+		response = apiResponse.getBody().toString();
+		response = response.trim();
+		response = response.replace(/[ ]{2}|\r\n|\n|\r|\t/gm, "");
+	}
+	return response;
+};
+
+//#endregion
+export { getXml };