@tahminator/sapling 1.5.16 → 1.5.17

package/dist/eslint.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("typescript-eslint").FlatConfig.ConfigArray;
+export default _default;

package/dist/eslint.config.js

@@ -0,0 +1,38 @@
+import js from "@eslint/js";
+import perfectionist from "eslint-plugin-perfectionist";
+import globals from "globals";
+import tseslint from "typescript-eslint";
+export default tseslint.config(js.configs.recommended, ...tseslint.configs.recommended, { ignores: ["dist", "example"] }, {
+    plugins: {
+        perfectionist,
+    },
+    rules: {
+        "perfectionist/sort-imports": "error",
+    },
+}, {
+    files: ["**/*.{ts,tsx}"],
+    languageOptions: {
+        ecmaVersion: 2020,
+        globals: globals["node"],
+    },
+    rules: {
+        "@typescript-eslint/no-namespace": ["off"],
+        "@typescript-eslint/no-non-null-assertion": ["error"],
+        "@typescript-eslint/no-empty-object-type": ["off"],
+        "@typescript-eslint/no-unused-vars": [
+            "error",
+            {
+                argsIgnorePattern: "^_",
+                varsIgnorePattern: "^_",
+                caughtErrorsIgnorePattern: "^_",
+            },
+        ],
+        "@typescript-eslint/consistent-type-imports": [
+            "error",
+            {
+                prefer: "type-imports",
+                fixStyle: "separate-type-imports",
+            },
+        ],
+    },
+}, {});

package/dist/exclusions.d.ts

@@ -0,0 +1,5 @@
+/**
+ * See https://github.com/tahminator/sapling/blob/main/.github/scripts/src/test/index.ts
+ * for test exclusion usages.
+ */
+export declare const exclusions: string[];

package/dist/exclusions.js

@@ -0,0 +1,6 @@
+/**
+ * See https://github.com/tahminator/sapling/blob/main/.github/scripts/src/test/index.ts
+ * for test exclusion usages.
+ */
+const baseDir = "src";
+export const exclusions = [`${baseDir}/**/*.test.ts`];

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./src";

package/dist/index.js

@@ -0,0 +1 @@
+export * from "./src";

package/dist/lib/weakmap.d.ts

@@ -0,0 +1,15 @@
+/**
+ * WeakMap that is iterable.
+ */
+export declare class IterableWeakMap<K extends object, V> {
+    #private;
+    constructor(iterable?: Iterable<[K, V]>);
+    set(key: K, value: V): this;
+    get(key: K): V | undefined;
+    delete(key: K): boolean;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+    entries(): IterableIterator<[K, V]>;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    forEach(callback: (value: V, key: K, map: this) => void, thisArg?: any): void;
+}

package/dist/lib/weakmap.js

@@ -0,0 +1,77 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _a, _IterableWeakMap_weakMap, _IterableWeakMap_refSet, _IterableWeakMap_finalizationGroup, _IterableWeakMap_cleanup;
+/**
+ * WeakMap that is iterable.
+ */
+export class IterableWeakMap {
+    constructor(iterable) {
+        _IterableWeakMap_weakMap.set(this, new WeakMap());
+        _IterableWeakMap_refSet.set(this, new Set());
+        _IterableWeakMap_finalizationGroup.set(this, new FinalizationRegistry(__classPrivateFieldGet(_a, _a, "m", _IterableWeakMap_cleanup)));
+        if (iterable) {
+            for (const [key, value] of iterable) {
+                this.set(key, value);
+            }
+        }
+    }
+    set(key, value) {
+        const ref = new WeakRef(key);
+        __classPrivateFieldGet(this, _IterableWeakMap_weakMap, "f").set(key, { value, ref });
+        __classPrivateFieldGet(this, _IterableWeakMap_refSet, "f").add(ref);
+        __classPrivateFieldGet(this, _IterableWeakMap_finalizationGroup, "f").register(key, {
+            set: __classPrivateFieldGet(this, _IterableWeakMap_refSet, "f"),
+            ref,
+        }, ref);
+        return this;
+    }
+    get(key) {
+        const entry = __classPrivateFieldGet(this, _IterableWeakMap_weakMap, "f").get(key);
+        return entry === null || entry === void 0 ? void 0 : entry.value;
+    }
+    delete(key) {
+        const entry = __classPrivateFieldGet(this, _IterableWeakMap_weakMap, "f").get(key);
+        if (!entry) {
+            return false;
+        }
+        __classPrivateFieldGet(this, _IterableWeakMap_weakMap, "f").delete(key);
+        __classPrivateFieldGet(this, _IterableWeakMap_refSet, "f").delete(entry.ref);
+        __classPrivateFieldGet(this, _IterableWeakMap_finalizationGroup, "f").unregister(entry.ref);
+        return true;
+    }
+    *[(_IterableWeakMap_weakMap = new WeakMap(), _IterableWeakMap_refSet = new WeakMap(), _IterableWeakMap_finalizationGroup = new WeakMap(), _IterableWeakMap_cleanup = function _IterableWeakMap_cleanup(heldValue) {
+        heldValue.set.delete(heldValue.ref);
+    }, Symbol.iterator)]() {
+        for (const ref of __classPrivateFieldGet(this, _IterableWeakMap_refSet, "f")) {
+            const key = ref.deref();
+            if (!key)
+                continue;
+            const entry = __classPrivateFieldGet(this, _IterableWeakMap_weakMap, "f").get(key);
+            if (entry) {
+                yield [key, entry.value];
+            }
+        }
+    }
+    entries() {
+        return this[Symbol.iterator]();
+    }
+    *keys() {
+        for (const [key] of this) {
+            yield key;
+        }
+    }
+    *values() {
+        for (const [, value] of this) {
+            yield value;
+        }
+    }
+    forEach(callback, thisArg) {
+        for (const [key, value] of this) {
+            callback.call(thisArg, value, key, this);
+        }
+    }
+}
+_a = IterableWeakMap;

package/dist/src/annotation/controller.d.ts

@@ -0,0 +1,21 @@
+import { Router } from "express";
+import type { Class } from "../types";
+export declare const _ControllerRegistry: WeakMap<Function, Router>;
+type ControllerProps = {
+    /**
+     * Optional URL prefix applied to all routes in the controller. Defaults to "".
+     */
+    prefix?: string;
+    /**
+     * Optional array of dependencies to be injected into the constructor that are `@Injectable`
+     */
+    deps?: Array<Class<any>>;
+} | undefined;
+/**
+ * Registers a class as an HTTP controller and registers its routes.
+ *
+ * @param [prefix] Optional URL prefix applied to all routes in the controller. Defaults to "".
+ * @param [deps] Optional array of dependencies to be injected into the constructor that are `@Injectable`
+ */
+export declare function Controller({ prefix, deps, }?: ControllerProps): ClassDecorator;
+export {};

package/dist/src/annotation/controller.js

@@ -0,0 +1,78 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Router } from "express";
+import { ResponseEntity, RedirectView } from "../helper";
+import { Sapling } from "../helper/sapling";
+import { Html404ErrorPage } from "../html/404";
+import { methodResolve } from "../types";
+import { _InjectableDeps, _resolve } from "./injectable";
+import { _getRoutes } from "./route";
+export const _ControllerRegistry = new WeakMap();
+/**
+ * Registers a class as an HTTP controller and registers its routes.
+ *
+ * @param [prefix] Optional URL prefix applied to all routes in the controller. Defaults to "".
+ * @param [deps] Optional array of dependencies to be injected into the constructor that are `@Injectable`
+ */
+export function Controller({ prefix = "", deps = [], } = {}) {
+    return (target) => {
+        const targetClass = target;
+        const router = Router();
+        const routes = _getRoutes(target);
+        const usedRoutes = new Set();
+        _InjectableDeps.set(targetClass, deps);
+        const controllerInstance = _resolve(targetClass);
+        for (const { method, path, fnName } of routes) {
+            const fn = controllerInstance[fnName];
+            if (typeof fn !== "function")
+                continue;
+            // When path is a RegExp, use it directly without prefix
+            // When path is a string, prepend the prefix
+            const fp = path instanceof RegExp ? path : prefix + path;
+            const routeKey = method + " " + (path instanceof RegExp ? path.source : fp);
+            // Only check for duplicates on non-middleware routes
+            // Middleware (USE) can have duplicate paths, and different HTTP methods can share paths
+            if (method !== "USE" && usedRoutes.has(routeKey)) {
+                throw new Error(`Duplicate route [${method}] "${path instanceof RegExp ? path.source : fp}" detected in controller "${target.name}"`);
+            }
+            if (method !== "USE") {
+                usedRoutes.add(routeKey);
+            }
+            const methodName = methodResolve[method];
+            router[methodName](fp, (request, response, next) => __awaiter(this, void 0, void 0, function* () {
+                const result = yield fn.bind(controllerInstance)(request, response, next);
+                // Middleware (USE) should not send responses, just call next()
+                if (method === "USE") {
+                    return;
+                }
+                if (result instanceof ResponseEntity) {
+                    response
+                        .contentType("application/json")
+                        .status(result.getStatusCode())
+                        .set(result.getHeaders())
+                        .send(Sapling.serialize(result.getBody()));
+                    return;
+                }
+                if (result instanceof RedirectView) {
+                    response.redirect(result.getUrl());
+                    return;
+                }
+                if (!response.writableEnded) {
+                    response
+                        .status(404)
+                        .send(Html404ErrorPage(`Cannot ${methodName.toUpperCase()} ${path instanceof RegExp ? path.source : fp}`));
+                }
+            }));
+        }
+        _ControllerRegistry.set(targetClass, router);
+    };
+}

package/dist/src/annotation/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./controller";
+export * from "./injectable";
+export * from "./route";
+export * from "./middleware";

package/dist/src/annotation/index.js

@@ -0,0 +1,4 @@
+export * from "./controller";
+export * from "./injectable";
+export * from "./route";
+export * from "./middleware";

package/dist/src/annotation/injectable.d.ts

@@ -0,0 +1,25 @@
+import type { Class } from "../types";
+import { IterableWeakMap } from "../../lib/weakmap";
+export declare const _InjectableRegistry: WeakMap<Class<any>, any>;
+export declare const _InjectableDeps: IterableWeakMap<Class<any>, Class<any>[]>;
+/**
+ * Mark the class as an injectable to be handled by Sapling. The class can now be
+ * be injected into other classes, as well as allow the class to inject other `@Injectable` classes.
+ *
+ * @argument deps - An optional array to define any dependencies that this class may require.
+ */
+export declare function Injectable(deps?: Array<Class<any>>): ClassDecorator;
+/**
+ * Resolves and instantiates a class along with all of it's transitive dependencies.
+ *
+ * Uses topological sort (Kahn's algorithm) to ensure that the dependency graph is created
+ * in a correct order.
+ *
+ * When `resolve` is first called (usually during controller registration),
+ * it will compute the dependency graph of all `@Injectable` classes and instantiates
+ * them in the correct order.
+ *
+ * Subsequent calls to dependencies that have already been resolved are cached, so they will
+ * re-use the created singletons instead of re-instantiation.
+ */
+export declare function _resolve<T>(ctor: Class<T>): T;

package/dist/src/annotation/injectable.js

@@ -0,0 +1,69 @@
+import { IterableWeakMap } from "../../lib/weakmap";
+export const _InjectableRegistry = new WeakMap();
+export const _InjectableDeps = new IterableWeakMap();
+/**
+ * Mark the class as an injectable to be handled by Sapling. The class can now be
+ * be injected into other classes, as well as allow the class to inject other `@Injectable` classes.
+ *
+ * @argument deps - An optional array to define any dependencies that this class may require.
+ */
+export function Injectable(deps = []) {
+    return function (target) {
+        _InjectableRegistry.set(target, null);
+        _InjectableDeps.set(target, deps);
+    };
+}
+/**
+ * Resolves and instantiates a class along with all of it's transitive dependencies.
+ *
+ * Uses topological sort (Kahn's algorithm) to ensure that the dependency graph is created
+ * in a correct order.
+ *
+ * When `resolve` is first called (usually during controller registration),
+ * it will compute the dependency graph of all `@Injectable` classes and instantiates
+ * them in the correct order.
+ *
+ * Subsequent calls to dependencies that have already been resolved are cached, so they will
+ * re-use the created singletons instead of re-instantiation.
+ */
+export function _resolve(ctor) {
+    const inDegree = new Map();
+    const graph = new Map();
+    _InjectableDeps.forEach((deps, node) => {
+        inDegree.set(node, inDegree.get(node) || 0);
+        deps.forEach((dep) => {
+            inDegree.set(dep, inDegree.get(dep) || 0);
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            inDegree.set(node, inDegree.get(node) + 1);
+            if (!graph.has(dep))
+                graph.set(dep, []);
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            graph.get(dep).push(node);
+        });
+    });
+    const queue = [];
+    inDegree.forEach((deg, node) => {
+        if (deg === 0)
+            queue.push(node);
+    });
+    while (queue.length) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const current = queue.shift();
+        if (!_InjectableRegistry.get(current)) {
+            const deps = _InjectableDeps.get(current) || [];
+            const params = deps.map((dep) => _InjectableRegistry.get(dep));
+            const instance = new current(...params);
+            _InjectableRegistry.set(current, instance);
+        }
+        (graph.get(current) || []).forEach((neighbor) => {
+            var _a;
+            inDegree.set(neighbor, ((_a = inDegree.get(neighbor)) !== null && _a !== void 0 ? _a : 0) - 1);
+            if (inDegree.get(neighbor) === 0)
+                queue.push(neighbor);
+        });
+    }
+    if (!_InjectableRegistry.get(ctor)) {
+        throw new Error("Circular dependency detected or injectable not registered");
+    }
+    return _InjectableRegistry.get(ctor);
+}

package/dist/src/annotation/middleware.d.ts

@@ -0,0 +1,9 @@
+import { Controller } from "./controller";
+/**
+ * Used to define a middleware-only class.
+ *
+ * __NOTE:__ `@MiddlewareClass` works exactly the same as `@Controller`. As such, you
+ * can still register `@Route` and `@Middleware` methods, though you very well should not
+ * for the sake of semantics.
+ */
+export declare function MiddlewareClass(...args: Parameters<typeof Controller>): ClassDecorator;

package/dist/src/annotation/middleware.js

@@ -0,0 +1,11 @@
+import { Controller } from "./controller";
+/**
+ * Used to define a middleware-only class.
+ *
+ * __NOTE:__ `@MiddlewareClass` works exactly the same as `@Controller`. As such, you
+ * can still register `@Route` and `@Middleware` methods, though you very well should not
+ * for the sake of semantics.
+ */
+export function MiddlewareClass(...args) {
+    return Controller(...args);
+}

package/dist/src/annotation/route.d.ts

@@ -0,0 +1,47 @@
+import type { RouteDefinition, ExpressRouterMethodKey } from "../types";
+type OptionalStrOrRegExp = string | RegExp | undefined;
+/**
+ * Custom annotation that will store all routes inside of a map,
+ * which can then be used to initialize all the routes to the router.
+ */
+export declare function _Route({ method, path, }: {
+    method: ExpressRouterMethodKey;
+    path: OptionalStrOrRegExp;
+}): MethodDecorator;
+/**
+ * Register GET route on the given path (default "") for the given controller.
+ */
+export declare const GET: (path?: OptionalStrOrRegExp) => MethodDecorator;
+/**
+ * Register POST route on the given path (default "") for the given controller.
+ */
+export declare const POST: (path?: OptionalStrOrRegExp) => MethodDecorator;
+/**
+ * Register PUT route on the given path (default "") for the given controller.
+ */
+export declare const PUT: (path?: OptionalStrOrRegExp) => MethodDecorator;
+/**
+ * Register DELETE route on the given path (default "") for the given controller.
+ */
+export declare const DELETE: (path?: OptionalStrOrRegExp) => MethodDecorator;
+/**
+ * Register OPTIONS route on the given path (default "") for the given controller.
+ */
+export declare const OPTIONS: (path?: OptionalStrOrRegExp) => MethodDecorator;
+/**
+ * Register PATCH route on the given path (default "") for the given controller.
+ */
+export declare const PATCH: (path?: OptionalStrOrRegExp) => MethodDecorator;
+/**
+ * Register HEAD route on the given path (default "") for the given controller.
+ */
+export declare const HEAD: (path?: OptionalStrOrRegExp) => MethodDecorator;
+/**
+ * Register a middleware route on the given path (default "") for the given controller.
+ */
+export declare const Middleware: (path?: OptionalStrOrRegExp) => MethodDecorator;
+/**
+ * Given a class constructor, fetch all the routes attached.
+ */
+export declare function _getRoutes(ctor: Function): readonly RouteDefinition[];
+export {};

package/dist/src/annotation/route.js

@@ -0,0 +1,77 @@
+const _routeStore = new WeakMap();
+/**
+ * Custom annotation that will store all routes inside of a map,
+ * which can then be used to initialize all the routes to the router.
+ */
+export function _Route({ method, path = "", }) {
+    return (target, propertyKey) => {
+        var _a;
+        const ctor = target.constructor;
+        const list = (_a = _routeStore.get(ctor)) !== null && _a !== void 0 ? _a : [];
+        list.push({ method, path: path !== null && path !== void 0 ? path : "", fnName: String(propertyKey) });
+        _routeStore.set(ctor, list);
+    };
+}
+/**
+ * Register GET route on the given path (default "") for the given controller.
+ */
+export const GET = (path = "") => _Route({
+    method: "GET",
+    path,
+});
+/**
+ * Register POST route on the given path (default "") for the given controller.
+ */
+export const POST = (path = "") => _Route({
+    method: "POST",
+    path,
+});
+/**
+ * Register PUT route on the given path (default "") for the given controller.
+ */
+export const PUT = (path = "") => _Route({
+    method: "PUT",
+    path,
+});
+/**
+ * Register DELETE route on the given path (default "") for the given controller.
+ */
+export const DELETE = (path = "") => _Route({
+    method: "DELETE",
+    path,
+});
+/**
+ * Register OPTIONS route on the given path (default "") for the given controller.
+ */
+export const OPTIONS = (path = "") => _Route({
+    method: "OPTIONS",
+    path,
+});
+/**
+ * Register PATCH route on the given path (default "") for the given controller.
+ */
+export const PATCH = (path = "") => _Route({
+    method: "PATCH",
+    path,
+});
+/**
+ * Register HEAD route on the given path (default "") for the given controller.
+ */
+export const HEAD = (path = "") => _Route({
+    method: "HEAD",
+    path,
+});
+/**
+ * Register a middleware route on the given path (default "") for the given controller.
+ */
+export const Middleware = (path = "") => _Route({
+    method: "USE",
+    path,
+});
+/**
+ * Given a class constructor, fetch all the routes attached.
+ */
+export function _getRoutes(ctor) {
+    var _a;
+    return (_a = _routeStore.get(ctor)) !== null && _a !== void 0 ? _a : [];
+}

package/dist/src/enum/http.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Enum of every valid HTTP status code mapped to a specific enum member.
+ *
+ * @see {@link ResponseEntity}
+ */
+export declare enum HttpStatus {
+    CONTINUE = 100,
+    SWITCHING_PROTOCOLS = 101,
+    PROCESSING = 102,
+    EARLY_HINTS = 103,
+    OK = 200,
+    CREATED = 201,
+    ACCEPTED = 202,
+    NON_AUTHORITATIVE_INFORMATION = 203,
+    NO_CONTENT = 204,
+    RESET_CONTENT = 205,
+    PARTIAL_CONTENT = 206,
+    MULTI_STATUS = 207,
+    ALREADY_REPORTED = 208,
+    IM_USED = 226,
+    MULTIPLE_CHOICES = 300,
+    MOVED_PERMANENTLY = 301,
+    FOUND = 302,
+    SEE_OTHER = 303,
+    NOT_MODIFIED = 304,
+    TEMPORARY_REDIRECT = 307,
+    PERMANENT_REDIRECT = 308,
+    BAD_REQUEST = 400,
+    UNAUTHORIZED = 401,
+    PAYMENT_REQUIRED = 402,
+    FORBIDDEN = 403,
+    NOT_FOUND = 404,
+    METHOD_NOT_ALLOWED = 405,
+    NOT_ACCEPTABLE = 406,
+    PROXY_AUTHENTICATION_REQUIRED = 407,
+    REQUEST_TIMEOUT = 408,
+    CONFLICT = 409,
+    GONE = 410,
+    LENGTH_REQUIRED = 411,
+    PRECONDITION_FAILED = 412,
+    PAYLOAD_TOO_LARGE = 413,
+    URI_TOO_LONG = 414,
+    UNSUPPORTED_MEDIA_TYPE = 415,
+    REQUESTED_RANGE_NOT_SATISFIABLE = 416,
+    EXPECTATION_FAILED = 417,
+    I_AM_A_TEAPOT = 418,
+    UNPROCESSABLE_ENTITY = 422,
+    LOCKED = 423,
+    FAILED_DEPENDENCY = 424,
+    TOO_EARLY = 425,
+    UPGRADE_REQUIRED = 426,
+    PRECONDITION_REQUIRED = 428,
+    TOO_MANY_REQUESTS = 429,
+    REQUEST_HEADER_FIELDS_TOO_LARGE = 431,
+    UNAVAILABLE_FOR_LEGAL_REASONS = 451,
+    INTERNAL_SERVER_ERROR = 500,
+    NOT_IMPLEMENTED = 501,
+    BAD_GATEWAY = 502,
+    SERVICE_UNAVAILABLE = 503,
+    GATEWAY_TIMEOUT = 504,
+    HTTP_VERSION_NOT_SUPPORTED = 505,
+    VARIANT_ALSO_NEGOTIATES = 506,
+    INSUFFICIENT_STORAGE = 507,
+    LOOP_DETECTED = 508,
+    BANDWIDTH_LIMIT_EXCEEDED = 509,
+    NOT_EXTENDED = 510,
+    NETWORK_AUTHENTICATION_REQUIRED = 511
+}

package/dist/src/enum/http.js

@@ -0,0 +1,71 @@
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import {} from "../helper";
+/**
+ * Enum of every valid HTTP status code mapped to a specific enum member.
+ *
+ * @see {@link ResponseEntity}
+ */
+export var HttpStatus;
+(function (HttpStatus) {
+    HttpStatus[HttpStatus["CONTINUE"] = 100] = "CONTINUE";
+    HttpStatus[HttpStatus["SWITCHING_PROTOCOLS"] = 101] = "SWITCHING_PROTOCOLS";
+    HttpStatus[HttpStatus["PROCESSING"] = 102] = "PROCESSING";
+    HttpStatus[HttpStatus["EARLY_HINTS"] = 103] = "EARLY_HINTS";
+    HttpStatus[HttpStatus["OK"] = 200] = "OK";
+    HttpStatus[HttpStatus["CREATED"] = 201] = "CREATED";
+    HttpStatus[HttpStatus["ACCEPTED"] = 202] = "ACCEPTED";
+    HttpStatus[HttpStatus["NON_AUTHORITATIVE_INFORMATION"] = 203] = "NON_AUTHORITATIVE_INFORMATION";
+    HttpStatus[HttpStatus["NO_CONTENT"] = 204] = "NO_CONTENT";
+    HttpStatus[HttpStatus["RESET_CONTENT"] = 205] = "RESET_CONTENT";
+    HttpStatus[HttpStatus["PARTIAL_CONTENT"] = 206] = "PARTIAL_CONTENT";
+    HttpStatus[HttpStatus["MULTI_STATUS"] = 207] = "MULTI_STATUS";
+    HttpStatus[HttpStatus["ALREADY_REPORTED"] = 208] = "ALREADY_REPORTED";
+    HttpStatus[HttpStatus["IM_USED"] = 226] = "IM_USED";
+    HttpStatus[HttpStatus["MULTIPLE_CHOICES"] = 300] = "MULTIPLE_CHOICES";
+    HttpStatus[HttpStatus["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
+    HttpStatus[HttpStatus["FOUND"] = 302] = "FOUND";
+    HttpStatus[HttpStatus["SEE_OTHER"] = 303] = "SEE_OTHER";
+    HttpStatus[HttpStatus["NOT_MODIFIED"] = 304] = "NOT_MODIFIED";
+    HttpStatus[HttpStatus["TEMPORARY_REDIRECT"] = 307] = "TEMPORARY_REDIRECT";
+    HttpStatus[HttpStatus["PERMANENT_REDIRECT"] = 308] = "PERMANENT_REDIRECT";
+    HttpStatus[HttpStatus["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+    HttpStatus[HttpStatus["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+    HttpStatus[HttpStatus["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
+    HttpStatus[HttpStatus["FORBIDDEN"] = 403] = "FORBIDDEN";
+    HttpStatus[HttpStatus["NOT_FOUND"] = 404] = "NOT_FOUND";
+    HttpStatus[HttpStatus["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+    HttpStatus[HttpStatus["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
+    HttpStatus[HttpStatus["PROXY_AUTHENTICATION_REQUIRED"] = 407] = "PROXY_AUTHENTICATION_REQUIRED";
+    HttpStatus[HttpStatus["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
+    HttpStatus[HttpStatus["CONFLICT"] = 409] = "CONFLICT";
+    HttpStatus[HttpStatus["GONE"] = 410] = "GONE";
+    HttpStatus[HttpStatus["LENGTH_REQUIRED"] = 411] = "LENGTH_REQUIRED";
+    HttpStatus[HttpStatus["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
+    HttpStatus[HttpStatus["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
+    HttpStatus[HttpStatus["URI_TOO_LONG"] = 414] = "URI_TOO_LONG";
+    HttpStatus[HttpStatus["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
+    HttpStatus[HttpStatus["REQUESTED_RANGE_NOT_SATISFIABLE"] = 416] = "REQUESTED_RANGE_NOT_SATISFIABLE";
+    HttpStatus[HttpStatus["EXPECTATION_FAILED"] = 417] = "EXPECTATION_FAILED";
+    HttpStatus[HttpStatus["I_AM_A_TEAPOT"] = 418] = "I_AM_A_TEAPOT";
+    HttpStatus[HttpStatus["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+    HttpStatus[HttpStatus["LOCKED"] = 423] = "LOCKED";
+    HttpStatus[HttpStatus["FAILED_DEPENDENCY"] = 424] = "FAILED_DEPENDENCY";
+    HttpStatus[HttpStatus["TOO_EARLY"] = 425] = "TOO_EARLY";
+    HttpStatus[HttpStatus["UPGRADE_REQUIRED"] = 426] = "UPGRADE_REQUIRED";
+    HttpStatus[HttpStatus["PRECONDITION_REQUIRED"] = 428] = "PRECONDITION_REQUIRED";
+    HttpStatus[HttpStatus["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+    HttpStatus[HttpStatus["REQUEST_HEADER_FIELDS_TOO_LARGE"] = 431] = "REQUEST_HEADER_FIELDS_TOO_LARGE";
+    HttpStatus[HttpStatus["UNAVAILABLE_FOR_LEGAL_REASONS"] = 451] = "UNAVAILABLE_FOR_LEGAL_REASONS";
+    HttpStatus[HttpStatus["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+    HttpStatus[HttpStatus["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
+    HttpStatus[HttpStatus["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
+    HttpStatus[HttpStatus["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+    HttpStatus[HttpStatus["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
+    HttpStatus[HttpStatus["HTTP_VERSION_NOT_SUPPORTED"] = 505] = "HTTP_VERSION_NOT_SUPPORTED";
+    HttpStatus[HttpStatus["VARIANT_ALSO_NEGOTIATES"] = 506] = "VARIANT_ALSO_NEGOTIATES";
+    HttpStatus[HttpStatus["INSUFFICIENT_STORAGE"] = 507] = "INSUFFICIENT_STORAGE";
+    HttpStatus[HttpStatus["LOOP_DETECTED"] = 508] = "LOOP_DETECTED";
+    HttpStatus[HttpStatus["BANDWIDTH_LIMIT_EXCEEDED"] = 509] = "BANDWIDTH_LIMIT_EXCEEDED";
+    HttpStatus[HttpStatus["NOT_EXTENDED"] = 510] = "NOT_EXTENDED";
+    HttpStatus[HttpStatus["NETWORK_AUTHENTICATION_REQUIRED"] = 511] = "NETWORK_AUTHENTICATION_REQUIRED";
+})(HttpStatus || (HttpStatus = {}));

package/dist/src/enum/index.d.ts

@@ -0,0 +1 @@
+export * from "./http";

package/dist/src/enum/index.js

@@ -0,0 +1 @@
+export * from "./http";