@zenofolio/hyper-decor 0.0.3

package/dist/decorators/Middleware.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Middleware = void 0;
+require("reflect-metadata");
+const constants_1 = require("../__internals/constants");
+const stores_1 = __importDefault(require("../__internals/stores"));
+/**
+ * Middleware decorator to attach middleware to controllers, modules, and routes.
+ */
+const Middleware = (...middleware) => (Target, propertyKey, descriptor) => {
+    stores_1.default.define(constants_1.KEY_PARAMS_MIDDLEWARES, middleware, {
+        target: Target,
+        propertyKey,
+    });
+};
+exports.Middleware = Middleware;
+/**
+ * Exclude middleware from matching paths.
+ *
+ * @param expresiosn
+ * @param middleware
+ * @returns
+ */
+exports.Middleware.exclude = (expresiosn, middleware) => {
+    return (0, exports.Middleware)((req, res, next) => {
+        expresiosn = Array.isArray(expresiosn) ? expresiosn : [expresiosn];
+        const excluude = expresiosn.some((exp) => exp.test(req.path));
+        if (excluude)
+            return next();
+        return middleware(req, res, next);
+    });
+};
+/**
+ * Only run middleware on matching paths.
+ *
+ * @param expresiosn
+ * @param middleware
+ * @returns
+ */
+exports.Middleware.only = (expresiosn, middleware) => {
+    return (0, exports.Middleware)((req, res, next) => {
+        expresiosn = Array.isArray(expresiosn) ? expresiosn : [expresiosn];
+        const only = expresiosn.some((exp) => exp.test(req.path));
+        if (!only)
+            return next();
+        return middleware(req, res, next);
+    });
+};

package/dist/decorators/Pass.d.ts

@@ -0,0 +1,12 @@
+import { Request, Response } from "hyper-express";
+interface PassOptions {
+    (req: Request, res: Response): boolean | Promise<boolean>;
+}
+/**
+ * This method will pass all checks if the function returns true.
+ *
+ * @param options
+ * @returns
+ */
+export declare const Pass: (options: PassOptions) => ClassDecorator & MethodDecorator;
+export {};

package/dist/decorators/Pass.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pass = void 0;
+const who_helper_1 = __importDefault(require("../__internals/helpers/who.helper"));
+const NotPropertyException_1 = __importDefault(require("../exeptions/NotPropertyException"));
+const constants_1 = require("../__internals/constants");
+/**
+ * This method will pass all checks if the function returns true.
+ *
+ * @param options
+ * @returns
+ */
+const Pass = (options) => (target, propertyKey, descriptorOrIndex) => {
+    const { isProperty, isMethod } = (0, who_helper_1.default)(target, propertyKey, descriptorOrIndex);
+    if (isProperty) {
+        throw new NotPropertyException_1.default(`${target.constructor.name}.${propertyKey === null || propertyKey === void 0 ? void 0 : propertyKey.toString()}`, target);
+    }
+    if (isMethod) {
+        Reflect.defineMetadata(constants_1.KEY_PARAMS_PASS, options, target, propertyKey);
+    }
+    else {
+        Reflect.defineMetadata(constants_1.KEY_PARAMS_PASS, options, target);
+    }
+    return target;
+};
+exports.Pass = Pass;

package/dist/decorators/Role.d.ts

@@ -0,0 +1,6 @@
+import "reflect-metadata";
+import { RoleType } from "./types";
+/**
+ * Role decorator for setting role-based access control.
+ */
+export declare const Role: <T extends string = string>(roles: RoleType<T>) => (target: any, propertyKey?: any, descriptorOrIndex?: any) => void;

package/dist/decorators/Role.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Role = void 0;
+require("reflect-metadata");
+const constants_1 = require("../__internals/constants");
+const who_helper_1 = __importDefault(require("../__internals/helpers/who.helper"));
+const stores_1 = __importDefault(require("../__internals/stores"));
+const exeptions_1 = require("../exeptions");
+/**
+ * Role decorator for setting role-based access control.
+ */
+const Role = (roles) => (target, propertyKey, descriptorOrIndex) => {
+    const _roles = Array.isArray(roles) ? roles : [roles];
+    if (!_roles.length) {
+        exeptions_1.HyperException.throw(`Role decorator must have at least one role.`, "HyperException", {
+            target,
+            propertyKey,
+            descriptorOrIndex,
+        });
+    }
+    const { isProperty, isMethod } = (0, who_helper_1.default)(target, propertyKey, descriptorOrIndex);
+    if (isProperty) {
+        throw new Error(`Scope decorator cannot be used as parameter decorator in ${target.constructor.name}.${propertyKey}`);
+    }
+    const list = stores_1.default.list(constants_1.KEY_PARAMS_ROLE, {
+        target,
+        propertyKey,
+    });
+    list.set(..._roles);
+};
+exports.Role = Role;

package/dist/decorators/Routes.d.ts

@@ -0,0 +1,14 @@
+import "reflect-metadata";
+export declare const Get: (path?: string) => MethodDecorator & ClassDecorator;
+export declare const Post: (path?: string) => MethodDecorator & ClassDecorator;
+export declare const Put: (path?: string) => MethodDecorator & ClassDecorator;
+export declare const Delete: (path?: string) => MethodDecorator & ClassDecorator;
+export declare const Patch: (path?: string) => MethodDecorator & ClassDecorator;
+export declare const Options: (path?: string) => MethodDecorator & ClassDecorator;
+export declare const Head: (path?: string) => MethodDecorator & ClassDecorator;
+export declare const Trace: (path?: string) => MethodDecorator & ClassDecorator;
+export declare const Any: (path?: string) => MethodDecorator & ClassDecorator;
+export declare const All: (path?: string) => MethodDecorator & ClassDecorator;
+export declare const Connect: (path?: string) => MethodDecorator & ClassDecorator;
+export declare const WS: (path?: string) => MethodDecorator & ClassDecorator;
+export declare const Upgrade: (path?: string) => MethodDecorator & ClassDecorator;

package/dist/decorators/Routes.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Upgrade = exports.WS = exports.Connect = exports.All = exports.Any = exports.Trace = exports.Head = exports.Options = exports.Patch = exports.Delete = exports.Put = exports.Post = exports.Get = void 0;
+require("reflect-metadata");
+const routes_creator_1 = __importDefault(require("../__internals/creators/routes.creator"));
+exports.Get = (0, routes_creator_1.default)("get");
+exports.Post = (0, routes_creator_1.default)("post");
+exports.Put = (0, routes_creator_1.default)("put");
+exports.Delete = (0, routes_creator_1.default)("delete");
+exports.Patch = (0, routes_creator_1.default)("patch");
+exports.Options = (0, routes_creator_1.default)("options");
+exports.Head = (0, routes_creator_1.default)("head");
+exports.Trace = (0, routes_creator_1.default)("trace");
+exports.Any = (0, routes_creator_1.default)("any");
+exports.All = (0, routes_creator_1.default)("all");
+exports.Connect = (0, routes_creator_1.default)("connect");
+exports.WS = (0, routes_creator_1.default)("ws");
+exports.Upgrade = (0, routes_creator_1.default)("upgrade");

package/dist/decorators/Scope.d.ts

@@ -0,0 +1,6 @@
+import "reflect-metadata";
+import { ScopeType } from "./types";
+/**
+ * Scope decorator for defining access scopes.
+ */
+export declare const Scope: <T extends string = string>(scopes: ScopeType<T>) => ClassDecorator & MethodDecorator & ParameterDecorator;

package/dist/decorators/Scope.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scope = void 0;
+require("reflect-metadata");
+const constants_1 = require("../__internals/constants");
+const who_helper_1 = __importDefault(require("../__internals/helpers/who.helper"));
+const stores_1 = __importDefault(require("../__internals/stores"));
+/**
+ * Scope decorator for defining access scopes.
+ */
+const Scope = (scopes) => (target, propertyKey, descriptorOrIndex) => {
+    const { isProperty, isMethod } = (0, who_helper_1.default)(target, propertyKey, descriptorOrIndex);
+    if (isProperty) {
+        throw new Error(`Scope decorator cannot be used as parameter decorator in ${target.constructor.name}.${propertyKey}`);
+    }
+    const list = stores_1.default.list(constants_1.KEY_PARAMS_SCOPE, {
+        target,
+        propertyKey,
+    });
+    list.set(...(Array.isArray(scopes) ? scopes : [scopes]));
+};
+exports.Scope = Scope;

package/dist/decorators/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./HyperApp";
+export * from "./HyperModule";
+export * from "./HyperController";
+export * from "./Middleware";
+export * from "./Scope";
+export * from "./Role";
+export * from "./Routes";
+export * from "./types";
+export * from "./Http";
+export * from "./Pass";
+export * from "./File";

package/dist/decorators/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./HyperApp"), exports);
+__exportStar(require("./HyperModule"), exports);
+__exportStar(require("./HyperController"), exports);
+__exportStar(require("./Middleware"), exports);
+__exportStar(require("./Scope"), exports);
+__exportStar(require("./Role"), exports);
+__exportStar(require("./Routes"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./Http"), exports);
+__exportStar(require("./Pass"), exports);
+__exportStar(require("./File"), exports);

package/dist/decorators/types.d.ts

@@ -0,0 +1,89 @@
+import type { MiddlewareHandler, Request, Response, ServerConstructorOptions } from "hyper-express";
+export type Constructor<R extends any = any> = new (...args: any[]) => R;
+export type ConstructorDecorator = (target: Constructor, kay?: any, descriptor?: PropertyDescriptor) => Constructor;
+export type HyperClassDecorator<T> = (options?: T) => ConstructorDecorator;
+export type HyperMethodDecorator<T> = (options?: T) => (target: any, key?: any, descriptor?: PropertyDescriptor) => void;
+export interface LogSpaces {
+    controllers: boolean;
+    middleware: boolean;
+    routes: boolean;
+}
+export interface HyperAppMetadata {
+    name?: string;
+    version?: string;
+    description?: string;
+    author?: string;
+    license?: string;
+    prefix?: string;
+    logger?: (...args: any[]) => void;
+    logs?: LogSpaces;
+    modules: Constructor[];
+    imports?: Constructor[];
+    options?: ServerConstructorOptions;
+}
+export type HyperAppDecorator = (options?: HyperAppMetadata) => (target: Constructor) => Constructor;
+export type HyperModuleMetadata = {
+    path: string;
+    name?: string;
+    roles?: string[];
+    scopes?: string[];
+    modules?: Constructor[];
+    controllers?: Constructor[];
+    imports?: Constructor[];
+};
+export type HyperModuleDecorator = HyperClassDecorator<HyperModuleMetadata>;
+export type HyperControllerMetadata = {
+    path?: string;
+    roles?: string[];
+    scopes?: string[];
+    imports?: Constructor[];
+};
+export type HyperControllerDecorator = HyperClassDecorator<HyperControllerMetadata | string>;
+export type ParameterResolver = (req: Request, res: Response) => any | Promise<any>;
+export type HyperParamerMetadata = {
+    params: Record<string, {
+        index: number;
+        type: any;
+        key: string;
+        name: string;
+        method: string;
+        resolver: ParameterResolver;
+    }[]>;
+};
+export type HyperParamDecorator = (key: string) => (target: any, key: string, index: number) => void;
+export type RoleMap<T> = {
+    role: T;
+    description: string;
+    message?: string;
+};
+/**
+ * Type definition for Role decorator.
+ * It can accept a single role, an array of roles, or a function that evaluates roles dynamically.
+ */
+export type RoleType<T extends string = string> = T | T[] | RoleMap<T> | RoleMap<T>[];
+export type ScopeMap<T> = {
+    scope: T;
+    description: string;
+    message?: string;
+};
+/**
+ * Type definition for Scope decorator.
+ * It can accept a single scope or multiple scopes as an array of strings.
+ */
+export type ScopeType<T extends string = string> = T | T[] | ScopeMap<T> | ScopeMap<T>[];
+/**
+ * Type definition for Route metadata.
+ * Contains method, path, and handler function name.
+ */
+export interface RouteMetadata {
+    className: string;
+    method: string;
+    path: string;
+    propertyKey: string;
+    handler: (...args: any[]) => any;
+}
+/**
+ * Type definition for Middleware.
+ * Middleware can be a single handler or an array of handlers.
+ */
+export type MiddlewareType = MiddlewareHandler | MiddlewareHandler[];

package/dist/decorators/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/exeptions/DuplicateControllerPathException.d.ts

@@ -0,0 +1,14 @@
+import HyperException from "./HyperException";
+export default class DuplicateControllerPathException extends HyperException {
+    constructor(data: {
+        path: string;
+        current: {
+            module: string;
+            controller: string;
+        };
+        duplicate: {
+            module: string;
+            controller: string;
+        };
+    });
+}

package/dist/exeptions/DuplicateControllerPathException.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const HyperException_1 = __importDefault(require("./HyperException"));
+class DuplicateControllerPathException extends HyperException_1.default {
+    constructor(data) {
+        super(`Duplicate controller path: '${data.path}' in ${data.current.module}/${data.current.controller} and ${data.duplicate.module} controller: ${data.duplicate.controller}`, "DuplicateControllerPathException", data);
+    }
+}
+exports.default = DuplicateControllerPathException;

package/dist/exeptions/DuplicatedException.d.ts

@@ -0,0 +1,8 @@
+import HyperException from "./HyperException";
+export default class DuplicatedException extends HyperException {
+    constructor(data: {
+        path: string;
+        currentNameSpace: string;
+        duplicateNameSpace: string;
+    });
+}

package/dist/exeptions/DuplicatedException.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const HyperException_1 = __importDefault(require("./HyperException"));
+class DuplicatedException extends HyperException_1.default {
+    constructor(data) {
+        super(`Duplicate at path: '${data.path}' in ${data.currentNameSpace} and ${data.duplicateNameSpace}`, "DuplicatedException", data);
+    }
+}
+exports.default = DuplicatedException;

package/dist/exeptions/DuplicatedHandlerException.d.ts

@@ -0,0 +1,4 @@
+import HyperException from "./HyperException";
+export default class DuplicatedHandlerException extends HyperException {
+    constructor(message: string);
+}

package/dist/exeptions/DuplicatedHandlerException.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const HyperException_1 = __importDefault(require("./HyperException"));
+class DuplicatedHandlerException extends HyperException_1.default {
+    constructor(message) {
+        super(message, "DuplicateHandlerException");
+    }
+}
+exports.default = DuplicatedHandlerException;

package/dist/exeptions/HyperException.d.ts

@@ -0,0 +1,7 @@
+import { ExceptionType } from "./types";
+export default class HyperException extends Error {
+    code: ExceptionType;
+    additionalInfo: any;
+    constructor(message: string, code?: ExceptionType, additionalInfo?: any);
+    static throw(message: string, code?: ExceptionType, additionalInfo?: {}): void;
+}

package/dist/exeptions/HyperException.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class HyperException extends Error {
+    constructor(message, code = "HyperException", additionalInfo = {}) {
+        super(message);
+        this.code = code;
+        this.additionalInfo = additionalInfo;
+    }
+    static throw(message, code, additionalInfo = {}) {
+        throw new this(message, code, additionalInfo);
+    }
+}
+exports.default = HyperException;

package/dist/exeptions/HyperFileException.d.ts

@@ -0,0 +1,4 @@
+import HyperException from "./HyperException";
+export default class HyperFileException extends HyperException {
+    constructor(message: string, additional?: any);
+}

package/dist/exeptions/HyperFileException.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const HyperException_1 = __importDefault(require("./HyperException"));
+class HyperFileException extends HyperException_1.default {
+    constructor(message, additional) {
+        super(message, "HyperFileException", additional);
+    }
+}
+exports.default = HyperFileException;

package/dist/exeptions/MethodNotFountException.d.ts

@@ -0,0 +1,4 @@
+import HyperException from "./HyperException";
+export default class MethodNotFountException extends HyperException {
+    constructor(className: string, method: string, path: string);
+}

package/dist/exeptions/MethodNotFountException.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const HyperException_1 = __importDefault(require("./HyperException"));
+class MethodNotFountException extends HyperException_1.default {
+    constructor(className, method, path) {
+        super(`Method ${method} not exists in ${className} for path ${path}`, "MethodNotFountException");
+    }
+}
+exports.default = MethodNotFountException;

package/dist/exeptions/NotPropertyException.d.ts

@@ -0,0 +1,6 @@
+import HyperException from "./HyperException";
+export default class NotPropertyException extends HyperException {
+    namespace: string;
+    target: any;
+    constructor(namespace: string, target: any);
+}

package/dist/exeptions/NotPropertyException.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const HyperException_1 = __importDefault(require("./HyperException"));
+class NotPropertyException extends HyperException_1.default {
+    constructor(namespace, target) {
+        super(`This decorator cannot be used as a property decorator in ${namespace}`, "NotPropertyException", {
+            target,
+        });
+        this.namespace = namespace;
+        this.target = target;
+    }
+}
+exports.default = NotPropertyException;

package/dist/exeptions/NotRoleException.d.ts

@@ -0,0 +1,6 @@
+import HyperException from "./HyperException";
+export default class NotRoleException extends HyperException {
+    roles: string[];
+    requiredRoles: string[];
+    constructor(message?: string, roles?: string[], requiredRoles?: string[]);
+}

package/dist/exeptions/NotRoleException.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const HyperException_1 = __importDefault(require("./HyperException"));
+class NotRoleException extends HyperException_1.default {
+    constructor(message = `Has not Permission to access this resource`, roles = [], requiredRoles = []) {
+        super(message, "NotRoleException", {
+            roles,
+            requiredRoles,
+        });
+        this.roles = roles;
+        this.requiredRoles = requiredRoles;
+    }
+}
+exports.default = NotRoleException;

package/dist/exeptions/NotScopeException.d.ts

@@ -0,0 +1,7 @@
+import HyperException from "./HyperException";
+export default class NotScopeException extends HyperException {
+    message: string;
+    requestScopes: string[];
+    requiredScopes: string[];
+    constructor(message: string, requestScopes?: string[], requiredScopes?: string[]);
+}

package/dist/exeptions/NotScopeException.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const HyperException_1 = __importDefault(require("./HyperException"));
+class NotScopeException extends HyperException_1.default {
+    constructor(message, requestScopes = [], requiredScopes = []) {
+        super(message || `You don't have the required scopes to access this resource`, "NotScopeException", {
+            requestScopes,
+            requiredScopes,
+        });
+        this.message = message;
+        this.requestScopes = requestScopes;
+        this.requiredScopes = requiredScopes;
+    }
+}
+exports.default = NotScopeException;

package/dist/exeptions/WrongPlaceException.d.ts

@@ -0,0 +1,8 @@
+import HyperException from "./HyperException";
+export default class WrongPlaceException extends HyperException {
+    decorator: string;
+    as: string;
+    namespace: string;
+    target: any;
+    constructor(decorator: string, as: string, namespace: string, target: any);
+}

package/dist/exeptions/WrongPlaceException.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const HyperException_1 = __importDefault(require("./HyperException"));
+class WrongPlaceException extends HyperException_1.default {
+    constructor(decorator, as, namespace, target) {
+        super(`The decorator @${decorator} only can be used as a ${as} decorator. Error => ${namespace}`, "WrongPlaceException", {
+            decorator,
+            target,
+            namespace,
+            as,
+        });
+        this.decorator = decorator;
+        this.as = as;
+        this.namespace = namespace;
+        this.target = target;
+    }
+}
+exports.default = WrongPlaceException;

package/dist/exeptions/index.d.ts

@@ -0,0 +1,8 @@
+import DuplicatedHandlerException from "./DuplicatedHandlerException";
+import DuplicateControllerPathException from "./DuplicateControllerPathException";
+import HyperException from "./HyperException";
+import MethodNotFountException from "./MethodNotFountException";
+import NotRoleException from "./NotRoleException";
+import NotScopeException from "./NotScopeException";
+export type * from "./types";
+export { DuplicatedHandlerException, DuplicateControllerPathException as DuplicatedRouterException, HyperException, NotRoleException, NotScopeException, MethodNotFountException as MethodNotExists, };

package/dist/exeptions/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MethodNotExists = exports.NotScopeException = exports.NotRoleException = exports.HyperException = exports.DuplicatedRouterException = exports.DuplicatedHandlerException = void 0;
+const DuplicatedHandlerException_1 = __importDefault(require("./DuplicatedHandlerException"));
+exports.DuplicatedHandlerException = DuplicatedHandlerException_1.default;
+const DuplicateControllerPathException_1 = __importDefault(require("./DuplicateControllerPathException"));
+exports.DuplicatedRouterException = DuplicateControllerPathException_1.default;
+const HyperException_1 = __importDefault(require("./HyperException"));
+exports.HyperException = HyperException_1.default;
+const MethodNotFountException_1 = __importDefault(require("./MethodNotFountException"));
+exports.MethodNotExists = MethodNotFountException_1.default;
+const NotRoleException_1 = __importDefault(require("./NotRoleException"));
+exports.NotRoleException = NotRoleException_1.default;
+const NotScopeException_1 = __importDefault(require("./NotScopeException"));
+exports.NotScopeException = NotScopeException_1.default;

package/dist/exeptions/types.d.ts

@@ -0,0 +1 @@
+export type ExceptionType = "DuplicateControllerException" | "DuplicateHandlerException" | "DuplicateRouterException" | "HyperException" | "NotRoleException" | "NotScopeException" | "MethodNotFountException" | "DuplicateControllerPathException" | "DuplicateHandlerException" | "DuplicatedException" | "NotPropertyException" | "WrongPlaceException" | "HyperFileException" | "DpublicateModuleException";

package/dist/exeptions/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/extension.d.ts

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