@oliversalzburg/js-utils 0.0.17 → 0.0.19-dev.0

package/array.d.ts

@@ -0,0 +1,39 @@
+import { ConstructorOf } from "./core.js";
+/**
+ * Places the items in the array in random order.
+ * @param array - The array to shuffle.
+ * @typeParam TElements - The type of the elements in the array.
+ * @returns The passed array in random order.
+ * @group Array
+ */
+export declare const shuffleArray: <TElements>(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.
+ * @group Array
+ */
+export declare const intersect: <TElements>(a: TElements[], b: 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`.
+ * @group Array
+ */
+export declare const difference: <TElements>(a: TElements[], b: 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.
+ * @group Array
+ */
+export declare const filterType: <TElements>(array: Array<unknown>, InstanceType: ConstructorOf<TElements>) => TElements[];

package/{lib/array.js → array.js}

@@ -1,8 +1,8 @@
 import { is } from "./nil.js";
 /**
  * Places the items in the array in random order.
- * @param array The array to shuffle.
- * @template {unknown} T The type of the elements in the array.
+ * @param array - The array to shuffle.
+ * @typeParam TElements - The type of the elements in the array.
  * @returns The passed array in random order.
  * @group Array
  */
@@ -18,9 +18,9 @@ export const shuffleArray = (array) => {
 /**
  * Returns an array that holds all items that appear in both
  * passed arrays.
- * @param a The first array.
- * @param b The second array.
- * @template {unknown} T The type of the elements in the array.
+ * @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.
  * @group Array
@@ -30,11 +30,10 @@ export const intersect = (a, b) => {
 };
 /**
  * Returns an array that holds all items that only appear in `a`.
- * @param a The first array.
- * @param b The second array.
- * @template {unknown} T The type of the elements in the array.
- * @returns A new array which holds the items that ony 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`.
  * @group Array
  */
 export const difference = (a, b) => {
@@ -43,9 +42,9 @@ export const difference = (a, b) => {
 /**
  * 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.
- * @template {unknown} T The type of the elements in the 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.
  * @group Array
  */

package/array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.js","sourceRoot":"","sources":["../source/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;QACrD,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;KAC3B;IACD,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AAEF;;;;;;;;;GASG;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;;;;;;;GAOG;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;;;;;;;;GAQG;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"}

package/async.d.ts

@@ -0,0 +1,28 @@
+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 exectute.
+ * @typeParam TArguments - The type of the arguments that your function expects.
+ * @returns A function returning nothing.
+ * @group Async
+ */
+export declare const prepareAsyncContext: <TArguments extends unknown[]>(context: AnyAsyncFunction) => (...args: TArguments) => 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.
+ * @group Async
+ */
+export declare const coalesceOnRejection: <TExecutableReturn, TCoalesce, TFilter extends ConstructorOf<Error>>(executable: AnyFunctionReturning<TExecutableReturn | Promise<TExecutableReturn>>, to: TCoalesce, filter?: TFilter | undefined) => Promise<TExecutableReturn | TCoalesce>;

package/{lib/async.js → async.js}

@@ -4,27 +4,33 @@
  *
  * This can be useful when providing asynchonous event handler to `.addEventlistener()`,
  * which only expects synchronous functions.
- * @param context The asynchronous function to exectute.
+ * @param context - The asynchronous function to exectute.
+ * @typeParam TArguments - The type of the arguments that your function expects.
  * @returns A function returning nothing.
  * @group Async
  */
 export const prepareAsyncContext = (context) => {
-    return () => {
-        void context()
+    return (
+    /**
+     * The arguments that our new function was called with.
+     */
+    ...args) => {
+        void context(...args)
             .then(() => undefined)
-            .catch(() => undefined);
+            // eslint-disable-next-line no-console
+            .catch(console.error);
     };
 };
 /**
  * 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
+ * @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.
- * @template {unknown} TExecutableReturn The return type of the function.
- * @template {unknown} TCoalesce The type of the object to coalesce to.
- * @template {ConstructorOf<Error>} TFilter The type of the error filter.
+ * @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.
  * @group Async

package/async.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async.js","sourceRoot":"","sources":["../source/async.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CACjC,OAAyB,EACzB,EAAE;IACF,OAAO;IACL;;OAEG;IACH,GAAG,IAAgB,EACnB,EAAE;QACF,KAAK,OAAO,CAAC,GAAG,IAAI,CAAC;aAClB,IAAI,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC;YACtB,sCAAsC;aACrC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAC1B,CAAC,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,KAAK,EAKtC,UAAgF,EAChF,EAAa,EACb,MAAgB,EAChB,EAAE;IACF,IAAI;QACF,OAAO,MAAM,UAAU,EAAE,CAAC;KAC3B;IAAC,OAAO,KAAK,EAAE;QACd,IAAI,CAAC,MAAM,KAAK,SAAS,IAAI,KAAK,YAAY,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE;YAChE,OAAO,EAAE,CAAC;SACX;QACD,MAAM,KAAK,CAAC;KACb;AACH,CAAC,CAAC"}

package/async.test.js

@@ -0,0 +1,28 @@
+/* eslint-disable no-unused-expressions */
+import { expect } from "chai";
+import { it } from "mocha";
+import { prepareAsyncContext } from "./async.js";
+import { sleep } from "./sleep.js";
+it("executes trivial callback", async () => {
+    let executed = false;
+    const callback = prepareAsyncContext(async () => {
+        await sleep(1);
+        executed = true;
+    });
+    callback();
+    await sleep(100);
+    expect(executed).to.be.true;
+});
+it("passes parameters to callback", async () => {
+    let executed = false;
+    const callback = prepareAsyncContext(async (event, eventId) => {
+        expect(event.name).to.equal("call");
+        expect(eventId).to.equal(42);
+        await sleep(1);
+        executed = true;
+    });
+    callback({ name: "call" }, 42);
+    await sleep(100);
+    expect(executed).to.be.true;
+});
+//# sourceMappingURL=async.test.js.map

package/async.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async.test.js","sourceRoot":"","sources":["../source/async.test.ts"],"names":[],"mappings":"AAAA,0CAA0C;AAC1C,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAC9B,OAAO,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC;AAC3B,OAAO,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,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,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC;AAC9B,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,KAAK,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QACpC,MAAM,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QAE7B,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,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC;AAC9B,CAAC,CAAC,CAAC"}

package/core.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 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>) => 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>>;

package/core.js

@@ -0,0 +1,3 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export {};
+//# sourceMappingURL=core.js.map

package/core.js.map

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

package/{lib/dom → dom}/core.d.ts

@@ -3,21 +3,21 @@ import { ConstructorOf } from "../core.js";
 /**
  * Retrieves an element from the document and returns it if it is
  * non-null and has the expected type. Otherwise an error is thrown.
- * @param document The document from which to look up the element.
- * @param id The ID of the element.
- * @param Type The type you expect the element to have.
+ * @param document - The document from which to look up the element.
+ * @param id - The ID of the element.
+ * @param Type - The type you expect the element to have.
  * @returns The requested element, if it has the expected type.
- * @throws {InvalidOperationError} When the document element has an unexpected type.
- * @throws {UnexpectedNilError} When the the document element is `null`.
+ * @throws {@linkcode InvalidOperationError} When the document element has an unexpected type.
+ * @throws {@linkcode  UnexpectedNilError} When the the document element is `null`.
  * @group DOM
  */
 export declare const getDocumentElementTypeByIdStrict: <T extends HTMLElement>(document: Document, id: string, Type: ConstructorOf<T>) => T;
 /**
  * Retrieves an element from the document and returns it if it has the
  * expected type.
- * @param document The document from which to look up the element.
- * @param id The ID of the element.
- * @param Type The type you expect the element to have.
+ * @param document - The document from which to look up the element.
+ * @param id - The ID of the element.
+ * @param Type - The type you expect the element to have.
  * @returns The requested element, if it has the expected type; `null` otherwise.
  * @group DOM
  */

package/{lib/dom → dom}/core.js

@@ -3,12 +3,12 @@ import { UnexpectedNilError } from "../nil.js";
 /**
  * Retrieves an element from the document and returns it if it is
  * non-null and has the expected type. Otherwise an error is thrown.
- * @param document The document from which to look up the element.
- * @param id The ID of the element.
- * @param Type The type you expect the element to have.
+ * @param document - The document from which to look up the element.
+ * @param id - The ID of the element.
+ * @param Type - The type you expect the element to have.
  * @returns The requested element, if it has the expected type.
- * @throws {InvalidOperationError} When the document element has an unexpected type.
- * @throws {UnexpectedNilError} When the the document element is `null`.
+ * @throws {@linkcode InvalidOperationError} When the document element has an unexpected type.
+ * @throws {@linkcode  UnexpectedNilError} When the the document element is `null`.
  * @group DOM
  */
 export const getDocumentElementTypeByIdStrict = (document, id, Type) => {
@@ -24,9 +24,9 @@ export const getDocumentElementTypeByIdStrict = (document, id, Type) => {
 /**
  * Retrieves an element from the document and returns it if it has the
  * expected type.
- * @param document The document from which to look up the element.
- * @param id The ID of the element.
- * @param Type The type you expect the element to have.
+ * @param document - The document from which to look up the element.
+ * @param id - The ID of the element.
+ * @param Type - The type you expect the element to have.
  * @returns The requested element, if it has the expected type; `null` otherwise.
  * @group DOM
  */

package/{lib/error-serializer.d.ts → error-serializer.d.ts}

@@ -6,7 +6,7 @@ import { AbstractError } from "./errors/AbstractError.js";
 export type SerializedError = Record<string, Record<string, string> | string | undefined>;
 /**
  * Determine if the given unknown subject is an {@linkcode !Error} instance.
- * @param subject The object to inspect.
+ * @param subject - The object to inspect.
  * @returns `true` if the subject is an {@linkcode !Error}, `false` otherwise.
  * @group Errors
  */
@@ -15,28 +15,28 @@ export declare const isError: (subject: unknown) => subject is Error;
  * Returns an {@linkcode AbstractError} that best represents the passed subject.
  * If the passed subject is already an {@linkcode AbstractError}, it is returned as-is.
  * Otherwise, it will be converted into an appropriate error type.
- * @param subject The subject to inspect
+ * @param subject - The subject to inspect
  * @returns An {@linkcode AbstractError} instance.
  * @group Errors
  */
 export declare const unknownToError: (subject: unknown) => AbstractError;
 /**
  * Serializes an error into a JSON string.
- * @param error The error to stringify.
+ * @param error - The error to stringify.
  * @returns A JSON string representing the error.
  * @group Errors
  */
 export declare const errorToJSON: (error: Error) => string;
 /**
  * Converts an error into a regular hash.
- * @param error The error to convert.
+ * @param error - The error to convert.
  * @returns A new object that contains all the properties of the error.
  * @group Errors
  */
 export declare const errorToRecord: (error: Error) => Record<string, unknown>;
 /**
  * Serializes an error into a simpler shape.
- * @param error The error to serialize.
+ * @param error - The error to serialize.
  * @returns A simple representation of the error.
  * @group Errors
  */

package/{lib/error-serializer.js → error-serializer.js}

@@ -3,7 +3,7 @@ import { InternalError } from "./errors/InternalError.js";
 import { UnknownError } from "./errors/UnknownError.js";
 /**
  * Determine if the given unknown subject is an {@linkcode !Error} instance.
- * @param subject The object to inspect.
+ * @param subject - The object to inspect.
  * @returns `true` if the subject is an {@linkcode !Error}, `false` otherwise.
  * @group Errors
  */
@@ -14,7 +14,7 @@ export const isError = (subject) => {
  * Returns an {@linkcode AbstractError} that best represents the passed subject.
  * If the passed subject is already an {@linkcode AbstractError}, it is returned as-is.
  * Otherwise, it will be converted into an appropriate error type.
- * @param subject The subject to inspect
+ * @param subject - The subject to inspect
  * @returns An {@linkcode AbstractError} instance.
  * @group Errors
  */
@@ -29,7 +29,7 @@ export const unknownToError = (subject) => {
 };
 /**
  * Serializes an error into a JSON string.
- * @param error The error to stringify.
+ * @param error - The error to stringify.
  * @returns A JSON string representing the error.
  * @group Errors
  */
@@ -38,7 +38,7 @@ export const errorToJSON = (error) => {
 };
 /**
  * Converts an error into a regular hash.
- * @param error The error to convert.
+ * @param error - The error to convert.
  * @returns A new object that contains all the properties of the error.
  * @group Errors
  */
@@ -51,7 +51,7 @@ export const errorToRecord = (error) => {
 };
 /**
  * Serializes an error into a simpler shape.
- * @param error The error to serialize.
+ * @param error - The error to serialize.
  * @returns A simple representation of the error.
  * @group Errors
  */

package/{lib/errors → errors}/AbstractError.d.ts

@@ -13,15 +13,15 @@ export declare class AbstractError extends Error {
     code: string;
     /**
      * Constructs a new {@linkcode AbstractError}.
-     * @param code The main identification code for the error.
-     * @param message The main error message.
-     * @param status The HTTP status code to return.
+     * @param code - The main identification code for the error.
+     * @param message - The main error message.
+     * @param status - The HTTP status code to return.
      */
     constructor(code: string, message: string, status: number);
     /**
      * Checks if an object is an instance of {@linkcode AbstractError}, or one of its subclasses.
-     * @param error The object to check.
-     * @param allowForeignModule Only check for similar looking error codes.
+     * @param error - The object to check.
+     * @param allowForeignModule - Only check for similar looking error codes.
      * You're going to want to use this if you're dealing with a setup where
      * multiple versions of js-utils are loaded.
      * @returns `true` if the object is an {@linkcode AbstractError}, `false` otherwise.

package/{lib/errors → errors}/AbstractError.js

@@ -13,9 +13,9 @@ export class AbstractError extends Error {
     code;
     /**
      * Constructs a new {@linkcode AbstractError}.
-     * @param code The main identification code for the error.
-     * @param message The main error message.
-     * @param status The HTTP status code to return.
+     * @param code - The main identification code for the error.
+     * @param message - The main error message.
+     * @param status - The HTTP status code to return.
      */
     constructor(code, message, status) {
         super(message);
@@ -30,8 +30,8 @@ export class AbstractError extends Error {
     }
     /**
      * Checks if an object is an instance of {@linkcode AbstractError}, or one of its subclasses.
-     * @param error The object to check.
-     * @param allowForeignModule Only check for similar looking error codes.
+     * @param error - The object to check.
+     * @param allowForeignModule - Only check for similar looking error codes.
      * You're going to want to use this if you're dealing with a setup where
      * multiple versions of js-utils are loaded.
      * @returns `true` if the object is an {@linkcode AbstractError}, `false` otherwise.

package/{lib/errors → errors}/InternalError.d.ts

@@ -7,13 +7,13 @@ import { AbstractError } from "./AbstractError.js";
 export declare class InternalError extends AbstractError {
     /**
      * Constructs a new {@linkcode InternalError}.
-     * @param message The main error message.
-     * @param status The HTTP status code to return.
+     * @param message - The main error message.
+     * @param status - The HTTP status code to return.
      */
     constructor(message: string, status?: number);
     /**
      * Converts an error into an {@linkcode InternalError}.
-     * @param error The error to convert.
+     * @param error - The error to convert.
      * @returns An {@linkcode InternalError} that represents the given error.
      */
     static fromError(error: Error): InternalError;

package/{lib/errors → errors}/InternalError.js

@@ -7,8 +7,8 @@ import { AbstractError } from "./AbstractError.js";
 export class InternalError extends AbstractError {
     /**
      * Constructs a new {@linkcode InternalError}.
-     * @param message The main error message.
-     * @param status The HTTP status code to return.
+     * @param message - The main error message.
+     * @param status - The HTTP status code to return.
      */
     constructor(message, status = 500) {
         super("ERR_OS_INTERNAL", message, status);
@@ -21,7 +21,7 @@ export class InternalError extends AbstractError {
     }
     /**
      * Converts an error into an {@linkcode InternalError}.
-     * @param error The error to convert.
+     * @param error - The error to convert.
      * @returns An {@linkcode InternalError} that represents the given error.
      */
     static fromError(error) {

package/{lib/errors → errors}/InvalidArgumentError.d.ts

@@ -7,8 +7,8 @@ import { AbstractError } from "./AbstractError.js";
 export declare class InvalidArgumentError extends AbstractError {
     /**
      * Constructs a new {@linkcode InvalidArgumentError}.
-     * @param message The main error message.
-     * @param status The HTTP status code to return.
+     * @param message - The main error message.
+     * @param status - The HTTP status code to return.
      */
     constructor(message: string, status?: number);
 }

package/{lib/errors → errors}/InvalidArgumentError.js

@@ -7,8 +7,8 @@ import { AbstractError } from "./AbstractError.js";
 export class InvalidArgumentError extends AbstractError {
     /**
      * Constructs a new {@linkcode InvalidArgumentError}.
-     * @param message The main error message.
-     * @param status The HTTP status code to return.
+     * @param message - The main error message.
+     * @param status - The HTTP status code to return.
      */
     constructor(message, status = 400) {
         super("ERR_OS_INVALID_ARGUMENT", message, status);

package/{lib/errors → errors}/InvalidOperationError.d.ts

@@ -7,8 +7,8 @@ import { AbstractError } from "./AbstractError.js";
 export declare class InvalidOperationError extends AbstractError {
     /**
      * Constructs a new {@linkcode InvalidOperationError}.
-     * @param message The main error message.
-     * @param status The HTTP status code to return.
+     * @param message - The main error message.
+     * @param status - The HTTP status code to return.
      */
     constructor(message: string, status?: number);
 }

package/{lib/errors → errors}/InvalidOperationError.js

@@ -7,8 +7,8 @@ import { AbstractError } from "./AbstractError.js";
 export class InvalidOperationError extends AbstractError {
     /**
      * Constructs a new {@linkcode InvalidOperationError}.
-     * @param message The main error message.
-     * @param status The HTTP status code to return.
+     * @param message - The main error message.
+     * @param status - The HTTP status code to return.
      */
     constructor(message, status = 400) {
         super("ERR_OS_INVALID_OPERATION", message, status);

package/{lib/errors → errors}/NotImplementedError.d.ts

@@ -6,8 +6,8 @@ import { AbstractError } from "./AbstractError.js";
 export declare class NotImplementedError extends AbstractError {
     /**
      * Constructs a new {@linkcode NotImplementedError}.
-     * @param message The main error message.
-     * @param status The HTTP status code to return.
+     * @param message - The main error message.
+     * @param status - The HTTP status code to return.
      */
     constructor(message: string, status?: number);
 }

package/{lib/errors → errors}/NotImplementedError.js

@@ -6,8 +6,8 @@ import { AbstractError } from "./AbstractError.js";
 export class NotImplementedError extends AbstractError {
     /**
      * Constructs a new {@linkcode NotImplementedError}.
-     * @param message The main error message.
-     * @param status The HTTP status code to return.
+     * @param message - The main error message.
+     * @param status - The HTTP status code to return.
      */
     constructor(message, status = 501) {
         super("ERR_OS_NOT_IMPLEMENTED", message, status);

package/{lib/errors → errors}/PermissionViolationError.d.ts

@@ -7,8 +7,8 @@ import { AbstractError } from "./AbstractError.js";
 export declare class PermissionViolationError extends AbstractError {
     /**
      * Constructs a new {@linkcode PermissionViolationError}.
-     * @param message The main error message.
-     * @param status The HTTP status code to return.
+     * @param message - The main error message.
+     * @param status - The HTTP status code to return.
      */
     constructor(message: string, status?: number);
 }

package/{lib/errors → errors}/PermissionViolationError.js

@@ -7,8 +7,8 @@ import { AbstractError } from "./AbstractError.js";
 export class PermissionViolationError extends AbstractError {
     /**
      * Constructs a new {@linkcode PermissionViolationError}.
-     * @param message The main error message.
-     * @param status The HTTP status code to return.
+     * @param message - The main error message.
+     * @param status - The HTTP status code to return.
      */
     constructor(message, status = 403) {
         super("ERR_OS_PERMISSION_VIOLATION", message, status);

package/{lib/errors → errors}/ResourceConflictError.d.ts

@@ -6,8 +6,8 @@ import { AbstractError } from "./AbstractError.js";
 export declare class ResourceConflictError extends AbstractError {
     /**
      * Constructs a new {@linkcode ResourceConflictError}.
-     * @param message The main error message.
-     * @param status The HTTP status code to return.
+     * @param message - The main error message.
+     * @param status - The HTTP status code to return.
      */
     constructor(message: string, status?: number);
 }

package/{lib/errors → errors}/ResourceConflictError.js

@@ -6,8 +6,8 @@ import { AbstractError } from "./AbstractError.js";
 export class ResourceConflictError extends AbstractError {
     /**
      * Constructs a new {@linkcode ResourceConflictError}.
-     * @param message The main error message.
-     * @param status The HTTP status code to return.
+     * @param message - The main error message.
+     * @param status - The HTTP status code to return.
      */
     constructor(message, status = 409) {
         super("ERR_OS_RESOURCE_CONFLICT", message, status);

package/{lib/errors → errors}/UnknownError.d.ts

@@ -10,8 +10,8 @@ import { AbstractError } from "./AbstractError.js";
 export declare class UnknownError extends AbstractError {
     /**
      * Constructs a new {@linkcode UnknownError}.
-     * @param message The main error message.
-     * @param status The HTTP status code to return.
+     * @param message - The main error message.
+     * @param status - The HTTP status code to return.
      */
     constructor(message: string, status?: number);
 }

package/{lib/errors → errors}/UnknownError.js

@@ -10,8 +10,8 @@ import { AbstractError } from "./AbstractError.js";
 export class UnknownError extends AbstractError {
     /**
      * Constructs a new {@linkcode UnknownError}.
-     * @param message The main error message.
-     * @param status The HTTP status code to return.
+     * @param message - The main error message.
+     * @param status - The HTTP status code to return.
      */
     constructor(message, status = 500) {
         super("ERR_OS_UNKNOWN", message, status);