@alextheman/utility 5.11.3 → 5.12.0

package/dist/v6/index.js

@@ -0,0 +1,406 @@
+//#region src/root/functions/arrayHelpers/fillArray.ts
+/**
+* Creates a new array where each element is the result of the provided callback.
+*
+* If the callback returns at least one Promise, the entire result will be wrapped
+* in a `Promise` and resolved with `Promise.all`. Otherwise, a plain array is returned.
+*
+* @category Array Helpers
+*
+* @template ItemType - The return type of the callback (awaited if any items are a Promise) that becomes the type of the array items.
+*
+* @param callback - A function invoked with the current index. May return a value or a Promise.
+* @param length - The desired length of the resulting array.
+*
+* @returns An array of the callback results, or a Promise resolving to one if the callback is async.
+*/
+function fillArray(callback, length = 1) {
+	const outputArray = new Array(length).fill(null).map((_, index) => {
+		return callback(index);
+	});
+	if (outputArray.some((item) => {
+		return item instanceof Promise;
+	})) return Promise.all(outputArray);
+	return outputArray;
+}
+//#endregion
+//#region src/root/functions/arrayHelpers/paralleliseArrays.ts
+/**
+* Creates a new array of tuples, each containing the item at the given index from both arrays.
+*
+* If `secondArray` is shorter than `firstArray`, the second position in the tuple
+* will be `undefined`. Iteration always uses the length of the first array.
+*
+* @category Array Helpers
+*
+* @template FirstArrayItem
+* @template SecondArrayItem
+*
+* @param firstArray - The first array. Each item in this will take up the first tuple spot.
+* @param secondArray - The second array. Each item in this will take up the second tuple spot.
+*
+* @returns An array of `[firstItem, secondItem]` tuples for each index in `firstArray`.
+*/
+function paralleliseArrays(firstArray, secondArray) {
+	const outputArray = [];
+	for (let i = 0; i < firstArray.length; i++) outputArray.push([firstArray[i], secondArray[i]]);
+	return outputArray;
+}
+//#endregion
+//#region src/root/functions/taggedTemplate/interpolate.ts
+/**
+* Returns the result of interpolating a template string when given the strings and interpolations separately.
+*
+* You can pass a template string directly by doing:
+*
+* ```
+* interpolate`Template string here`;
+* ```
+*
+* In this case, it will be functionally the same as if you just wrote the template string by itself.
+*
+* @category Tagged Template
+*
+* @template InterpolationsType - The type of the interpolations.
+*
+* @param strings - The strings from the template to process.
+* @param interpolations - An array of all interpolations from the template.
+*
+* @returns A new string with the strings and interpolations from the template applied.
+*/
+function interpolate(strings, ...interpolations) {
+	let result = "";
+	for (const [string, interpolation = ""] of paralleliseArrays(strings, interpolations)) result += string + interpolation;
+	return result;
+}
+//#endregion
+//#region src/root/functions/taggedTemplate/normaliseIndents.ts
+function calculateTabSize(line, whitespaceLength) {
+	const potentialWhitespacePart = line.slice(0, whitespaceLength);
+	const trimmedString = line.trimStart();
+	if (potentialWhitespacePart.trim() !== "") return 0;
+	const tabSize = line.length - (trimmedString.length + whitespaceLength);
+	return tabSize < 0 ? 0 : tabSize;
+}
+function getWhitespaceLength(lines) {
+	const [firstNonEmptyLine] = lines.filter((line) => {
+		return line.trim() !== "";
+	});
+	return firstNonEmptyLine.length - firstNonEmptyLine.trimStart().length;
+}
+function reduceLines(lines, { preserveTabs = true }) {
+	const slicedLines = lines.slice(1);
+	const isFirstLineEmpty = lines[0].trim() === "";
+	const whitespaceLength = getWhitespaceLength(isFirstLineEmpty ? lines : slicedLines);
+	return (isFirstLineEmpty ? slicedLines : lines).map((line) => {
+		const tabSize = calculateTabSize(line, whitespaceLength);
+		return (preserveTabs ? fillArray(() => {
+			return " ";
+		}, tabSize).join("") : "") + line.trimStart();
+	}).join("\n");
+}
+/**
+* Applies any options if provided, then removes any extraneous indents from a multi-line template string.
+*
+* You can pass a template string directly by doing:
+*
+* ```typescript
+* normaliseIndents`Template string here
+*     with a new line
+*     and another new line`;
+* ```
+*
+* You may also pass the options first, then invoke the resulting function with a template string:
+*
+* ```typescript
+* normaliseIndents({ preserveTabs: false })`Template string here
+*     with a new line
+*     and another new line`;
+* ```
+*
+* @category Tagged Template
+*
+* @param first - The strings from the template to process, or the options to apply.
+* @param args - An array of all interpolations from the template.
+*
+* @returns An additional function to invoke, or a new string with the strings and interpolations from the template applied, and extraneous indents removed.
+*/
+function normaliseIndents(first, ...args) {
+	if (typeof first === "object" && first !== null && !Array.isArray(first)) {
+		const options = first;
+		return (strings, ...interpolations) => {
+			return normaliseIndents(strings, ...interpolations, options);
+		};
+	}
+	const strings = first;
+	const options = typeof args[args.length - 1] === "object" && !Array.isArray(args[args.length - 1]) ? args.pop() : {};
+	return reduceLines(interpolate(strings, ...[...args]).split("\n"), options);
+}
+//#endregion
+//#region src/root/functions/miscellaneous/sayHello.ts
+/**
+* Returns a string representing the lyrics to the package's theme song, Commit To You
+*
+* [Pls listen!](https://www.youtube.com/watch?v=mH-Sg-8EnxM)
+*
+* @returns The lyrics string in markdown format.
+*/
+function sayHello() {
+	return normaliseIndents`
+    # Commit To You
+
+    ### Verse 1
+
+    I know you've been checking me out,  
+    Shall we take it to the next level now?  
+    'Cause I really wanna be there all for you,  
+    All for you!  
+    Come on now, let's make a fresh start!  
+    Pin my number, then you can take me out!  
+    Can't you see I really do care about you,  
+    About you!
+
+    ### Pre-chorus 1
+    Although our calendars are imperfect, at best,  
+    I'd like to organise time with you! (with you!).  
+    Just tell me when and I'll make it clear,  
+    All clear for you,  
+    All clear for you!  
+    (One, two, three, go!)
+
+    ### Chorus
+    I wanna be of utility, I'll help you on the run!  
+    I'll be the one here in the back, while you go have some fun!  
+    Looking out for you tonight, I'll be the one you can rely on!  
+    Watch you go and watch me pass by,  
+    I'll be here!  
+    I'll commit to you!
+
+    ### Verse 2
+    Though sometimes it won't be easy,  
+    You'll be here to bring out the best in me,  
+    And I'll hold myself to high standards for you!  
+    All for you!  
+    We'll grow as a pair, you and me,  
+    We'll build up a healthy dependency,  
+    You can build with me and I'll develop with you!  
+    I'm with you!
+
+    ### Pre-chorus 2
+    I'll be with you when you're up or you're down,  
+    We'll deal with all our problems together (together!)  
+    Just tell me what you want, I'll make it clear,  
+    All clear for you,  
+    All clear for you!  
+    (One, three, one, go!)
+
+    ### Chorus
+    I wanna be of utility, I'll help you on the run!  
+    (help you on the run!)  
+    I'll be the one here in the back, while you go have some fun!  
+    (you go have some fun!)  
+    Looking out for you tonight, I'll be the one you can rely on!  
+    Watch you go and watch me pass by,  
+    I'll be here!  
+    I'll commit to you!
+
+    ### Bridge
+    Looking into our stack!  
+    I'll commit to you!  
+    We've got a lot to unpack!  
+    I'll commit to you!  
+    The environment that we're in!  
+    I'll commit to you!  
+    Delicate as a string!  
+    I'll commit to you!
+
+    But I think you're my type!  
+    I'll commit to you!  
+    Oh, this feels all so right!  
+    I'll commit to you!  
+    Nothing stopping us now!  
+    I'll commit to you!  
+    Let's show them what we're about!  
+    Two, three, four, go!
+
+    ### Final Chorus
+    I wanna be of utility, I'll help you on the run!  
+    (help you on the run!)  
+    I'll be the one here in the back, while you go have some fun!  
+    (you go have some fun!)  
+    Looking out for you tonight, I'll be the one you can rely on!  
+    Watch you go and watch me pass by,  
+    I'll be here!  
+    I'll commit to you!
+
+    I wanna be of utility, I'll help you on the run!  
+    (I'll commit to you!)  
+    I'll be the one here in the back, while you go have some fun!  
+    (I'll commit to you!)  
+    Looking out for you tonight, I'll be the one you can rely on!  
+    (I'll commit to you!)  
+    Watch you go and watch me pass by,  
+    (I'll commit to you!)  
+    I'll be here!  
+
+    ### Outro
+    I'll commit to you!  
+    I'll commit to you!  
+    I'll commit to you!
+    `;
+}
+//#endregion
+//#region src/v6/CodeError.ts
+/**
+* Represents errors that can be described using a standardised error code, and a human-readable error message.
+*
+* @category Types
+*
+* @template ErrorCode The type of the standardised error code.
+*/
+var CodeError = class CodeError extends Error {
+	code;
+	/**
+	* @param code - A standardised code (e.g. UNEXPECTED_DATA).
+	* @param message  - A human-readable error message (e.g. The data provided is invalid).
+	* @param options - Extra options to pass to super Error constructor.
+	*/
+	constructor(code, message = "Something went wrong.", options) {
+		super(message, options);
+		if (Error.captureStackTrace) Error.captureStackTrace(this, new.target);
+		this.name = new.target.name;
+		this.code = code;
+		Object.defineProperty(this, "message", { enumerable: true });
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+	/**
+	* Checks whether the given input may have been caused by a CodeError.
+	*
+	* @param input - The input to check.
+	*
+	* @returns `true` if the input is a CodeError, and `false` otherwise. The type of the input will also be narrowed down to CodeError if `true`.
+	*/
+	static check(input) {
+		if (input instanceof CodeError) return true;
+		return typeof input === "object" && input !== null && "message" in input && typeof input.message === "string" && "code" in input && typeof input.code === "string";
+	}
+	static checkCaughtError(error, options) {
+		if (this.check(error)) {
+			if (options?.expectedCode && error.code !== options.expectedCode) throw new Error(normaliseIndents`The error code on the thrown error does not match the expected error code.
+            
+            Expected: ${options.expectedCode}
+            Received: ${error.code}
+            `, { cause: error });
+			return error;
+		}
+		throw error;
+	}
+	/**
+	* Gets the thrown `CodeError` from a given function if one was thrown, and re-throws any other errors, or throws a default `CodeError` if no error thrown.
+	*
+	* @param errorFunction - The function expected to throw the error.
+	* @param options - Extra options to apply.
+	*
+	* @throws {Error} Any other errors thrown by the `errorFunction` that are not a `CodeError`.
+	* @throws {Error} If no `CodeError` was thrown by the `errorFunction`
+	*
+	* @returns The `CodeError` that was thrown by the `errorFunction`
+	*/
+	static expectError(errorFunction, options) {
+		try {
+			errorFunction();
+		} catch (error) {
+			return this.checkCaughtError(error, options);
+		}
+		throw new Error(`Expected a ${this.name} to be thrown but none was thrown`);
+	}
+	/**
+	* Gets the thrown `CodeError` from a given asynchronous function if one was thrown, and re-throws any other errors, or throws a default `CodeError` if no error thrown.
+	*
+	* @param errorFunction - The function expected to throw the error.
+	* @param options - Extra options to apply.
+	*
+	* @throws {Error} Any other errors thrown by the `errorFunction` that are not a `CodeError`.
+	* @throws {Error} If no `CodeError` was thrown by the `errorFunction`
+	*
+	* @returns The `CodeError` that was thrown by the `errorFunction`
+	*/
+	static async expectErrorAsync(errorFunction, options) {
+		try {
+			await errorFunction();
+		} catch (error) {
+			return this.checkCaughtError(error, options);
+		}
+		throw new Error(`Expected a ${this.name} to be thrown but none was thrown`);
+	}
+};
+//#endregion
+//#region src/v6/DataError.ts
+const DataErrorCode = { INVALID_DATA: "INVALID_DATA" };
+/**
+* Represents errors you may get that may've been caused by a specific piece of data.
+*
+* @category Types
+*
+* @template DataType - The type of the data that caused the error.
+*/
+var DataError = class DataError extends CodeError {
+	data;
+	/**
+	* @param data - The data that caused the error.
+	* @param code - A standardised code (e.g. UNEXPECTED_DATA).
+	* @param message  - A human-readable error message (e.g. The data provided is invalid).
+	* @param options - Extra options to pass to super Error constructor.
+	*/
+	constructor(data, code = "INVALID_DATA", message = "The data provided is invalid", options) {
+		super(code, message, options);
+		if (Error.captureStackTrace) Error.captureStackTrace(this, new.target);
+		this.name = new.target.name;
+		this.code = code;
+		this.data = data;
+		Object.defineProperty(this, "message", { enumerable: true });
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+	/**
+	* Checks whether the given input may have been caused by a DataError.
+	*
+	* @param input - The input to check.
+	*
+	* @returns `true` if the input is a DataError, and `false` otherwise. The type of the input will also be narrowed down to DataError if `true`.
+	*/
+	static check(input) {
+		if (input instanceof DataError) return true;
+		const data = input;
+		return typeof data === "object" && data !== null && typeof data.message === "string" && typeof data.code === "string" && "data" in data;
+	}
+	/**
+	* Gets the thrown `DataError` from a given function if one was thrown, and re-throws any other errors, or throws a default `DataError` if no error thrown.
+	*
+	* @param errorFunction - The function expected to throw the error.
+	* @param options - Extra options to apply.
+	*
+	* @throws {Error} Any other errors thrown by the `errorFunction` that are not a `DataError`.
+	* @throws {Error} If no `DataError` was thrown by the `errorFunction`
+	*
+	* @returns The `DataError` that was thrown by the `errorFunction`
+	*/
+	static expectError(errorFunction, options) {
+		return super.expectError(errorFunction, options);
+	}
+	/**
+	* Gets the thrown `DataError` from a given asynchronous function if one was thrown, and re-throws any other errors, or throws a default `DataError` if no error thrown.
+	*
+	* @param errorFunction - The function expected to throw the error.
+	* @param options - Extra options to apply.
+	*
+	* @throws {Error} Any other errors thrown by the `errorFunction` that are not a `DataError`.
+	* @throws {Error} If no `DataError` was thrown by the `errorFunction`
+	*
+	* @returns The `DataError` that was thrown by the `errorFunction`
+	*/
+	static async expectErrorAsync(errorFunction, options) {
+		return await super.expectErrorAsync(errorFunction, options);
+	}
+};
+//#endregion
+export { CodeError, DataError, DataErrorCode, sayHello };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alextheman/utility",
-  "version": "5.11.3",
+  "version": "5.12.0",
   "description": "Helpful utility functions.",
   "repository": {
     "type": "git",
@@ -25,6 +25,11 @@
       "types": "./dist/node/index.d.ts",
       "import": "./dist/node/index.js",
       "require": "./dist/node/index.cjs"
+    },
+    "./v6": {
+      "types": "./dist/v6/index.d.ts",
+      "import": "./dist/v6/index.js",
+      "require": "./dist/v6/index.cjs"
     }
   },
   "files": [