@expressots/adapter-express 1.8.2 → 3.0.0-beta.2

package/lib/cjs/types/di/di.interfaces.d.ts

@@ -0,0 +1,289 @@
+export declare enum FactoryType {
+    DynamicValue = "toDynamicValue",
+    Factory = "toFactory",
+    Provider = "toProvider"
+}
+declare namespace interfaces {
+    export type DynamicValue<T> = (context: interfaces.Context) => T | Promise<T>;
+    export type ContainerResolution<T> = T | Promise<T> | Array<T | Promise<T>>;
+    type AsyncCallback<TCallback> = TCallback extends (...args: infer TArgs) => infer TResult ? (...args: TArgs) => Promise<TResult> : never;
+    export type BindingScope = "Singleton" | "Transient" | "Request";
+    export type BindingType = "ConstantValue" | "Constructor" | "DynamicValue" | "Factory" | "Function" | "Instance" | "Invalid" | "Provider";
+    export type TargetType = "ConstructorArgument" | "ClassProperty" | "Variable";
+    export interface BindingScopeEnum {
+        Request: interfaces.BindingScope;
+        Singleton: interfaces.BindingScope;
+        Transient: interfaces.BindingScope;
+    }
+    export interface BindingTypeEnum {
+        ConstantValue: interfaces.BindingType;
+        Constructor: interfaces.BindingType;
+        DynamicValue: interfaces.BindingType;
+        Factory: interfaces.BindingType;
+        Function: interfaces.BindingType;
+        Instance: interfaces.BindingType;
+        Invalid: interfaces.BindingType;
+        Provider: interfaces.BindingType;
+    }
+    export interface TargetTypeEnum {
+        ConstructorArgument: interfaces.TargetType;
+        ClassProperty: interfaces.TargetType;
+        Variable: interfaces.TargetType;
+    }
+    export type Newable<T> = new (...args: Array<unknown>) => T;
+    export type Instance<T> = T & Record<string, () => void>;
+    export interface Abstract<T> {
+        prototype: T;
+    }
+    export type ServiceIdentifier<T = unknown> = string | symbol | Newable<T> | Abstract<T>;
+    export interface Clonable<T> {
+        clone(): T;
+    }
+    export type BindingActivation<T = unknown> = (context: interfaces.Context, injectable: T) => T | Promise<T>;
+    export type BindingDeactivation<T = unknown> = (injectable: T) => void | Promise<void>;
+    export interface Binding<TActivated = unknown> extends Clonable<Binding<TActivated>> {
+        id: number;
+        moduleId: ContainerModuleBase["id"];
+        activated: boolean;
+        serviceIdentifier: ServiceIdentifier<TActivated>;
+        constraint: ConstraintFunction;
+        dynamicValue: DynamicValue<TActivated> | null;
+        scope: BindingScope;
+        type: BindingType;
+        implementationType: Newable<TActivated> | TActivated | null;
+        factory: FactoryCreator<unknown> | null;
+        provider: ProviderCreator<unknown> | null;
+        onActivation: BindingActivation<TActivated> | null;
+        onDeactivation: BindingDeactivation<TActivated> | null;
+        cache: null | TActivated | Promise<TActivated>;
+    }
+    export type SimpleFactory<T, U extends Array<unknown> = Array<unknown>> = (...args: U) => T;
+    export type MultiFactory<T, U extends Array<unknown> = Array<unknown>, V extends Array<unknown> = Array<unknown>> = (...args: U) => SimpleFactory<T, V>;
+    export type Factory<T, U extends Array<unknown> = Array<unknown>, V extends Array<unknown> = Array<unknown>> = SimpleFactory<T, U> | MultiFactory<T, U, V>;
+    export type FactoryCreator<T, U extends Array<unknown> = Array<unknown>, V extends Array<unknown> = Array<unknown>> = (context: Context) => Factory<T, U, V>;
+    export type AutoNamedFactory<T> = SimpleFactory<T, [string]>;
+    export type AutoFactory<T> = SimpleFactory<T, []>;
+    export type FactoryTypeFunction<T = unknown> = (context: interfaces.Context) => T | Promise<T>;
+    export interface FactoryDetails {
+        factoryType: FactoryType;
+        factory: FactoryTypeFunction | null;
+    }
+    export type Provider<T> = (...args: Array<unknown>) => ((...args: Array<unknown>) => Promise<T>) | Promise<T>;
+    export type ProviderCreator<T> = (context: Context) => Provider<T>;
+    export interface NextArgs<T = unknown> {
+        avoidConstraints: boolean;
+        contextInterceptor: (contexts: Context) => Context;
+        isMultiInject: boolean;
+        targetType: TargetType;
+        serviceIdentifier: interfaces.ServiceIdentifier<T>;
+        key?: string | number | symbol | undefined;
+        value?: unknown;
+    }
+    export type Next = (args: NextArgs) => unknown | Array<unknown>;
+    export type Middleware = (next: Next) => Next;
+    export type ContextInterceptor = (context: interfaces.Context) => interfaces.Context;
+    export interface Context {
+        id: number;
+        container: Container;
+        plan: Plan;
+        currentRequest: Request;
+        addPlan(plan: Plan): void;
+        setCurrentRequest(request: Request): void;
+    }
+    export type MetadataOrMetadataArray = Metadata | Array<Metadata>;
+    export interface Metadata<TValue = unknown> {
+        key: string | number | symbol;
+        value: TValue;
+    }
+    export interface Plan {
+        parentContext: Context;
+        rootRequest: Request;
+    }
+    export interface QueryableString {
+        startsWith(searchString: string): boolean;
+        endsWith(searchString: string): boolean;
+        contains(searchString: string): boolean;
+        equals(compareString: string): boolean;
+        value(): string;
+    }
+    export type ResolveRequestHandler = (request: interfaces.Request) => unknown;
+    export type RequestScope = Map<unknown, unknown>;
+    export interface Request {
+        id: number;
+        serviceIdentifier: ServiceIdentifier;
+        parentContext: Context;
+        parentRequest: Request | null;
+        childRequests: Array<Request>;
+        target: Target;
+        bindings: Array<Binding<unknown>>;
+        requestScope: RequestScope | null;
+        addChildRequest(serviceIdentifier: ServiceIdentifier, bindings: Binding<unknown> | Array<Binding<unknown>>, target: Target): Request;
+    }
+    export interface Target {
+        id: number;
+        serviceIdentifier: ServiceIdentifier;
+        type: TargetType;
+        name: QueryableString;
+        identifier: string | symbol;
+        metadata: Array<Metadata>;
+        getNamedTag(): interfaces.Metadata<string> | null;
+        getCustomTags(): Array<interfaces.Metadata> | null;
+        hasTag(key: string | number | symbol): boolean;
+        isArray(): boolean;
+        matchesArray(name: interfaces.ServiceIdentifier): boolean;
+        isNamed(): boolean;
+        isTagged(): boolean;
+        isOptional(): boolean;
+        matchesNamedTag(name: string): boolean;
+        matchesTag(key: string | number | symbol): (value: unknown) => boolean;
+    }
+    export interface ContainerOptions {
+        autoBindInjectable?: boolean;
+        defaultScope?: BindingScope | undefined;
+        skipBaseClassChecks?: boolean;
+    }
+    export interface Container {
+        id: number;
+        parent: Container | null;
+        options: ContainerOptions;
+        bind<T>(serviceIdentifier: ServiceIdentifier<T>): BindingToSyntax<T>;
+        rebind<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): interfaces.BindingToSyntax<T>;
+        rebindAsync<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): Promise<interfaces.BindingToSyntax<T>>;
+        unbind(serviceIdentifier: ServiceIdentifier): void;
+        unbindAsync(serviceIdentifier: interfaces.ServiceIdentifier): Promise<void>;
+        unbindAll(): void;
+        unbindAllAsync(): Promise<void>;
+        isBound(serviceIdentifier: ServiceIdentifier): boolean;
+        isCurrentBound<T>(serviceIdentifier: ServiceIdentifier<T>): boolean;
+        isBoundNamed(serviceIdentifier: ServiceIdentifier, named: string | number | symbol): boolean;
+        isBoundTagged(serviceIdentifier: ServiceIdentifier, key: string | number | symbol, value: unknown): boolean;
+        get<T>(serviceIdentifier: ServiceIdentifier<T>): T;
+        getNamed<T>(serviceIdentifier: ServiceIdentifier<T>, named: string | number | symbol): T;
+        getTagged<T>(serviceIdentifier: ServiceIdentifier<T>, key: string | number | symbol, value: unknown): T;
+        getAll<T>(serviceIdentifier: ServiceIdentifier<T>): Array<T>;
+        getAllTagged<T>(serviceIdentifier: ServiceIdentifier<T>, key: string | number | symbol, value: unknown): Array<T>;
+        getAllNamed<T>(serviceIdentifier: ServiceIdentifier<T>, named: string | number | symbol): Array<T>;
+        getAsync<T>(serviceIdentifier: ServiceIdentifier<T>): Promise<T>;
+        getNamedAsync<T>(serviceIdentifier: ServiceIdentifier<T>, named: string | number | symbol): Promise<T>;
+        getTaggedAsync<T>(serviceIdentifier: ServiceIdentifier<T>, key: string | number | symbol, value: unknown): Promise<T>;
+        getAllAsync<T>(serviceIdentifier: ServiceIdentifier<T>): Promise<Array<T>>;
+        getAllTaggedAsync<T>(serviceIdentifier: ServiceIdentifier<T>, key: string | number | symbol, value: unknown): Promise<Array<T>>;
+        getAllNamedAsync<T>(serviceIdentifier: ServiceIdentifier<T>, named: string | number | symbol): Promise<Array<T>>;
+        onActivation<T>(serviceIdentifier: ServiceIdentifier<T>, onActivation: BindingActivation<T>): void;
+        onDeactivation<T>(serviceIdentifier: ServiceIdentifier<T>, onDeactivation: BindingDeactivation<T>): void;
+        resolve<T>(constructorFunction: interfaces.Newable<T>): T;
+        load(...modules: Array<ContainerModule>): void;
+        loadAsync(...modules: Array<AsyncContainerModule>): Promise<void>;
+        unload(...modules: Array<ContainerModuleBase>): void;
+        unloadAsync(...modules: Array<ContainerModuleBase>): Promise<void>;
+        applyCustomMetadataReader(metadataReader: MetadataReader): void;
+        applyMiddleware(...middleware: Array<Middleware>): void;
+        snapshot(): void;
+        restore(): void;
+        createChild(): Container;
+    }
+    export type Bind = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => BindingToSyntax<T>;
+    export type Rebind = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => BindingToSyntax<T>;
+    export type Unbind = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => void;
+    export type UnbindAsync = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => Promise<void>;
+    export type IsBound = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => boolean;
+    export interface ContainerModuleBase {
+        id: number;
+    }
+    export interface ContainerModule extends ContainerModuleBase {
+        registry: ContainerModuleCallBack;
+    }
+    export interface AsyncContainerModule extends ContainerModuleBase {
+        registry: AsyncContainerModuleCallBack;
+    }
+    export interface ModuleActivationHandlers {
+        onActivations: Lookup<BindingActivation<unknown>>;
+        onDeactivations: Lookup<BindingDeactivation<unknown>>;
+    }
+    export interface ModuleActivationStore extends Clonable<ModuleActivationStore> {
+        addDeactivation(moduleId: ContainerModuleBase["id"], serviceIdentifier: ServiceIdentifier<unknown>, onDeactivation: interfaces.BindingDeactivation<unknown>): void;
+        addActivation(moduleId: ContainerModuleBase["id"], serviceIdentifier: ServiceIdentifier<unknown>, onActivation: interfaces.BindingActivation<unknown>): void;
+        remove(moduleId: ContainerModuleBase["id"]): ModuleActivationHandlers;
+    }
+    export type ContainerModuleCallBack = (bind: interfaces.Bind, unbind: interfaces.Unbind, isBound: interfaces.IsBound, rebind: interfaces.Rebind, unbindAsync: interfaces.UnbindAsync, onActivation: interfaces.Container["onActivation"], onDeactivation: interfaces.Container["onDeactivation"]) => void;
+    export type AsyncContainerModuleCallBack = AsyncCallback<ContainerModuleCallBack>;
+    export interface ContainerSnapshot {
+        bindings: Lookup<Binding<unknown>>;
+        activations: Lookup<BindingActivation<unknown>>;
+        deactivations: Lookup<BindingDeactivation<unknown>>;
+        middleware: Next | null;
+        moduleActivationStore: interfaces.ModuleActivationStore;
+    }
+    export interface Lookup<T> extends Clonable<Lookup<T>> {
+        [x: string]: any;
+        add(serviceIdentifier: ServiceIdentifier, value: T): void;
+        getMap(): Map<interfaces.ServiceIdentifier, Array<T>>;
+        get(serviceIdentifier: ServiceIdentifier): Array<T>;
+        remove(serviceIdentifier: interfaces.ServiceIdentifier): void;
+        removeByCondition(condition: (item: T) => boolean): Array<T>;
+        removeIntersection(lookup: interfaces.Lookup<T>): void;
+        hasKey(serviceIdentifier: ServiceIdentifier): boolean;
+        clone(): Lookup<T>;
+        traverse(func: (key: interfaces.ServiceIdentifier, value: Array<T>) => void): void;
+    }
+    export interface BindingOnSyntax<T> {
+        onActivation(fn: (context: Context, injectable: T) => T | Promise<T>): BindingWhenSyntax<T>;
+        onDeactivation(fn: (injectable: T) => void | Promise<void>): BindingWhenSyntax<T>;
+    }
+    export interface BindingWhenSyntax<T> {
+        when(constraint: (request: Request) => boolean): BindingOnSyntax<T>;
+        whenTargetNamed(name: string | number | symbol): BindingOnSyntax<T>;
+        whenTargetIsDefault(): BindingOnSyntax<T>;
+        whenTargetTagged(tag: string | number | symbol, value: unknown): BindingOnSyntax<T>;
+        whenInjectedInto(parent: NewableFunction | string): BindingOnSyntax<T>;
+        whenParentNamed(name: string | number | symbol): BindingOnSyntax<T>;
+        whenParentTagged(tag: string | number | symbol, value: unknown): BindingOnSyntax<T>;
+        whenAnyAncestorIs(ancestor: NewableFunction | string): BindingOnSyntax<T>;
+        whenNoAncestorIs(ancestor: NewableFunction | string): BindingOnSyntax<T>;
+        whenAnyAncestorNamed(name: string | number | symbol): BindingOnSyntax<T>;
+        whenAnyAncestorTagged(tag: string | number | symbol, value: unknown): BindingOnSyntax<T>;
+        whenNoAncestorNamed(name: string | number | symbol): BindingOnSyntax<T>;
+        whenNoAncestorTagged(tag: string | number | symbol, value: unknown): BindingOnSyntax<T>;
+        whenAnyAncestorMatches(constraint: (request: Request) => boolean): BindingOnSyntax<T>;
+        whenNoAncestorMatches(constraint: (request: Request) => boolean): BindingOnSyntax<T>;
+    }
+    export interface BindingWhenOnSyntax<T> extends BindingWhenSyntax<T>, BindingOnSyntax<T> {
+    }
+    export interface BindingInSyntax<T> {
+        inSingletonScope(): BindingWhenOnSyntax<T>;
+        inTransientScope(): BindingWhenOnSyntax<T>;
+        inRequestScope(): BindingWhenOnSyntax<T>;
+    }
+    export interface BindingInWhenOnSyntax<T> extends BindingInSyntax<T>, BindingWhenOnSyntax<T> {
+    }
+    export interface BindingToSyntax<T> {
+        to(constructor: Newable<T>): BindingInWhenOnSyntax<T>;
+        toSelf(): BindingInWhenOnSyntax<T>;
+        toConstantValue(value: T): BindingWhenOnSyntax<T>;
+        toDynamicValue(func: DynamicValue<T>): BindingInWhenOnSyntax<T>;
+        toConstructor<T2>(constructor: Newable<T2>): BindingWhenOnSyntax<T>;
+        toFactory<T2, T3 extends Array<unknown> = Array<unknown>, T4 extends Array<unknown> = Array<unknown>>(factory: FactoryCreator<T2, T3, T4>): BindingWhenOnSyntax<T>;
+        toFunction(func: T): BindingWhenOnSyntax<T>;
+        toAutoFactory<T2>(serviceIdentifier: ServiceIdentifier<T2>): BindingWhenOnSyntax<T>;
+        toAutoNamedFactory<T2>(serviceIdentifier: ServiceIdentifier<T2>): BindingWhenOnSyntax<T>;
+        toProvider<T2>(provider: ProviderCreator<T2>): BindingWhenOnSyntax<T>;
+        toService(service: ServiceIdentifier<T>): void;
+    }
+    export interface ConstraintFunction {
+        metaData?: Metadata;
+        (request: Request | null): boolean;
+    }
+    export interface MetadataReader {
+        getConstructorMetadata(constructorFunc: NewableFunction): ConstructorMetadata;
+        getPropertiesMetadata(constructorFunc: NewableFunction): MetadataMap;
+    }
+    export interface MetadataMap {
+        [propertyNameOrArgumentIndex: string | symbol]: Array<Metadata>;
+    }
+    export interface ConstructorMetadata {
+        compilerGeneratedMetadata: Array<NewableFunction> | undefined;
+        userGeneratedMetadata: MetadataMap;
+    }
+    export {};
+}
+export { interfaces };

package/lib/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expressots/adapter-express",
-  "version": "1.8.2",
+  "version": "3.0.0-beta.2",
   "description": "Expressots - modern, fast, lightweight nodejs web framework (@adapter-express)",
   "author": "",
   "main": "./lib/cjs/index.js",
@@ -46,9 +46,6 @@
     "framework",
     "server-side"
   ],
-  "engines": {
-    "node": ">=18.18.0"
-  },
   "scripts": {
     "prepare": "husky",
     "clean": "node scripts/rm.js lib",
@@ -58,39 +55,37 @@
     "release": "release-it",
     "prepublish": "npm run build && npm pack",
     "publish": "npm publish --tag latest",
-    "test": "vitest run --reporter default",
-    "test:watch": "vitest run --watch",
-    "coverage": "vitest run --coverage",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "coverage": "jest --coverage",
     "format": "prettier --write \"src/**/*.ts\" --cache",
     "lint": "eslint \"src/**/*.ts\"",
     "lint:fix": "eslint \"src/**/*.ts\" --fix"
   },
   "dependencies": {
-    "dotenv": "16.4.5",
-    "inversify": "6.0.2",
-    "inversify-binding-decorators": "4.0.0",
+    "express": "4.21.1",
     "reflect-metadata": "0.2.2"
   },
   "devDependencies": {
     "@codecov/vite-plugin": "^0.0.1-beta.6",
     "@commitlint/cli": "19.2.1",
     "@commitlint/config-conventional": "19.2.2",
-    "@expressots/core": "2.16.1",
+    "@expressots/core": "^3.0.0-beta.1",
+    "@expressots/shared": "0.2.0",
     "@release-it/conventional-changelog": "8.0.1",
     "@types/express": "4.17.21",
+    "@types/jest": "^29.5.14",
     "@types/node": "20.14.10",
     "@typescript-eslint/eslint-plugin": "7.16.1",
     "@typescript-eslint/parser": "7.16.1",
-    "@vitest/coverage-v8": "2.0.3",
     "eslint": "8.57.0",
     "eslint-config-prettier": "9.1.0",
     "husky": "9.1.1",
+    "jest": "29.7.0",
     "prettier": "3.3.3",
     "release-it": "17.6.0",
-    "typescript": "5.5.3",
-    "vite": "5.3.4",
-    "vite-tsconfig-paths": "4.3.2",
-    "vitest": "2.0.3"
+    "ts-jest": "29.2.5",
+    "typescript": "5.5.3"
   },
   "release-it": {
     "git": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expressots/adapter-express",
-  "version": "1.8.2",
+  "version": "3.0.0-beta.2",
   "description": "Expressots - modern, fast, lightweight nodejs web framework (@adapter-express)",
   "author": "",
   "main": "./lib/cjs/index.js",
@@ -46,9 +46,6 @@
     "framework",
     "server-side"
   ],
-  "engines": {
-    "node": ">=18.18.0"
-  },
   "scripts": {
     "prepare": "husky",
     "clean": "node scripts/rm.js lib",
@@ -58,39 +55,37 @@
     "release": "release-it",
     "prepublish": "npm run build && npm pack",
     "publish": "npm publish --tag latest",
-    "test": "vitest run --reporter default",
-    "test:watch": "vitest run --watch",
-    "coverage": "vitest run --coverage",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "coverage": "jest --coverage",
     "format": "prettier --write \"src/**/*.ts\" --cache",
     "lint": "eslint \"src/**/*.ts\"",
     "lint:fix": "eslint \"src/**/*.ts\" --fix"
   },
   "dependencies": {
-    "dotenv": "16.4.5",
-    "inversify": "6.0.2",
-    "inversify-binding-decorators": "4.0.0",
+    "express": "4.21.1",
     "reflect-metadata": "0.2.2"
   },
   "devDependencies": {
     "@codecov/vite-plugin": "^0.0.1-beta.6",
     "@commitlint/cli": "19.2.1",
     "@commitlint/config-conventional": "19.2.2",
-    "@expressots/core": "2.16.1",
+    "@expressots/core": "^3.0.0-beta.1",
+    "@expressots/shared": "0.2.0",
     "@release-it/conventional-changelog": "8.0.1",
     "@types/express": "4.17.21",
+    "@types/jest": "^29.5.14",
     "@types/node": "20.14.10",
     "@typescript-eslint/eslint-plugin": "7.16.1",
     "@typescript-eslint/parser": "7.16.1",
-    "@vitest/coverage-v8": "2.0.3",
     "eslint": "8.57.0",
     "eslint-config-prettier": "9.1.0",
     "husky": "9.1.1",
+    "jest": "29.7.0",
     "prettier": "3.3.3",
     "release-it": "17.6.0",
-    "typescript": "5.5.3",
-    "vite": "5.3.4",
-    "vite-tsconfig-paths": "4.3.2",
-    "vitest": "2.0.3"
+    "ts-jest": "29.2.5",
+    "typescript": "5.5.3"
   },
   "release-it": {
     "git": {

package/lib/cjs/adapter-express/application-express.interface.js

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

package/lib/cjs/adapter-express/render/ejs/ejs.config.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setEngineEjs = setEngineEjs;
-const path_1 = require("path");
-const resolve_render_1 = require("../resolve-render");
-/**
- * Ejs defaults
- * @type {EjsOptions}
- * @constant
- * @default
- */
-const EJS_DEFAULTS = {
-    viewsDir: (0, path_1.join)(process.cwd(), "views"),
-    viewEngine: "ejs",
-    serverOptions: {},
-};
-/**
- * Set Ejs as the view engine
- * @param {Application} app - The express application
- * @param {EjsOptions} [options=EJS_DEFAULTS] - The ejs options
- */
-async function setEngineEjs(app, options = EJS_DEFAULTS) {
-    (0, resolve_render_1.packageResolver)("ejs");
-    app.set("view engine", options.viewEngine || EJS_DEFAULTS.viewEngine);
-    app.set("views", options.viewsDir || EJS_DEFAULTS.viewsDir);
-    if (Array.isArray(options.viewsDir)) {
-        options.viewsDir.forEach((dir) => {
-            app.set("views", dir);
-        });
-    }
-    if (options.serverOptions) {
-        app.locals = {
-            ...app.locals,
-            ...options.serverOptions,
-        };
-    }
-}

package/lib/cjs/adapter-express/render/ejs/ejs.types.js

@@ -1,3 +0,0 @@
-"use strict";
-/* eslint-disable @typescript-eslint/no-explicit-any */
-Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/adapter-express/render/handlebars/hbs.config.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setEngineHandlebars = setEngineHandlebars;
-const path_1 = require("path");
-const core_1 = require("@expressots/core");
-const resolve_render_1 = require("../resolve-render");
-/**
- * Handlebars defaults
- * @type {HandlebarsOptions}
- * @constant
- * @default
- */
-const HANDLEBARS_DEFAULTS = {
-    viewEngine: "hbs",
-    viewsDir: (0, path_1.join)(process.cwd(), "views"),
-    partialsDir: (0, path_1.join)(process.cwd(), "views/partials"),
-};
-/**
- * Default partials directory
- */
-const DEFAULT_PARTIALS_DIR = (0, path_1.join)(process.cwd(), "views/partials");
-/**
- * Set Handlebars as the view engine
- * @param {express.Application} app - The express application
- * @param {HandlebarsOptions} [options=HANDLEBARS_DEFAULTS] - The handlebars options
- */
-async function setEngineHandlebars(app, options = HANDLEBARS_DEFAULTS) {
-    const logger = new core_1.Logger();
-    try {
-        const hbs = (0, resolve_render_1.packageResolver)("hbs");
-        hbs.registerPartials(options.partialsDir || DEFAULT_PARTIALS_DIR);
-        app.set("view engine", options.viewEngine || HANDLEBARS_DEFAULTS.viewEngine);
-        app.set("views", options.viewsDir || HANDLEBARS_DEFAULTS.viewsDir);
-    }
-    catch (error) {
-        logger.error(error.message, "handlebars-config");
-    }
-}

package/lib/cjs/adapter-express/render/pug/pug.config.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setEnginePug = setEnginePug;
-const path_1 = require("path");
-const resolve_render_1 = require("../resolve-render");
-/**
- * Pug defaults
- * @type {PugOptions}
- * @constant
- * @default
- */
-const PUG_DEFAULTS = {
-    viewEngine: "pug",
-    viewsDir: (0, path_1.join)(process.cwd(), "views"),
-};
-/**
- * Set Pug as the view engine
- * @param {express.Application} app - The express application
- * @param {PugOptions} [options=PUG_DEFAULTS] - The pug options
- */
-async function setEnginePug(app, options = PUG_DEFAULTS) {
-    (0, resolve_render_1.packageResolver)("pug");
-    app.set("view engine", options.viewEngine || PUG_DEFAULTS.viewEngine);
-    app.set("views", options.viewsDir || PUG_DEFAULTS.viewsDir);
-}

package/lib/cjs/types/adapter-express/application-express.interface.d.ts

@@ -1,20 +0,0 @@
-import { IApplicationMessageToConsole } from "@expressots/core";
-import express from "express";
-import { ServerEnvironment } from "./application-express.types";
-/**
- * Public Interface for the WebServer application.
- */
-export interface IWebServerPublic {
-    /**
-     * Start listening on the given port and environment.
-     * @param port - The port number to listen on.
-     * @param environment - The server environment.
-     * @param consoleMessage - Optional message to display in the console.
-     */
-    listen(port: number, environment: ServerEnvironment, consoleMessage?: IApplicationMessageToConsole): Promise<void>;
-    /**
-     * Get the underlying HTTP server. (default: Express.js)
-     * @returns The underlying HTTP server after initialization.
-     */
-    getHttpServer(): Promise<express.Application>;
-}

package/lib/cjs/types/adapter-express/render/ejs/ejs.config.d.ts

@@ -1,21 +0,0 @@
-import { Application } from "express";
-import { Options } from "./ejs.types";
-/**
- * Ejs options
- * @typedef {Object} EjsOptions
- * @property {string | Array<string>} viewsDir - The path to the views folder
- * @property {string} viewEngine - The view engine
- * @property {ejs.Options} [serverOptions] - The server options
- *
- */
-export type EjsOptions = {
-    viewsDir?: string | Array<string>;
-    viewEngine?: string;
-    serverOptions?: Options;
-};
-/**
- * Set Ejs as the view engine
- * @param {Application} app - The express application
- * @param {EjsOptions} [options=EJS_DEFAULTS] - The ejs options
- */
-export declare function setEngineEjs(app: Application, options?: EjsOptions): Promise<void>;