@oliversalzburg/js-utils 0.6.0 → 0.7.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@oliversalzburg/js-utils",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "license": "MIT",
   "author": "Oliver Salzburg <oliver.salzburg@gmail.com>",
   "repository": {
@@ -25,10 +25,10 @@
     "postversion": "git push"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.4.4",
-    "@types/node": "24.10.13",
-    "@types/web": "0.0.338",
-    "typescript": "5.9.3"
+    "@biomejs/biome": "2.5.9",
+    "@types/node": "26.2.0",
+    "@types/web": "0.0.354",
+    "typescript": "7.0.2"
   },
   "engines": {
     "node": ">=20"

package/lib/async/async.d.ts

@@ -1,44 +0,0 @@
-import { AnyAsyncFunction, AnyFunctionReturning, ConstructorOf } from "../core.js";
-/**
- * Wraps the given asynchronous function in a new function that will ignore any outcome of
- * the context as it resolves.
- *
- * This can be useful when providing asynchonous event handler to `.addEventlistener()`,
- * which only expects synchronous functions.
- * @param context - The asynchronous function to execute.
- * @returns A function returning nothing.
- */
-export declare const prepareAsyncContext: (context: AnyAsyncFunction) => (
-/**
- * The arguments that our new function was called with.
- */
-...args: Array<unknown>) => void;
-/**
- * Executes an asynchronous function and resolves with an alternative result
- * in case the function failed.
- * @param executable - The asynchronous function to execute.
- * @param to - The result we want to return when the function errors.
- * @param filter - An {@linkcode !Error} subclass. If defined, only errors of
- * this type will be coalesced.
- * @typeParam TExecutableReturn - The return type of the function.
- * @typeParam TCoalesce - The type of the object to coalesce to.
- * @typeParam TFilter - The type of the error filter.
- * @returns Whatever the function resolved to, or the provided replacement,
- * in case the function failed.
- */
-export declare const coalesceOnRejection: <TExecutableReturn, TCoalesce, TFilter extends ConstructorOf<Error>>(executable: AnyFunctionReturning<TExecutableReturn | Promise<TExecutableReturn>>, to: TCoalesce, filter?: TFilter) => Promise<TExecutableReturn | TCoalesce>;
-/**
- * Wait a given period before continuing execution.
- * @param duration - How many milliseconds to wait.
- * @returns Nothing
- */
-export declare const sleep: (duration: number) => Promise<void>;
-/**
- * Executes an asynchronous function and retries the execution if it rejects.
- * @param executable - The asynchronous function to execute.
- * @param retryDelay - The duration to wait after a failed execution.
- * @param retryCount - How often should the execution be retried?
- * @typeParam TExecutableReturn - The return type of the function.
- * @returns Whatever the function resolved to.
- */
-export declare const retry: <TExecutableReturn>(executable: AnyFunctionReturning<TExecutableReturn | Promise<TExecutableReturn>>, retryDelay?: number, retryCount?: number) => Promise<TExecutableReturn>;

package/lib/async/async.js

@@ -1,76 +0,0 @@
-import { redirectErrorsToConsole } from "../errors/console.js";
-/**
- * Wraps the given asynchronous function in a new function that will ignore any outcome of
- * the context as it resolves.
- *
- * This can be useful when providing asynchonous event handler to `.addEventlistener()`,
- * which only expects synchronous functions.
- * @param context - The asynchronous function to execute.
- * @returns A function returning nothing.
- */
-export const prepareAsyncContext = (context) => {
-    return (
-    /**
-     * The arguments that our new function was called with.
-     */
-    ...args) => {
-        void context(...args)
-            .then(() => undefined)
-            .catch(redirectErrorsToConsole(console));
-    };
-};
-/**
- * Executes an asynchronous function and resolves with an alternative result
- * in case the function failed.
- * @param executable - The asynchronous function to execute.
- * @param to - The result we want to return when the function errors.
- * @param filter - An {@linkcode !Error} subclass. If defined, only errors of
- * this type will be coalesced.
- * @typeParam TExecutableReturn - The return type of the function.
- * @typeParam TCoalesce - The type of the object to coalesce to.
- * @typeParam TFilter - The type of the error filter.
- * @returns Whatever the function resolved to, or the provided replacement,
- * in case the function failed.
- */
-export const coalesceOnRejection = async (executable, to, filter) => {
-    try {
-        return await executable();
-    }
-    catch (error) {
-        if ((filter !== undefined && error instanceof filter) || !filter) {
-            return to;
-        }
-        throw error;
-    }
-};
-/**
- * Wait a given period before continuing execution.
- * @param duration - How many milliseconds to wait.
- * @returns Nothing
- */
-export const sleep = (duration) => {
-    return new Promise(resolve => setTimeout(resolve, duration));
-};
-/**
- * Executes an asynchronous function and retries the execution if it rejects.
- * @param executable - The asynchronous function to execute.
- * @param retryDelay - The duration to wait after a failed execution.
- * @param retryCount - How often should the execution be retried?
- * @typeParam TExecutableReturn - The return type of the function.
- * @returns Whatever the function resolved to.
- */
-export const retry = async (executable, retryDelay = 0, retryCount = 0) => {
-    try {
-        return await executable();
-    }
-    catch (error) {
-        if (0 < retryCount) {
-            if (0 < retryDelay) {
-                await sleep(retryDelay);
-            }
-            return retry(executable, retryDelay, --retryCount);
-        }
-        throw error;
-    }
-};
-//# sourceMappingURL=async.js.map

package/lib/async/async.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"async.js","sourceRoot":"","sources":["../../source/async/async.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAE/D;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,OAAyB,EAAE,EAAE;IAC/D,OAAO;IACL;;OAEG;IACH,GAAG,IAAoB,EACvB,EAAE;QACF,KAAK,OAAO,CAAC,GAAG,IAAI,CAAC;aAClB,IAAI,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC;aACrB,KAAK,CAAC,uBAAuB,CAAC,OAAO,CAAC,CAAC,CAAC;IAC7C,CAAC,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,KAAK,EAKtC,UAAgF,EAChF,EAAa,EACb,MAAgB,EAChB,EAAE;IACF,IAAI,CAAC;QACH,OAAO,MAAM,UAAU,EAAE,CAAC;IAC5B,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,CAAC,MAAM,KAAK,SAAS,IAAI,KAAK,YAAY,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACjE,OAAO,EAAE,CAAC;QACZ,CAAC;QACD,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,QAAgB,EAAiB,EAAE;IACvD,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC;AAC/D,CAAC,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,KAAK,EACxB,UAAgF,EAChF,UAAU,GAAG,CAAC,EACd,UAAU,GAAG,CAAC,EACc,EAAE;IAC9B,IAAI,CAAC;QACH,OAAO,MAAM,UAAU,EAAE,CAAC;IAC5B,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,CAAC,GAAG,UAAU,EAAE,CAAC;YACnB,IAAI,CAAC,GAAG,UAAU,EAAE,CAAC;gBACnB,MAAM,KAAK,CAAC,UAAU,CAAC,CAAC;YAC1B,CAAC;YACD,OAAO,KAAK,CAAC,UAAU,EAAE,UAAU,EAAE,EAAE,UAAU,CAAC,CAAC;QACrD,CAAC;QACD,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC,CAAC"}

package/lib/async/async.test.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/async/async.test.js

@@ -1,26 +0,0 @@
-import assert from "node:assert";
-import { it } from "node:test";
-import { prepareAsyncContext, sleep } from "./async.js";
-it("executes trivial callback", async () => {
-    let executed = false;
-    const callback = prepareAsyncContext(async () => {
-        await sleep(1);
-        executed = true;
-    });
-    callback();
-    await sleep(100);
-    assert.strictEqual(executed, true);
-});
-it("passes parameters to callback", async () => {
-    let executed = false;
-    const callback = prepareAsyncContext(async (event, eventId) => {
-        assert.strictEqual(event.name, "call");
-        assert.strictEqual(eventId, 42);
-        await sleep(1);
-        executed = true;
-    });
-    callback({ name: "call" }, 42);
-    await sleep(100);
-    assert.strictEqual(executed, true);
-});
-//# sourceMappingURL=async.test.js.map

package/lib/async/async.test.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"async.test.js","sourceRoot":"","sources":["../../source/async/async.test.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,aAAa,CAAC;AACjC,OAAO,EAAE,EAAE,EAAE,MAAM,WAAW,CAAC;AAC/B,OAAO,EAAE,mBAAmB,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExD,EAAE,CAAC,2BAA2B,EAAE,KAAK,IAAI,EAAE;IACzC,IAAI,QAAQ,GAAG,KAAK,CAAC;IAErB,MAAM,QAAQ,GAAG,mBAAmB,CAAC,KAAK,IAAI,EAAE;QAC9C,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC;QACf,QAAQ,GAAG,IAAI,CAAC;IAClB,CAAC,CAAC,CAAC;IAEH,QAAQ,EAAE,CAAC;IAEX,MAAM,KAAK,CAAC,GAAG,CAAC,CAAC;IAEjB,MAAM,CAAC,WAAW,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;AACrC,CAAC,CAAC,CAAC;AAEH,EAAE,CAAC,+BAA+B,EAAE,KAAK,IAAI,EAAE;IAC7C,IAAI,QAAQ,GAAG,KAAK,CAAC;IAErB,MAAM,QAAQ,GAAG,mBAAmB,CAAC,KAAK,EAAE,KAA6B,EAAE,OAAe,EAAE,EAAE;QAC5F,MAAM,CAAC,WAAW,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACvC,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;QAEhC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC;QACf,QAAQ,GAAG,IAAI,CAAC;IAClB,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC;IAE/B,MAAM,KAAK,CAAC,GAAG,CAAC,CAAC;IAEjB,MAAM,CAAC,WAAW,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;AACrC,CAAC,CAAC,CAAC"}

package/lib/core.d.ts

@@ -1,43 +0,0 @@
-/**
- * Describes a function that is a constructor for something.
- * @typeParam TConstructed - The type this is a constructor for.
- */
-export type ConstructorOf<TConstructed> = new (...args: Array<any>) => TConstructed;
-/**
- * Describes any function.
- */
-export type AnyFunction = (...args: Array<any>) => any;
-/**
- * Describes any asynchronous function.
- */
-export type AnyAsyncFunction = (...args: Array<any>) => Promise<any>;
-/**
- * Any constructor
- */
-export type AnyConstructor = new (...args: Array<any>) => any;
-/**
- * Describes a function returning an instance of a given type.
- * @typeParam TReturned - The type of the item returned by the function.
- */
-export type AnyFunctionReturning<TReturned = any> = (...args: Array<any>) => TReturned;
-/**
- * Describes an async function returning an instance of a given type.
- * @typeParam TReturned - The type of the item returned by the function.
- */
-export type AnyAsyncFunctionReturning<TReturned = any> = (...args: Array<any>) => Promise<TReturned>;
-/**
- * Describes a class "mixin", which is a function that returns a dynamically
- * constructed class, based on the passed parameters.
- *
- * **Hint**: Don't use mixins.
- * @typeParam TTarget - The type of the classed this mixin is being
- * mixed in with.
- */
-export type Mixin<TTarget extends AnyFunctionReturning> = InstanceType<ReturnType<TTarget>>;
-/**
- * Recursive definition of a regular JS object, which is a key-value hash
- * of strings to primitives, or another object of the same type.
- */
-export type JsonObject = string | number | boolean | null | Array<JsonObject> | {
-    [key: string]: JsonObject;
-};

package/lib/core.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=core.js.map

package/lib/core.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"core.js","sourceRoot":"","sources":["../source/core.ts"],"names":[],"mappings":""}

package/lib/data/array.d.ts

@@ -1,45 +0,0 @@
-import { ConstructorOf } from "../core.js";
-/**
- * Places the items in the array in random order.
- * The array is shuffled in-place, no copy is created. The returned array is exactly the passed array.
- * @param array - The array to shuffle.
- * @typeParam TElements - The type of the elements in the array.
- * @returns The passed array in random order.
- */
-export declare const shuffleArray: <TElements>(array: Array<TElements>) => TElements[];
-/**
- * Returns an array that holds all items that appear in both
- * passed arrays.
- * @param a - The first array.
- * @param b - The second array.
- * @typeParam TElements - The type of the elements in the array.
- * @returns A new array which holds the items that appear in
- * both passed arrays.
- */
-export declare const intersect: <TElements>(a: Array<TElements>, b: Array<TElements>) => TElements[];
-/**
- * Returns an array that holds all items that only appear in `a`.
- * @param a - The first array.
- * @param b - The second array.
- * @typeParam TElements - The type of the elements in the array.
- * @returns A new array which holds the items that ony appear in `a`.
- */
-export declare const difference: <TElements>(a: Array<TElements>, b: Array<TElements>) => TElements[];
-/**
- * From an array with unknown contents, retrieve all the elements
- * that are of a certain type and return them as a new array.
- * @param array - The array to filter.
- * @param InstanceType - The type to search for.
- * @typeParam TElements - The type of the elements in the array.
- * @returns A new array with the filtered items.
- */
-export declare const filterType: <TElements>(array: Array<unknown>, InstanceType: ConstructorOf<TElements>) => Array<TElements>;
-/**
- * From an iterable with unknown contents, yield arrays that contain items from
- * the iterable up to a given limit.
- * @param iterable - The iterable to retrieve items from.
- * @param limit - The amount of items in each chunk.
- * @typeParam TElements - The type of the elements in the iterable.
- * @yields Chunks from the provided iterable.
- */
-export declare const chunkify: <TElements>(iterable: Iterable<TElements>, limit: number) => Generator<TElements[], void, unknown>;

package/lib/data/array.js

@@ -1,70 +0,0 @@
-import { is } from "./nil.js";
-/**
- * Places the items in the array in random order.
- * The array is shuffled in-place, no copy is created. The returned array is exactly the passed array.
- * @param array - The array to shuffle.
- * @typeParam TElements - The type of the elements in the array.
- * @returns The passed array in random order.
- */
-export const shuffleArray = (array) => {
-    for (let index = array.length - 1; index > 0; index--) {
-        const targetIndex = Math.trunc(Math.random() * (index + 1));
-        const temp = array[index];
-        array[index] = array[targetIndex];
-        array[targetIndex] = temp;
-    }
-    return array;
-};
-/**
- * Returns an array that holds all items that appear in both
- * passed arrays.
- * @param a - The first array.
- * @param b - The second array.
- * @typeParam TElements - The type of the elements in the array.
- * @returns A new array which holds the items that appear in
- * both passed arrays.
- */
-export const intersect = (a, b) => {
-    return a.filter(x => b.includes(x));
-};
-/**
- * Returns an array that holds all items that only appear in `a`.
- * @param a - The first array.
- * @param b - The second array.
- * @typeParam TElements - The type of the elements in the array.
- * @returns A new array which holds the items that ony appear in `a`.
- */
-export const difference = (a, b) => {
-    return a.filter(x => !b.includes(x));
-};
-/**
- * From an array with unknown contents, retrieve all the elements
- * that are of a certain type and return them as a new array.
- * @param array - The array to filter.
- * @param InstanceType - The type to search for.
- * @typeParam TElements - The type of the elements in the array.
- * @returns A new array with the filtered items.
- */
-export const filterType = (array, InstanceType) => array.filter(element => is(element, InstanceType));
-/**
- * From an iterable with unknown contents, yield arrays that contain items from
- * the iterable up to a given limit.
- * @param iterable - The iterable to retrieve items from.
- * @param limit - The amount of items in each chunk.
- * @typeParam TElements - The type of the elements in the iterable.
- * @yields Chunks from the provided iterable.
- */
-export const chunkify = function* (iterable, limit) {
-    let chunk = [];
-    for (const element of iterable) {
-        chunk.push(element);
-        if (chunk.length === limit) {
-            yield chunk;
-            chunk = [];
-        }
-    }
-    if (chunk.length) {
-        yield chunk;
-    }
-};
-//# sourceMappingURL=array.js.map

package/lib/data/array.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"array.js","sourceRoot":"","sources":["../../source/data/array.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAE9B;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAY,KAAuB,EAAE,EAAE;IACjE,KAAK,IAAI,KAAK,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC;QACtD,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC;QAC5D,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;QAC1B,KAAK,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,WAAW,CAAC,CAAC;QAClC,KAAK,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC;IAC5B,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CAAY,CAAmB,EAAE,CAAmB,EAAE,EAAE;IAC/E,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;AACtC,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAY,CAAmB,EAAE,CAAmB,EAAE,EAAE;IAChF,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;AACvC,CAAC,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CACxB,KAAqB,EACrB,YAAsC,EACtC,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE,CAAC,OAAO,EAAE,YAAY,CAAC,CAAqB,CAAC;AAE5E;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,QAAQ,CAAC,EAAa,QAA6B,EAAE,KAAa;IACxF,IAAI,KAAK,GAAG,EAAE,CAAC;IACf,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACpB,IAAI,KAAK,CAAC,MAAM,KAAK,KAAK,EAAE,CAAC;YAC3B,MAAM,KAAK,CAAC;YACZ,KAAK,GAAG,EAAE,CAAC;QACb,CAAC;IACH,CAAC;IACD,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;QACjB,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC,CAAC"}

package/lib/data/nil.d.ts

@@ -1,92 +0,0 @@
-import { ConstructorOf } from "../core.js";
-/**
- * When you want to normalize away `null` | `undefined`, or deal
- * with either type through a consistent interface.
- */
-export type Nil = null | undefined;
-/**
- * A type that could be either what you want, or `Nil`.
- * @typeParam T - The type that should be made nillable.
- */
-export type Maybe<T> = T | Nil;
-/**
- * Check if something is nil.
- * Can be used as a typeguard.
- * @param subject - The subject that could be nil.
- * @typeParam TSubject - The type of the subject.
- * @returns `true` if the subject is nil, `false` otherwise.
- */
-export declare function isNil<TSubject>(subject: Maybe<TSubject>): subject is Nil;
-/**
- * Check if something is a concrete value of the given type.
- * Can be used as a typeguard.
- * @param subject - The subject that could be nil.
- * @param Prototype - The prototype to check against.
- * @typeParam TSubject - The type to check against.
- * @returns `true` if the input element matches the given type,
- * `false` otherwise.
- */
-export declare function is<TSubject>(subject: Maybe<TSubject> | unknown, Prototype: ConstructorOf<TSubject>): subject is TSubject;
-/**
- * Thrown when an unexpected nil value was encountered.
- */
-export declare class UnexpectedNilError extends Error {
-    /**
-     * Constructs a new {@linkcode UnexpectedNilError}.
-     * @param message - The error message.
-     */
-    constructor(message?: string);
-}
-/**
- * Ensure that the passed subject is not nil; throw otherwise.
- * @param subject - A subject that is possibly nil.
- * @param errorMessage - An optional error message to throw when the subject is nil.
- * @typeParam TSubject - The type of the subject.
- * @returns The subject, if it isn't nil.
- * @throws {@linkcode UnexpectedNilError} When the subject is nil.
- */
-export declare function mustExist<TSubject>(subject: Maybe<TSubject>, errorMessage?: string): TSubject;
-/**
- * Ensure that all passed subjects are not nil; throw otherwise.
- * @param subjects - The subjects that are possibly nil.
- * @param errorMessage - An optional error message to throw when a subject is nil.
- * @typeParam TSubject - The type a the subject.
- * @returns The subjects, if they aren't nil.
- * @throws {@linkcode UnexpectedNilError} When a subject is nil.
- */
-export declare function mustExistAll<TSubject>(subjects: Array<Maybe<TSubject>>, errorMessage?: string): Array<TSubject>;
-/**
- * Ensure that the passed subject is not nil; throw otherwise.
- * @param subject - A subject that is possibly nil.
- * @typeParam TSubject - The type of the subject.
- * @throws {@linkcode UnexpectedNilError} When the subject is nil.
- */
-export declare function assertExists<TSubject>(subject: Maybe<TSubject>): asserts subject is TSubject;
-/**
- * Ensure that the passed subjects are not nil; throw otherwise.
- * @param subjects - Subjects that are possibly nil.
- * @typeParam TSubject - The type of a subject.
- * @throws {@linkcode UnexpectedNilError} When a subject is nil.
- */
-export declare function assertExistsAll<TSubject>(subjects: Array<Maybe<TSubject>>): asserts subjects is Array<TSubject>;
-/**
- * Convert a nilable into a real value, if it is nil.
- * @param nilable - The subject to convert to an optional.
- * @param to - The value to coalese to.
- * @returns The input value, if it wasn't nil, or the value to coalesce to.
- */
-export declare function coalesce<T>(nilable: Maybe<T>, to: T): T;
-/**
- * Drop all nil values from an array, or replaces them with another value.
- * @param nilables - The subject to convert.
- * @param to - The value to coalese to.
- * @returns An array with where all values are not nil.
- */
-export declare function coalesceArray<T>(nilables: Array<Maybe<T>>, to?: Maybe<T>): Array<T>;
-/**
- * Convert a nilable into an optional argument.
- * This means `null` is normalized to `undefined`.
- * @param nilable - The subject to convert to an optional.
- * @returns The value, normalized to `undefined`, if it was nil.
- */
-export declare function toOptional<T>(nilable: Maybe<T>): T | undefined;

package/lib/data/nil.js

@@ -1,131 +0,0 @@
-/**
- * Check if something is nil.
- * Can be used as a typeguard.
- * @param subject - The subject that could be nil.
- * @typeParam TSubject - The type of the subject.
- * @returns `true` if the subject is nil, `false` otherwise.
- */
-export function isNil(subject) {
-    return subject === null || subject === undefined;
-}
-/**
- * Check if something is a concrete value of the given type.
- * Can be used as a typeguard.
- * @param subject - The subject that could be nil.
- * @param Prototype - The prototype to check against.
- * @typeParam TSubject - The type to check against.
- * @returns `true` if the input element matches the given type,
- * `false` otherwise.
- */
-export function is(subject, Prototype) {
-    return !isNil(subject) && subject instanceof Prototype;
-}
-/**
- * Thrown when an unexpected nil value was encountered.
- */
-export class UnexpectedNilError extends Error {
-    /**
-     * Constructs a new {@linkcode UnexpectedNilError}.
-     * @param message - The error message.
-     */
-    constructor(message = "unexpected nil value") {
-        super(message);
-    }
-}
-/**
- * Ensure that the passed subject is not nil; throw otherwise.
- * @param subject - A subject that is possibly nil.
- * @param errorMessage - An optional error message to throw when the subject is nil.
- * @typeParam TSubject - The type of the subject.
- * @returns The subject, if it isn't nil.
- * @throws {@linkcode UnexpectedNilError} When the subject is nil.
- */
-export function mustExist(subject, errorMessage) {
-    if (isNil(subject)) {
-        throw new UnexpectedNilError(errorMessage);
-    }
-    return subject;
-}
-/**
- * Ensure that all passed subjects are not nil; throw otherwise.
- * @param subjects - The subjects that are possibly nil.
- * @param errorMessage - An optional error message to throw when a subject is nil.
- * @typeParam TSubject - The type a the subject.
- * @returns The subjects, if they aren't nil.
- * @throws {@linkcode UnexpectedNilError} When a subject is nil.
- */
-export function mustExistAll(subjects, errorMessage) {
-    for (const subject of subjects) {
-        if (isNil(subject)) {
-            throw new UnexpectedNilError(errorMessage);
-        }
-    }
-    return subjects;
-}
-/**
- * Ensure that the passed subject is not nil; throw otherwise.
- * @param subject - A subject that is possibly nil.
- * @typeParam TSubject - The type of the subject.
- * @throws {@linkcode UnexpectedNilError} When the subject is nil.
- */
-export function assertExists(subject) {
-    if (isNil(subject)) {
-        throw new UnexpectedNilError();
-    }
-}
-/**
- * Ensure that the passed subjects are not nil; throw otherwise.
- * @param subjects - Subjects that are possibly nil.
- * @typeParam TSubject - The type of a subject.
- * @throws {@linkcode UnexpectedNilError} When a subject is nil.
- */
-export function assertExistsAll(subjects) {
-    for (const subject of subjects) {
-        if (isNil(subject)) {
-            throw new UnexpectedNilError();
-        }
-    }
-}
-/**
- * Convert a nilable into a real value, if it is nil.
- * @param nilable - The subject to convert to an optional.
- * @param to - The value to coalese to.
- * @returns The input value, if it wasn't nil, or the value to coalesce to.
- */
-export function coalesce(nilable, to) {
-    if (isNil(nilable)) {
-        return to;
-    }
-    return nilable;
-}
-/**
- * Drop all nil values from an array, or replaces them with another value.
- * @param nilables - The subject to convert.
- * @param to - The value to coalese to.
- * @returns An array with where all values are not nil.
- */
-export function coalesceArray(nilables, to) {
-    const result = new Array();
-    for (const nilable of nilables) {
-        if (!isNil(nilable)) {
-            result.push(nilable);
-        }
-        else if (!isNil(to)) {
-            result.push(to);
-        }
-    }
-    return result;
-}
-/**
- * Convert a nilable into an optional argument.
- * This means `null` is normalized to `undefined`.
- * @param nilable - The subject to convert to an optional.
- * @returns The value, normalized to `undefined`, if it was nil.
- */
-export function toOptional(nilable) {
-    if (isNil(nilable)) {
-        return undefined;
-    }
-    return nilable;
-}
-//# sourceMappingURL=nil.js.map

package/lib/data/nil.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"nil.js","sourceRoot":"","sources":["../../source/data/nil.ts"],"names":[],"mappings":"AAcA;;;;;;GAMG;AACH,MAAM,UAAU,KAAK,CAAW,OAAwB;IACtD,OAAO,OAAO,KAAK,IAAI,IAAI,OAAO,KAAK,SAAS,CAAC;AACnD,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,EAAE,CAChB,OAAkC,EAClC,SAAkC;IAElC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,OAAO,YAAY,SAAS,CAAC;AACzD,CAAC;AAED;;GAEG;AACH,MAAM,OAAO,kBAAmB,SAAQ,KAAK;IAC3C;;;OAGG;IACH,YAAY,OAAO,GAAG,sBAAsB;QAC1C,KAAK,CAAC,OAAO,CAAC,CAAC;IACjB,CAAC;CACF;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,SAAS,CAAW,OAAwB,EAAE,YAAqB;IACjF,IAAI,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;QACnB,MAAM,IAAI,kBAAkB,CAAC,YAAY,CAAC,CAAC;IAC7C,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,YAAY,CAC1B,QAAgC,EAChC,YAAqB;IAErB,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,IAAI,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;YACnB,MAAM,IAAI,kBAAkB,CAAC,YAAY,CAAC,CAAC;QAC7C,CAAC;IACH,CAAC;IAED,OAAO,QAA2B,CAAC;AACrC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAW,OAAwB;IAC7D,IAAI,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;QACnB,MAAM,IAAI,kBAAkB,EAAE,CAAC;IACjC,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,eAAe,CAC7B,QAAgC;IAEhC,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,IAAI,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;YACnB,MAAM,IAAI,kBAAkB,EAAE,CAAC;QACjC,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,QAAQ,CAAI,OAAiB,EAAE,EAAK;IAClD,IAAI,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;QACnB,OAAO,EAAE,CAAC;IACZ,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAAI,QAAyB,EAAE,EAAa;IACvE,MAAM,MAAM,GAAG,IAAI,KAAK,EAAK,CAAC;IAC9B,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;YACpB,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACvB,CAAC;aAAM,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC;YACtB,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAClB,CAAC;IACH,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,UAAU,CAAI,OAAiB;IAC7C,IAAI,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;QACnB,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC"}