raiton 3.0.2 → 3.1.0

package/source/core/guards.ts

@@ -0,0 +1,43 @@
+import {GuardDeclaration} from "../types";
+import {Logger} from "@protorians/logger";
+
+export class RaitonGuards {
+    protected static _map: Map<string, GuardDeclaration> = new Map();
+
+    static set(name: string, guard: GuardDeclaration): typeof this {
+        this._map.set(name, guard);
+        return this;
+    }
+
+    static get(name: string): GuardDeclaration | undefined {
+        return this._map.get(name);
+    }
+
+    static remove(name: string): typeof this {
+        this._map.delete(name);
+        return this;
+    }
+
+    static removeAll(): typeof this {
+        Logger.error('Removing all guards');
+        this._map.clear();
+        return this;
+    }
+
+    static enabled(name: string): boolean {
+        const guard = this.get(name);
+        return (!guard) ? false : guard.enabled;
+    }
+
+    static enable(name: string): typeof this {
+        const guard = this.get(name);
+        if(guard) guard.enabled = true;
+        return this;
+    }
+
+    static disable(name: string){
+        const guard = this.get(name);
+        if(guard) guard.enabled = false;
+        return this;
+    }
+}

package/source/core/hooks.ts

@@ -1,15 +1,15 @@
-import {HookName, HookHandler} from '../types'
+import {HookNameType, HookHandlerCallable} from '../types'
 
 export class HookStore {
-    private hooks = new Map<HookName, HookHandler[]>()
+    private hooks = new Map<HookNameType, HookHandlerCallable[]>()
 
-    add(name: HookName, handler: HookHandler) {
+    add(name: HookNameType, handler: HookHandlerCallable) {
         const list = this.hooks.get(name) ?? []
         list.push(handler)
         this.hooks.set(name, list)
     }
 
-    async run(name: HookName, ctx: any) {
+    async run(name: HookNameType, ctx: any) {
         const list = this.hooks.get(name)
         if (!list) return
 

package/source/core/injection/injection.ts

@@ -1,5 +1,5 @@
 import "reflect-metadata";
-import type {IConstructor, ContainerDefinitionInterface} from "../../types";
+import type {ConstructorType, ContainerDefinitionInterface} from "../../types";
 import {LifetimeEnum, TextUtility} from "@protorians/core";
 import {Logger} from "@protorians/logger";
 import {METADATA_KEYS} from "../../sdk/constants";
@@ -30,20 +30,21 @@ export class Injection {
     }
 
     static clear(): void {
+        Logger.error('Clearing injection container');
         this._classes.clear();
         this._instances.clear();
         this._dependents.clear();
         this._artifactPaths.clear();
     }
 
-    static normalizeName(name: string): string {
+    protected static normalizeName(name: string): string {
         const stableName = camelCase(name);
         return stableName[0].toLowerCase() + stableName.slice(1);
     }
 
     static registry(
         name: string,
-        construct: IConstructor,
+        construct: ConstructorType,
         lifetime: LifetimeEnum = LifetimeEnum.SINGLETON,
         scope?: Symbol
     ): typeof this {
@@ -54,7 +55,7 @@ export class Injection {
         return this;
     }
 
-    static updateConstruct(name: string, construct: IConstructor): typeof this {
+    static updateConstruct(name: string, construct: ConstructorType): typeof this {
         const name_ = this.normalizeName(name);
         this._classes.set(name_, {...this._classes.get(this.normalizeName(name))!, construct});
         return this;
@@ -208,7 +209,7 @@ export class Injection {
         this.clear();
     }
 
-    static resolve<T>(construct: IConstructor<T>): T {
+    static resolve<T>(construct: ConstructorType<T>): T {
         const metadata: ContainerDefinitionInterface = Reflect.getMetadata(METADATA_KEYS.CONTAINER, construct);
 
         if (!metadata)

package/source/core/plugins/plugin.ts

@@ -1,8 +1,8 @@
-import { Plugin, PluginFn } from '../../types'
+import { PluginInterface, PluginCallable } from '../../types'
 
 export function definePlugin(
-  setup: PluginFn,
+  setup: PluginCallable,
   name?: string
-): Plugin {
+): PluginInterface {
   return { setup, name }
 }

package/source/core/raiton.ts

@@ -1,11 +1,11 @@
-import {RaitonSignalMap, ThreadInterface} from "../types";
+import {RaitonSignalMapInterface, ThreadInterface} from "../types";
 import {ISignalStack, Signal} from "@protorians/core";
 
 
 export class Raiton {
     protected static _thread: ThreadInterface | undefined;
 
-    static readonly signals: ISignalStack<RaitonSignalMap> = new Signal.Stack<RaitonSignalMap>()
+    static readonly signals: ISignalStack<RaitonSignalMapInterface> = new Signal.Stack<RaitonSignalMapInterface>()
     static title: string = 'Protorians Raiton';
     static identifier: string = 'raiton';
 

package/source/core/router/route.ts

@@ -1,13 +1,13 @@
-import type {RouteDefinition} from '../../types/router'
+import type {RouteDefinitionInterface} from '../../types/router'
 
 export class Route {
     method: string
     path: string
     version?: string
-    handler: RouteDefinition['handler']
+    handler: RouteDefinitionInterface['handler']
     parameters: Record<string, string> = {}
 
-    constructor(def: RouteDefinition) {
+    constructor(def: RouteDefinitionInterface) {
         this.method = def.method
         this.path = def.path
         this.version = def.version

package/source/core/router/router.ts

@@ -1,4 +1,4 @@
-import {RouteHandler} from '../../types'
+import {RouteHandlerCallable} from '../../types'
 import {HttpMethod} from "../../sdk/enums";
 import {Route} from './route'
 import {RouteMatcher} from './matcher'
@@ -6,7 +6,7 @@ import {RouteMatcher} from './matcher'
 export class Router {
     private matcher = new RouteMatcher()
 
-    add(method: HttpMethod, path: string, handler: RouteHandler, version?: string) {
+    add(method: HttpMethod, path: string, handler: RouteHandlerCallable, version?: string) {
         const route = new Route({
             method,
             path,

package/source/core/server.ts

@@ -1,4 +1,4 @@
-import type {ServerInterface, ServerOptions} from "../types";
+import type {ServerInterface, ServerOptionsInterface} from "../types";
 
 
 export class Server implements ServerInterface {
@@ -14,12 +14,12 @@ export class Server implements ServerInterface {
     }
 
     constructor(
-        public readonly options: ServerOptions
+        public readonly options: ServerOptionsInterface
     ) {
         Server.instance = this;
     }
 
-    option<K extends keyof ServerOptions>(key: K): ServerOptions[K] {
+    option<K extends keyof ServerOptionsInterface>(key: K): ServerOptionsInterface[K] {
         return this.options[key];
     }
 

package/source/core/thread.ts

@@ -3,8 +3,8 @@ import type {
     RuntimeAdapterInterface,
     RuntimeServerInterface,
     ThreadInterface,
-    ThreadOptions,
-    ThreadSetupOptions,
+    ThreadOptionsInterface,
+    ThreadSetupOptionsInterface,
     ThreadWaitCallable,
 } from "../types";
 import {EventMessageEnum, RuntimeType} from "../sdk/enums";
@@ -37,7 +37,7 @@ export class RaitonThread implements ThreadInterface {
 
     constructor(
         public readonly builder: BuilderInterface,
-        protected _options: ThreadOptions = {}
+        protected _options: ThreadOptionsInterface = {}
     ) {
         this.appDir = process.cwd();
         RaitonThread.instance = this;
@@ -72,7 +72,7 @@ export class RaitonThread implements ThreadInterface {
         return null;
     }
 
-    public setup({application, runtime}: ThreadSetupOptions): this {
+    public setup({application, runtime}: ThreadSetupOptionsInterface): this {
         const defaultRuntime = typeof Bun !== 'undefined' ? RuntimeType.Bun : RuntimeType.Node;
         this.runtime = new Runtime(runtime || defaultRuntime);
         this.application = application;
@@ -106,7 +106,8 @@ export class RaitonThread implements ThreadInterface {
         await this.runtimeServer.listen(port, hostname)
         if (this.builder.source) await ControllerBuilder.scan(this.builder.source)
 
-        Logger.log(LBadge.info('Server Started'), `http://${displayHostname}:${port}${prefix ?? ''}`)
+        Logger.log(LBadge.info('Local access:'), `http://localhost:${port}${prefix ?? ''}`,)
+        Logger.log(LBadge.info('LAN access:'), `http://${displayHostname}:${port}${prefix ?? ''}`,)
         return this;
     }
 }

package/source/sdk/artifacts.ts

@@ -1,6 +1,6 @@
 import {Injection} from "../core/injection";
 import {Logger} from "@protorians/logger";
-import type {IConstructor} from "../types";
+import type {ConstructorType} from "../types";
 import {Raiton} from "../core/raiton";
 import {isArtifact, isControllerArtifact} from "./utilities";
 
@@ -59,7 +59,7 @@ export class Artifacts {
 
             if (typeof name === 'string' && Injection.has(name)) {
                 if (filename) Injection.registerArtifactPath(name, filename);
-                Injection.updateConstruct(name, mod as IConstructor)
+                Injection.updateConstruct(name, mod as ConstructorType)
 
                 const dependents = Injection.getDependents(name);
                 for (const dependent of dependents) {

package/source/sdk/decorators/guard.decorator.ts

@@ -0,0 +1,23 @@
+import {GuardOptions} from "../../types";
+import {Middleware} from "./middleware.decorator";
+import {RaitonGuards} from "../../core/guards";
+import {HttpStatus} from "../enums";
+
+export function createGuardDecoration({name, handler}: GuardOptions) {
+    return Middleware(async ({next, context}) => {
+        const guard = RaitonGuards.get(name);
+
+        if (!guard) RaitonGuards.set(name, {name, handler, enabled: true})
+        if (guard && !guard.enabled) return next();
+
+        const response = await handler({context, next})
+
+        if (response) return next()
+
+        context.reply.status(HttpStatus.FORBIDDEN)
+        return context.reply.send({
+            error: true,
+            message: 'Forbidden'
+        });
+    });
+}

package/source/sdk/decorators/index.ts

@@ -2,4 +2,5 @@ export * from "./controllable.decorator"
 export * from "./middleware.decorator"
 export * from "./routable.decorator"
 export * from "./parametrable"
-export * from "./injection.decorator"
+export * from "./injection.decorator"
+export * from "./guard.decorator"

package/source/sdk/decorators/injection.decorator.ts

@@ -1,5 +1,5 @@
 import "reflect-metadata";
-import type {IConstructor} from "../../types/contruct";
+import type {ConstructorType} from "../../types/contruct";
 import {Injection} from "../../core/injection";
 import {LifetimeEnum} from "@protorians/core";
 import {Logger} from "@protorians/logger";
@@ -7,7 +7,7 @@ import {METADATA_KEYS} from "../constants";
 
 
 export function Injectable(lifetime?: LifetimeEnum, name?: string, scope?: any) {
-    return function <T extends IConstructor>(target: T) {
+    return function <T extends ConstructorType>(target: T) {
         const metadata = {
             name: name || target.name,
             construct: target,

package/source/sdk/decorators/parametrable.ts

@@ -1,8 +1,8 @@
 import "reflect-metadata";
-import type {Context, ParamMetaInterface} from "../../types";
+import type {ContextInterface, ParamMetaInterface} from "../../types";
 import {METADATA_KEYS, Parametrable} from "..";
 
-function createRouteParametrableDecorator(type: ParamMetaInterface['type'], callable?: (context: Context) => any) {
+function createRouteParametrableDecorator(type: ParamMetaInterface['type'], callable?: (context: ContextInterface) => any) {
     return (key?: string) => {
         return (target: any, propertyKey: string, index: number) => {
             const params = Reflect.getMetadata(METADATA_KEYS.ROUTE_PARAMETERS, target.constructor) || {}

package/source/sdk/encryption.ts

@@ -2,7 +2,7 @@ import crypto from "node:crypto";
 import argon2, {Options} from "argon2";
 import {HashAlgoEnum, PasswordAlgoEnum} from "./enums";
 import bcrypt from "bcrypt";
-import {IDerivationOptions, IEncryptionResult, IScryptOptions} from "../types";
+import {DerivationOptionsInterface, EncryptionResultType, ScryptOptionsInterface} from "../types";
 
 export class Encryption {
     static get algos() {
@@ -24,7 +24,7 @@ export class Encryption {
         return this.make(value).then(result => result === hash);
     }
 
-    async make(value: string, options?: IDerivationOptions | IScryptOptions): Promise<IEncryptionResult> {
+    async make(value: string, options?: DerivationOptionsInterface | ScryptOptionsInterface): Promise<EncryptionResultType> {
         if (!value) {
             throw new Error('Value cannot be empty');
         }
@@ -45,9 +45,9 @@ export class Encryption {
             case HashAlgoEnum.SHA3_512:
                 return this.sha3_512(value);
             case HashAlgoEnum.PBKDF2:
-                return this.pbkdf2(value, options as IDerivationOptions | undefined);
+                return this.pbkdf2(value, options as DerivationOptionsInterface | undefined);
             case HashAlgoEnum.SCRYPT:
-                return this.scrypt(value, options as IScryptOptions | undefined);
+                return this.scrypt(value, options as ScryptOptionsInterface | undefined);
             case HashAlgoEnum.ARGON2ID:
             case HashAlgoEnum.BCRYPT:
                 return this.password(value);
@@ -56,35 +56,35 @@ export class Encryption {
         }
     }
 
-    protected sha256(value: string): IEncryptionResult {
+    protected sha256(value: string): EncryptionResultType {
         return crypto.createHash("sha256").update(value).digest("hex");
     }
 
-    protected sha512(value: string): IEncryptionResult {
+    protected sha512(value: string): EncryptionResultType {
         return crypto.createHash("sha512").update(value).digest("hex");
     }
 
-    protected md5(value: string): IEncryptionResult {
+    protected md5(value: string): EncryptionResultType {
         return crypto.createHash("md5").update(value).digest("hex");
     }
 
-    protected ripemd160(value: string): IEncryptionResult {
+    protected ripemd160(value: string): EncryptionResultType {
         return crypto.createHash("ripemd160").update(value).digest("hex");
     }
 
-    protected blake2b(value: string): IEncryptionResult {
+    protected blake2b(value: string): EncryptionResultType {
         return crypto.createHash("blake2b512").update(value).digest("hex");
     }
 
-    protected sha3_256(value: string): IEncryptionResult {
+    protected sha3_256(value: string): EncryptionResultType {
         return crypto.createHash("sha3-256").update(value).digest("hex");
     }
 
-    protected sha3_512(value: string): IEncryptionResult {
+    protected sha3_512(value: string): EncryptionResultType {
         return crypto.createHash("sha3-512").update(value).digest("hex");
     }
 
-    protected pbkdf2(value: string, options?: IDerivationOptions): IEncryptionResult {
+    protected pbkdf2(value: string, options?: DerivationOptionsInterface): EncryptionResultType {
         const {salt, iterations, keylen, digest} = options || {};
         const usedSalt = salt ?? crypto.randomBytes(16).toString("hex");
         const usedIterations = iterations ?? 100_000;
@@ -96,8 +96,8 @@ export class Encryption {
         return `pbkdf2$${usedDigest}$${usedIterations}$${usedSalt}$${derived}`;
     }
 
-    protected scrypt(value: string, options?: IScryptOptions): IEncryptionResult {
-        const {salt, keylen, cost, blockSize, parallelization} = options || {} as IScryptOptions;
+    protected scrypt(value: string, options?: ScryptOptionsInterface): EncryptionResultType {
+        const {salt, keylen, cost, blockSize, parallelization} = options || {} as ScryptOptionsInterface;
         const usedSalt = salt ?? crypto.randomBytes(16).toString("hex");
         const usedKeylen = keylen ?? 64;
         const usedCost = cost ?? 16384; // N
@@ -120,7 +120,7 @@ export class Encryption {
 
     async password(value: string, options?: (Options & {
         raw?: boolean
-    }) | (string | number) | undefined): Promise<IEncryptionResult> {
+    }) | (string | number) | undefined): Promise<EncryptionResultType> {
         switch (this.algo) {
             case HashAlgoEnum.ARGON2ID: {
                 return await argon2.hash(value, {

package/source/sdk/env.ts

@@ -1,9 +1,9 @@
-import {IGenericValue} from "../types/generic";
+import {GenericValueType} from "../types/generic";
 import {getType} from "./utilities";
 
-export function env<T>(key: string, type?: IGenericValue): T | undefined {
+export function env<T>(key: string, type?: GenericValueType): T | undefined {
     const value = process.env[key];
-    type = type || getType(value) as IGenericValue;
+    type = type || getType(value) as GenericValueType;
 
     if (value) {
         switch (type) {
@@ -28,10 +28,10 @@ export function env<T>(key: string, type?: IGenericValue): T | undefined {
     return undefined;
 }
 
-export function envGroup(key: string): Record<string, IGenericValue | undefined> {
+export function envGroup(key: string): Record<string, GenericValueType | undefined> {
     const filtered = Object.entries(process.env)
         .filter(([index]) => key.startsWith(index))
-    const gen: Record<string, IGenericValue | undefined> = {}
+    const gen: Record<string, GenericValueType | undefined> = {}
 
     for (const [index, value] of filtered)
         gen[index] = env(value as any, undefined)

package/source/sdk/plugins/body-parser.plugin.ts

@@ -1,13 +1,13 @@
-import type {MiddlewareParameters, Plugin} from "../../types";
+import type {MiddlewareParametersInterface, PluginInterface} from "../../types";
 import {RequestContext} from "../../core/context";
 import {Logger} from "@protorians/logger";
 import {tryParseJson} from "../utilities/json.util";
 
-export function bodyParserPlugin(): Plugin {
+export function bodyParserPlugin(): PluginInterface {
     return {
         name: 'body-parser-plugin',
         setup: (scope) => {
-            scope.use(async ({context, next}: MiddlewareParameters) => {
+            scope.use(async ({context, next}: MiddlewareParametersInterface) => {
                 const contentType = context.req.headers.get('content-type') || '';
 
                 if (context.req.body && !context.state.bodyParsed) {

package/source/sdk/plugins/security/body-limit.ts

@@ -1,10 +1,10 @@
 import {definePlugin} from "../../../core/plugins";
-import {MiddlewareParameters} from "../../../types";
+import {MiddlewareParametersInterface} from "../../../types";
 
 
 export const secureBodyLimit = (maxBytes = 1_000_000) =>
   definePlugin((scope) => {
-    scope.use(async ({context, next}: MiddlewareParameters) => {
+    scope.use(async ({context, next}: MiddlewareParametersInterface) => {
       const len = Number(
         context.req.headers.get('content-length') ?? 0
       )

package/source/sdk/plugins/security/cors.ts

@@ -1,5 +1,5 @@
 import {definePlugin} from "../../../core/plugins";
-import {Context, MiddlewareParameters, NextCallable} from "../../../types";
+import {ContextInterface, MiddlewareParametersInterface, MiddlewareNextCallable} from "../../../types";
 
 export interface CorsOptions {
     origin?: string | string[]
@@ -9,7 +9,7 @@ export interface CorsOptions {
 
 export const secureCors = (opts: CorsOptions = {}) =>
     definePlugin((scope) => {
-        scope.use(async ({context, next}: MiddlewareParameters) => {
+        scope.use(async ({context, next}: MiddlewareParametersInterface) => {
             const origin = context.req.headers.get('origin')
 
             if (opts.origin) {

package/source/sdk/plugins/security/headers.ts

@@ -1,9 +1,9 @@
 import {definePlugin} from "../../../core/plugins";
-import {Context, MiddlewareParameters, NextCallable} from "../../../types";
+import {ContextInterface, MiddlewareParametersInterface, MiddlewareNextCallable} from "../../../types";
 
 
 export const secureHeaders = definePlugin((scope) => {
-  scope.use(async ({context, next}: MiddlewareParameters) => {
+  scope.use(async ({context, next}: MiddlewareParametersInterface) => {
     context.reply.header('X-Content-Type-Options', 'nosniff')
     context.reply.header('X-Frame-Options', 'DENY')
     context.reply.header('Referrer-Policy', 'no-referrer')

package/source/sdk/plugins/security/method-guard.ts

@@ -1,10 +1,10 @@
 import {definePlugin} from "../../../core/plugins";
-import {Context, MiddlewareParameters, NextCallable} from "../../../types";
+import {ContextInterface, MiddlewareParametersInterface, MiddlewareNextCallable} from "../../../types";
 
 
 export const secureMethodGuard = (allowed: string[]) =>
   definePlugin((scope) => {
-    scope.use(async ({context, next}: MiddlewareParameters) => {
+    scope.use(async ({context, next}: MiddlewareParametersInterface) => {
       if (!allowed.includes(context.req.method)) {
         context.reply.status(405)
         return context.send({ error: 'Method not allowed' })

package/source/sdk/plugins/security/rate-limit.ts

@@ -1,5 +1,5 @@
 import {definePlugin} from "../../../core/plugins";
-import {Context, MiddlewareParameters, NextCallable} from "../../../types";
+import {ContextInterface, MiddlewareParametersInterface, MiddlewareNextCallable} from "../../../types";
 
 
 export interface RateLimitOptions {
@@ -16,7 +16,7 @@ export const secureRateLimit = (
         const windowMs = opts.windowMs ?? 60_000
         const max = opts.max ?? 100
 
-        scope.use(async ({context, next}: MiddlewareParameters) => {
+        scope.use(async ({context, next}: MiddlewareParametersInterface) => {
             const ip =
                 context.req.remoteAddress ?? 'unknown'
             const now = Date.now()

package/source/sdk/utilities/utilities.util.ts

@@ -1,6 +1,6 @@
-import {IGenericValueType} from "../../types";
+import {GenericValuesType} from "../../types";
 
-export function getType(value: any): IGenericValueType {
+export function getType(value: any): GenericValuesType {
     if (typeof value === "string") return "string";
     if (typeof value === "boolean") return "boolean";
     if (typeof value === "bigint") return "bigInt";

package/source/types/application.ts

@@ -1,6 +1,6 @@
 import {HttpMethod} from "../sdk";
 
-export interface ApplicationConfig {
+export interface ApplicationConfigInterface {
     workdir?: string;
     hostname?: string;
     port?: number;
@@ -12,13 +12,13 @@ export interface ApplicationConfig {
 }
 
 export interface ApplicationInterface {
-    readonly config: ApplicationConfig;
+    readonly config: ApplicationConfigInterface;
 
     get hostname(): string;
 
-    setOption<K extends keyof ApplicationConfig>(key: K, value: ApplicationConfig[K]): this;
+    setOption<K extends keyof ApplicationConfigInterface>(key: K, value: ApplicationConfigInterface[K]): this;
 
-    setOptions(options: ApplicationConfig): this;
+    setOptions(options: ApplicationConfigInterface): this;
 
     register(plugin: any): this;
 

package/source/types/artifact.ts

@@ -1,44 +1,3 @@
-export interface ArtifactEntry {
-    id: string;
-    timestamp: Date;
-    size: number;
-}
-
-export interface ArtifactsConfig {
+export interface ArtifactsConfigInterface {
     types: string[]
-}
-
-// export type ArtifactDecoratorHandler = () => void;
-
-// export interface ArtifactDecorator {
-//     syntax: RegExp;
-//     handler: ArtifactDecoratorHandler;
-// }
-
-// export interface ArtifactOptions {
-//     readonly artifact: string;
-//     readonly provider: string;
-//     readonly decorator: ArtifactDecorator;
-//     verbose?: boolean;
-// }
-
-// export interface ArtifactInterface {
-//     readonly options: ArtifactOptions;
-//     readonly directory: string;
-//     readonly file: string;
-//     readonly workdir: string;
-//
-//     get files(): string[];
-//
-//     get extensions(): string[];
-//
-//     scan(): string[];
-//
-//     generate(): boolean;
-// }
-
-// export interface ArtifactEntry {
-//     vendor: string;
-//     decorator: string;
-//     pattern: string;
-// }
+}

package/source/types/builder.ts

@@ -1,19 +1,19 @@
 import {WatchEventType} from "node:fs";
 
-export interface BuildCommandOptions {
+export interface BuildCommandOptionsInterface {
     develop?: boolean;
     bootstrap?: boolean;
 }
 
-export interface BuilderConfig {
+export interface BuilderConfigInterface {
     development?: boolean;
 }
 
-export type BuilderBootCallable = (builder: BuilderInterface) => Promise<void>
+export type BuilderBootCallableType = (builder: BuilderInterface) => Promise<void>
 
 export interface BuilderInterface {
     readonly workdir: string;
-    readonly options: BuilderConfig;
+    readonly options: BuilderConfigInterface;
     // readonly signal: ISignalStack<BuilderSignalMap>;
 
     // get context(): BuildContext<BuildOptions> | null;
@@ -36,7 +36,7 @@ export interface BuilderInterface {
 }
 
 
-export interface BuilderHMRDeclaration {
+export interface BuilderHMRDeclarationInterface {
     filename: string;
     timestamp?: number;
     version?: number;

package/source/types/config.ts

@@ -1,7 +1,7 @@
-import type {ArtifactsConfig} from "./artifact";
+import type {ArtifactsConfigInterface} from "./artifact";
 
-export interface Configurable {
+export interface ConfigurableInterface {
     rootDir: string;
     version: string;
-    artifacts?: ArtifactsConfig
+    artifacts?: ArtifactsConfigInterface
 }