@oliversalzburg/js-utils 0.0.3 → 0.0.5

package/mkdocs.yml

@@ -0,0 +1,52 @@
+copyright: Oliver Salzburg
+dev_addr: 0.0.0.0:8000
+docs_dir: docs
+extra:
+  social:
+    - icon: fontawesome/brands/github
+      link: https://github.com/oliversalzburg/
+markdown_extensions:
+  - abbr
+  - admonition
+  - pymdownx.details
+  - pymdownx.highlight:
+      anchor_linenums: true
+  - pymdownx.inlinehilite
+  - pymdownx.snippets
+  - pymdownx.superfences:
+  - pymdownx.tabbed:
+      alternate_style: true
+  - pymdownx.tilde
+  - toc:
+      permalink: true
+plugins:
+  - search
+repo_name: oliversalzburg/js-utils
+repo_url: https://github.com/oliversalzburg/js-utils
+site_name: JS Utils
+theme:
+  favicon: assets/images/favicon.ico
+  features:
+    - content.code.copy
+    - navigation.instant
+    - navigation.sections
+    - navigation.tabs
+    - navigation.tabs.sticky
+  icon:
+    repo: fontawesome/brands/github
+  name: material
+  palette:
+    - media: "(prefers-color-scheme: light)"
+      scheme: default
+      accent: amber
+      primary: indigo
+      toggle:
+        icon: material/toggle-switch-off-outline
+        name: Switch to dark mode
+    - media: "(prefers-color-scheme: dark)"
+      scheme: slate
+      accent: indigo
+      primary: amber
+      toggle:
+        icon: material/toggle-switch
+        name: Switch to light mode

package/output/core.d.ts

@@ -1,4 +1,21 @@
 /**
  * Describes a function that is a constructor for T.
  */
-export type ConstructorOf<T = Record<string, unknown>> = new (...args: any[]) => T;
+export type ConstructorOf<T = Record<string, unknown>> = new (...args: Array<any>) => T;
+/**
+ * Describes literally any function.
+ */
+export type AnyFunction = (...args: Array<any>) => any;
+/**
+ * Any constructor
+ */
+export type AnyConstructor = new (...args: Array<any>) => any;
+/**
+ * Describes a function returning an instance of T.
+ */
+export type FunctionReturning<T = any> = (...args: Array<any>) => T;
+/**
+ * Describes a class "mixin", which is a function that returns a dynamically
+ * constructed class, based on the passed parameters.
+ */
+export type Mixin<T extends FunctionReturning> = InstanceType<ReturnType<T>>;

package/output/core.js

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

package/output/core.js.map

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

package/output/error-serializer.d.ts

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

package/output/error-serializer.js

@@ -0,0 +1,63 @@
+import { types } from "node:util";
+import { AbstractError } from "./errors/AbstractError.js";
+import { InternalError } from "./errors/InternalError.js";
+import { UnknownError } from "./errors/UnknownError.js";
+/**
+ * Determine if the given unknown subject is an `Error` instance.
+ * @param subject The object to inspect.
+ * @returns `true` if the subject is an `Error`, `false` otherwise.
+ */
+export const isError = (subject) => {
+    return subject instanceof Error || types.isNativeError(subject);
+};
+/**
+ * Returns an `AbstractError` that best represents the passed subject.
+ * If the passed subject is already an `AbstractError`, it is returned as-is.
+ * Otherwise, it will be converted into an appropriate error type.
+ * @param subject The subject to inspect
+ * @returns An `AbstractError` instance.
+ */
+export const unknownToError = (subject) => {
+    if (AbstractError.isAbstractError(subject)) {
+        return subject;
+    }
+    if (isError(subject)) {
+        return InternalError.fromError(subject);
+    }
+    return new UnknownError(String(subject));
+};
+/**
+ * Serializes an error into a JSON string.
+ * @param error The error to stringify.
+ * @returns A JSON string representing the error.
+ */
+export const errorToJSON = (error) => {
+    return JSON.stringify(error, Object.getOwnPropertyNames(error));
+};
+/**
+ * Converts an error into a regular hash.
+ * @param error The error to convert.
+ * @returns A new object that contains all the properties of the error.
+ */
+export const errorToRecord = (error) => {
+    const record = {};
+    for (const propertyName of Object.getOwnPropertyNames(error)) {
+        record[propertyName] = error[propertyName];
+    }
+    return record;
+};
+/**
+ * Serializes an error into a simpler shape.
+ * @param error The error to serialize.
+ * @returns A simple representation of the error.
+ */
+export const errorToSimpleSerializable = (error) => {
+    const serialized = {
+        code: error.code,
+        message: error.message,
+        name: error.name,
+        stack: error.stack,
+    };
+    return serialized;
+};
+//# sourceMappingURL=error-serializer.js.map

package/output/error-serializer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-serializer.js","sourceRoot":"","sources":["../source/error-serializer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAClC,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAOxD;;;;GAIG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,OAAgB,EAAoB,EAAE;IAC5D,OAAO,OAAO,YAAY,KAAK,IAAI,KAAK,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;AAClE,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,OAAgB,EAAiB,EAAE;IAChE,IAAI,aAAa,CAAC,eAAe,CAAC,OAAO,CAAC,EAAE;QAC1C,OAAO,OAAO,CAAC;KAChB;IAED,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE;QACpB,OAAO,aAAa,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;KACzC;IAED,OAAO,IAAI,YAAY,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;AAC3C,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,KAAY,EAAU,EAAE;IAClD,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC,CAAC;AAClE,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,KAAY,EAA2B,EAAE;IACrE,MAAM,MAAM,GAA4B,EAAE,CAAC;IAC3C,KAAK,MAAM,YAAY,IAAI,MAAM,CAAC,mBAAmB,CAAC,KAAK,CAAC,EAAE;QAC5D,MAAM,CAAC,YAAY,CAAC,GAAG,KAAK,CAAC,YAAkC,CAAC,CAAC;KAClE;IACD,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CACvC,KAAa,EACI,EAAE;IACnB,MAAM,UAAU,GAAoB;QAClC,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,KAAK,EAAE,KAAK,CAAC,KAAK;KACnB,CAAC;IAEF,OAAO,UAAU,CAAC;AACpB,CAAC,CAAC"}

package/output/errors/AbstractError.d.ts

@@ -0,0 +1,42 @@
+import { Maybe } from "../nil.js";
+/**
+ * Base class for all errors.
+ */
+export declare class AbstractError extends Error {
+    /**
+     * The HTTP status code to associate with this error.
+     * @deprecated We no longer respond to HTTP requests with error-specifc
+     * status codes.
+     */
+    status: number;
+    /**
+     * Another error that should be transported with this error.
+     * @deprecated We don't make use of this or interpret nested errors at all.
+     */
+    inner: Maybe<Error>;
+    /**
+     * A user-friendly error message that may be transported to the client.
+     * @deprecated User-friendly errors should be read from `extensions`.
+     */
+    info: Maybe<string>;
+    /**
+     * An application-unique, readable error code.
+     */
+    code: string;
+    /**
+     * Constructs a new {@link AbstractError}.
+     * @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 {@link AbstractError}, or one of its subclasses.
+     * @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 {@link AbstractError}, `false` otherwise.
+     */
+    static isAbstractError(error: unknown, allowForeignModule?: boolean): error is AbstractError;
+}

package/output/errors/AbstractError.js

@@ -0,0 +1,70 @@
+/**
+ * Base class for all errors.
+ */
+export class AbstractError extends Error {
+    /**
+     * The HTTP status code to associate with this error.
+     * @deprecated We no longer respond to HTTP requests with error-specifc
+     * status codes.
+     */
+    status;
+    /**
+     * Another error that should be transported with this error.
+     * @deprecated We don't make use of this or interpret nested errors at all.
+     */
+    inner;
+    /**
+     * A user-friendly error message that may be transported to the client.
+     * @deprecated User-friendly errors should be read from `extensions`.
+     */
+    info;
+    /**
+     * An application-unique, readable error code.
+     */
+    code;
+    /**
+     * Constructs a new {@link AbstractError}.
+     * @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);
+        this.code = code;
+        this.name = "AbstractError";
+        this.status = status;
+        this.inner = null;
+        // Capture a new stacktrace, otherwise it will include our base-class constructor instead of the code
+        // location we're actually interested in.
+        Error.captureStackTrace(this, AbstractError);
+    }
+    /**
+     * Checks if an object is an instance of {@link AbstractError}, or one of its subclasses.
+     * @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 {@link AbstractError}, `false` otherwise.
+     */
+    static isAbstractError(error, allowForeignModule = true) {
+        if (error instanceof AbstractError) {
+            return true;
+        }
+        // When multiple versions of js-utils are loaded at runtime, the
+        // prototypes of errors don't align. In that case, we just analyze the
+        // error code.
+        if (allowForeignModule) {
+            const errorRecord = error;
+            if (Object(error) === error &&
+                "code" in errorRecord &&
+                typeof errorRecord.code === "string") {
+                const codedError = error;
+                if (codedError.code.match(/^ERR_OS_/)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=AbstractError.js.map

package/output/errors/AbstractError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractError.js","sourceRoot":"","sources":["../../source/errors/AbstractError.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,OAAO,aAAc,SAAQ,KAAK;IACtC;;;;OAIG;IACH,MAAM,CAAS;IAEf;;;OAGG;IACH,KAAK,CAAe;IAEpB;;;OAGG;IACH,IAAI,CAAgB;IAEpB;;OAEG;IACH,IAAI,CAAS;IAEb;;;;;OAKG;IACH,YAAY,IAAY,EAAE,OAAe,EAAE,MAAc;QACvD,KAAK,CAAC,OAAO,CAAC,CAAC;QAEf,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,IAAI,GAAG,eAAe,CAAC;QAC5B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAElB,qGAAqG;QACrG,yCAAyC;QACzC,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC;IAC/C,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,eAAe,CAAC,KAAc,EAAE,kBAAkB,GAAG,IAAI;QAC9D,IAAI,KAAK,YAAY,aAAa,EAAE;YAClC,OAAO,IAAI,CAAC;SACb;QAED,gEAAgE;QAChE,sEAAsE;QACtE,cAAc;QACd,IAAI,kBAAkB,EAAE;YACtB,MAAM,WAAW,GAAG,KAAgC,CAAC;YACrD,IACE,MAAM,CAAC,KAAK,CAAC,KAAK,KAAK;gBACvB,MAAM,IAAI,WAAW;gBACrB,OAAO,WAAW,CAAC,IAAI,KAAK,QAAQ,EACpC;gBACA,MAAM,UAAU,GAAG,KAAyB,CAAC;gBAC7C,IAAI,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE;oBACrC,OAAO,IAAI,CAAC;iBACb;aACF;SACF;QAED,OAAO,KAAK,CAAC;IACf,CAAC;CACF"}

package/output/errors/InternalError.d.ts

@@ -0,0 +1,19 @@
+import { AbstractError } from "./AbstractError.js";
+/**
+ * Used when an `Error`-like object was caught and converted into an
+ * implementation of `AbstractError` for further processing.
+ */
+export declare class InternalError extends AbstractError {
+    /**
+     * Constructs a new {@link InternalError}.
+     * @param message The main error message.
+     * @param status The HTTP status code to return.
+     */
+    constructor(message: string, status?: number);
+    /**
+     * Converts an error into an {@link InternalError}.
+     * @param error The error to convert.
+     * @returns An {@link InternalError} that represents the given error.
+     */
+    static fromError(error: Error): InternalError;
+}

package/output/errors/InternalError.js

@@ -0,0 +1,38 @@
+import { AbstractError } from "./AbstractError.js";
+/**
+ * Used when an `Error`-like object was caught and converted into an
+ * implementation of `AbstractError` for further processing.
+ */
+export class InternalError extends AbstractError {
+    /**
+     * Constructs a new {@link InternalError}.
+     * @param message The main error message.
+     * @param status The HTTP status code to return.
+     */
+    constructor(message, status = 500) {
+        super("ERR_OS_INTERNAL", message, status);
+        this.name = "InternalError";
+        // Capture a new stacktrace, otherwise it will include our base-class
+        // constructor instead of the code location we're actually interested in.
+        Error.captureStackTrace(this, InternalError);
+    }
+    /**
+     * Converts an error into an {@link InternalError}.
+     * @param error The error to convert.
+     * @returns An {@link InternalError} that represents the given error.
+     */
+    static fromError(error) {
+        // Create a _real_ `InternalError` instance, which we will return later.
+        const internalError = new InternalError(error.message);
+        // Assign the error to it, to inherit all the fields in the error.
+        // Then assign another `InternalError` to replace key fields, like:
+        // name, code, status, ...
+        Object.assign(internalError, error, new InternalError(error.message));
+        // Set the inner error.
+        internalError.inner = error;
+        // Inherit the original error stack again.
+        internalError.stack = error.stack;
+        return internalError;
+    }
+}
+//# sourceMappingURL=InternalError.js.map

package/output/errors/InternalError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InternalError.js","sourceRoot":"","sources":["../../source/errors/InternalError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD;;;GAGG;AACH,MAAM,OAAO,aAAc,SAAQ,aAAa;IAC9C;;;;OAIG;IACH,YAAY,OAAe,EAAE,MAAM,GAAG,GAAG;QACvC,KAAK,CAAC,iBAAiB,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;QAE1C,IAAI,CAAC,IAAI,GAAG,eAAe,CAAC;QAE5B,qEAAqE;QACrE,yEAAyE;QACzE,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC;IAC/C,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,SAAS,CAAC,KAAY;QAC3B,wEAAwE;QACxE,MAAM,aAAa,GAAG,IAAI,aAAa,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACvD,kEAAkE;QAClE,mEAAmE;QACnE,0BAA0B;QAC1B,MAAM,CAAC,MAAM,CAAC,aAAa,EAAE,KAAK,EAAE,IAAI,aAAa,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;QACtE,uBAAuB;QACvB,aAAa,CAAC,KAAK,GAAG,KAAK,CAAC;QAC5B,0CAA0C;QAC1C,aAAa,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;QAElC,OAAO,aAAa,CAAC;IACvB,CAAC;CACF"}

package/output/errors/InvalidArgumentError.d.ts

@@ -0,0 +1,13 @@
+import { AbstractError } from "./AbstractError.js";
+/**
+ * Used when the user supplied an argument that is not valid in the current
+ * context.
+ */
+export declare class InvalidArgumentError extends AbstractError {
+    /**
+     * Constructs a new {@link InvalidArgumentError}.
+     * @param message The main error message.
+     * @param status The HTTP status code to return.
+     */
+    constructor(message: string, status?: number);
+}

package/output/errors/InvalidArgumentError.js

@@ -0,0 +1,20 @@
+import { AbstractError } from "./AbstractError.js";
+/**
+ * Used when the user supplied an argument that is not valid in the current
+ * context.
+ */
+export class InvalidArgumentError extends AbstractError {
+    /**
+     * Constructs a new {@link InvalidArgumentError}.
+     * @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);
+        this.name = "InvalidArgumentError";
+        // Capture a new stacktrace, otherwise it will include our base-class
+        // constructor instead of the code location we're actually interested in.
+        Error.captureStackTrace(this, InvalidArgumentError);
+    }
+}
+//# sourceMappingURL=InvalidArgumentError.js.map

package/output/errors/InvalidArgumentError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InvalidArgumentError.js","sourceRoot":"","sources":["../../source/errors/InvalidArgumentError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD;;;GAGG;AACH,MAAM,OAAO,oBAAqB,SAAQ,aAAa;IACrD;;;;OAIG;IACH,YAAY,OAAe,EAAE,MAAM,GAAG,GAAG;QACvC,KAAK,CAAC,yBAAyB,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;QAElD,IAAI,CAAC,IAAI,GAAG,sBAAsB,CAAC;QAEnC,qEAAqE;QACrE,yEAAyE;QACzE,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,oBAAoB,CAAC,CAAC;IACtD,CAAC;CACF"}

package/output/errors/InvalidOperationError.d.ts

@@ -0,0 +1,13 @@
+import { AbstractError } from "./AbstractError.js";
+/**
+ * Used when an operation was attempted that can not be completed in the current
+ * context.
+ */
+export declare class InvalidOperationError extends AbstractError {
+    /**
+     * Constructs a new {@link InvalidOperationError}.
+     * @param message The main error message.
+     * @param status The HTTP status code to return.
+     */
+    constructor(message: string, status?: number);
+}

package/output/errors/InvalidOperationError.js

@@ -0,0 +1,20 @@
+import { AbstractError } from "./AbstractError.js";
+/**
+ * Used when an operation was attempted that can not be completed in the current
+ * context.
+ */
+export class InvalidOperationError extends AbstractError {
+    /**
+     * Constructs a new {@link InvalidOperationError}.
+     * @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);
+        this.name = "InvalidOperationError";
+        // Capture a new stacktrace, otherwise it will include our base-class
+        // constructor instead of the code location we're actually interested in.
+        Error.captureStackTrace(this, InvalidOperationError);
+    }
+}
+//# sourceMappingURL=InvalidOperationError.js.map

package/output/errors/InvalidOperationError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InvalidOperationError.js","sourceRoot":"","sources":["../../source/errors/InvalidOperationError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD;;;GAGG;AACH,MAAM,OAAO,qBAAsB,SAAQ,aAAa;IACtD;;;;OAIG;IACH,YAAY,OAAe,EAAE,MAAM,GAAG,GAAG;QACvC,KAAK,CAAC,0BAA0B,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;QAEnD,IAAI,CAAC,IAAI,GAAG,uBAAuB,CAAC;QAEpC,qEAAqE;QACrE,yEAAyE;QACzE,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,qBAAqB,CAAC,CAAC;IACvD,CAAC;CACF"}

package/output/errors/NotImplementedError.d.ts

@@ -0,0 +1,12 @@
+import { AbstractError } from "./AbstractError.js";
+/**
+ * Used when a called method actually hasn't been implemented yet (whoops).
+ */
+export declare class NotImplementedError extends AbstractError {
+    /**
+     * Constructs a new {@link NotImplementedError}.
+     * @param message The main error message.
+     * @param status The HTTP status code to return.
+     */
+    constructor(message: string, status?: number);
+}

package/output/errors/NotImplementedError.js

@@ -0,0 +1,19 @@
+import { AbstractError } from "./AbstractError.js";
+/**
+ * Used when a called method actually hasn't been implemented yet (whoops).
+ */
+export class NotImplementedError extends AbstractError {
+    /**
+     * Constructs a new {@link NotImplementedError}.
+     * @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);
+        this.name = "NotImplementedError";
+        // Capture a new stacktrace, otherwise it will include our base-class
+        // constructor instead of the code location we're actually interested in.
+        Error.captureStackTrace(this, NotImplementedError);
+    }
+}
+//# sourceMappingURL=NotImplementedError.js.map

package/output/errors/NotImplementedError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NotImplementedError.js","sourceRoot":"","sources":["../../source/errors/NotImplementedError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD;;GAEG;AACH,MAAM,OAAO,mBAAoB,SAAQ,aAAa;IACpD;;;;OAIG;IACH,YAAY,OAAe,EAAE,MAAM,GAAG,GAAG;QACvC,KAAK,CAAC,wBAAwB,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;QAEjD,IAAI,CAAC,IAAI,GAAG,qBAAqB,CAAC;QAElC,qEAAqE;QACrE,yEAAyE;QACzE,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,mBAAmB,CAAC,CAAC;IACrD,CAAC;CACF"}

package/output/errors/PermissionViolationError.d.ts

@@ -0,0 +1,13 @@
+import { AbstractError } from "./AbstractError.js";
+/**
+ * An error used when access to a resource was requested, but the required
+ * permissions were not available.
+ */
+export declare class PermissionViolationError extends AbstractError {
+    /**
+     * Constructs a new {@link PermissionViolationError}.
+     * @param message The main error message.
+     * @param status The HTTP status code to return.
+     */
+    constructor(message: string, status?: number);
+}

package/output/errors/PermissionViolationError.js

@@ -0,0 +1,20 @@
+import { AbstractError } from "./AbstractError.js";
+/**
+ * An error used when access to a resource was requested, but the required
+ * permissions were not available.
+ */
+export class PermissionViolationError extends AbstractError {
+    /**
+     * Constructs a new {@link PermissionViolationError}.
+     * @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);
+        this.name = "PermissionViolationError";
+        // Capture a new stacktrace, otherwise it will include our base-class
+        // constructor instead of the code location we're actually interested in.
+        Error.captureStackTrace(this, PermissionViolationError);
+    }
+}
+//# sourceMappingURL=PermissionViolationError.js.map

package/output/errors/PermissionViolationError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PermissionViolationError.js","sourceRoot":"","sources":["../../source/errors/PermissionViolationError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD;;;GAGG;AACH,MAAM,OAAO,wBAAyB,SAAQ,aAAa;IACzD;;;;OAIG;IACH,YAAY,OAAe,EAAE,MAAM,GAAG,GAAG;QACvC,KAAK,CAAC,6BAA6B,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;QAEtD,IAAI,CAAC,IAAI,GAAG,0BAA0B,CAAC;QAEvC,qEAAqE;QACrE,yEAAyE;QACzE,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,wBAAwB,CAAC,CAAC;IAC1D,CAAC;CACF"}

package/output/errors/ResourceConflictError.d.ts

@@ -0,0 +1,12 @@
+import { AbstractError } from "./AbstractError.js";
+/**
+ * Used when a resource conflict was detected.
+ */
+export declare class ResourceConflictError extends AbstractError {
+    /**
+     * Constructs a new {@link ResourceConflictError}.
+     * @param message The main error message.
+     * @param status The HTTP status code to return.
+     */
+    constructor(message: string, status?: number);
+}

package/output/errors/ResourceConflictError.js

@@ -0,0 +1,19 @@
+import { AbstractError } from "./AbstractError.js";
+/**
+ * Used when a resource conflict was detected.
+ */
+export class ResourceConflictError extends AbstractError {
+    /**
+     * Constructs a new {@link ResourceConflictError}.
+     * @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);
+        this.name = "ResourceConflictError";
+        // Capture a new stacktrace, otherwise it will include our base-class
+        // constructor instead of the code location we're actually interested in.
+        Error.captureStackTrace(this, ResourceConflictError);
+    }
+}
+//# sourceMappingURL=ResourceConflictError.js.map

package/output/errors/ResourceConflictError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResourceConflictError.js","sourceRoot":"","sources":["../../source/errors/ResourceConflictError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD;;GAEG;AACH,MAAM,OAAO,qBAAsB,SAAQ,aAAa;IACtD;;;;OAIG;IACH,YAAY,OAAe,EAAE,MAAM,GAAG,GAAG;QACvC,KAAK,CAAC,0BAA0B,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;QAEnD,IAAI,CAAC,IAAI,GAAG,uBAAuB,CAAC;QAEpC,qEAAqE;QACrE,yEAAyE;QACzE,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,qBAAqB,CAAC,CAAC;IACvD,CAAC;CACF"}

package/output/errors/UnknownError.d.ts

@@ -0,0 +1,16 @@
+import { AbstractError } from "./AbstractError.js";
+/**
+ * Used when an unknown, non-`Error`-like object was caught and converted into a
+ * real `Error` instance.
+ * Like when you catch a `throw "boom"`, we will convert the caught `"boom"`
+ * into an `UnknownError`.
+ * To enrich an `Error`-like object that was caught, use the {@link InternalError}.
+ */
+export declare class UnknownError extends AbstractError {
+    /**
+     * Constructs a new {@link UnknownError}.
+     * @param message The main error message.
+     * @param status The HTTP status code to return.
+     */
+    constructor(message: string, status?: number);
+}

package/output/errors/UnknownError.js

@@ -0,0 +1,23 @@
+import { AbstractError } from "./AbstractError.js";
+/**
+ * Used when an unknown, non-`Error`-like object was caught and converted into a
+ * real `Error` instance.
+ * Like when you catch a `throw "boom"`, we will convert the caught `"boom"`
+ * into an `UnknownError`.
+ * To enrich an `Error`-like object that was caught, use the {@link InternalError}.
+ */
+export class UnknownError extends AbstractError {
+    /**
+     * Constructs a new {@link UnknownError}.
+     * @param message The main error message.
+     * @param status The HTTP status code to return.
+     */
+    constructor(message, status = 500) {
+        super("ERR_OS_UNKNOWN", message, status);
+        this.name = "UnknownError";
+        // Capture a new stacktrace, otherwise it will include our base-class
+        // constructor instead of the code location we're actually interested in.
+        Error.captureStackTrace(this, UnknownError);
+    }
+}
+//# sourceMappingURL=UnknownError.js.map

package/output/errors/UnknownError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UnknownError.js","sourceRoot":"","sources":["../../source/errors/UnknownError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD;;;;;;GAMG;AACH,MAAM,OAAO,YAAa,SAAQ,aAAa;IAC7C;;;;OAIG;IACH,YAAY,OAAe,EAAE,MAAM,GAAG,GAAG;QACvC,KAAK,CAAC,gBAAgB,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;QAEzC,IAAI,CAAC,IAAI,GAAG,cAAc,CAAC;QAE3B,qEAAqE;QACrE,yEAAyE;QACzE,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;IAC9C,CAAC;CACF"}

package/output/errors/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./AbstractError.js";
+export * from "./InternalError.js";
+export * from "./InvalidArgumentError.js";
+export * from "./InvalidOperationError.js";
+export * from "./NotImplementedError.js";
+export * from "./PermissionViolationError.js";
+export * from "./ResourceConflictError.js";
+export * from "./UnknownError.js";

package/output/errors/index.js

@@ -0,0 +1,9 @@
+export * from "./AbstractError.js";
+export * from "./InternalError.js";
+export * from "./InvalidArgumentError.js";
+export * from "./InvalidOperationError.js";
+export * from "./NotImplementedError.js";
+export * from "./PermissionViolationError.js";
+export * from "./ResourceConflictError.js";
+export * from "./UnknownError.js";
+//# sourceMappingURL=index.js.map

package/output/errors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../source/errors/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,0BAA0B,CAAC;AACzC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,mBAAmB,CAAC"}