@expressive-tea/core 2.0.0

package/services/WebsocketService.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const https = require("https");
+class WebsocketService {
+    constructor(ws, wss) {
+        if (WebsocketService.instance) {
+            return WebsocketService.instance;
+        }
+        if (ws)
+            this.ws = ws;
+        if (wss)
+            this.wss = wss;
+        WebsocketService.instance = this;
+    }
+    getWebsocket(httpServer) {
+        return (httpServer instanceof https.Server) ? this.wss : this.ws;
+    }
+    setHttpServer(httpServer) {
+        if (httpServer instanceof https.Server) {
+            this.httpsServer = httpServer;
+        }
+        else {
+            this.httpServer = httpServer;
+        }
+    }
+    setWebSocket(ws) {
+        this.ws = ws;
+    }
+    setSecureWebsocket(wss) {
+        this.wss = wss;
+    }
+    static getInstance(ws, wss) {
+        if (!WebsocketService.instance) {
+            WebsocketService.instance = new WebsocketService(ws, wss);
+        }
+        return WebsocketService.instance;
+    }
+    static init(ws, wss) {
+        if (!WebsocketService.instance) {
+            WebsocketService.instance = new WebsocketService(ws, wss);
+        }
+    }
+    static clear() {
+        WebsocketService.instance = undefined;
+    }
+}
+exports.default = WebsocketService;

package/types/core.d.ts

@@ -0,0 +1,14 @@
+import { type IExpressiveTeaModule, IExpressiveTeaProxy, type IExpressiveTeaRoute } from '@expressive-tea/commons';
+export type TFunction<T = any> = (...args: any[]) => T;
+export type Constructor<T = Record<string, any>> = new (...args: any[]) => T;
+export type MixinConstructor<T = Record<string, any>> = Constructor<T>;
+export type ExpressiveTeaModule = MixinConstructor<IExpressiveTeaModule>;
+export type ExpressiveTeaRoute = MixinConstructor<IExpressiveTeaRoute>;
+export type ExpressiveTeaProxy = MixinConstructor<IExpressiveTeaProxy>;
+/**
+ * Legacy type aliases - kept for backward compatibility
+ * @deprecated Use the typed versions from mixins instead
+ */
+export type ModulizedExpressiveTeaModule<TBase> = IExpressiveTeaModule & TBase;
+export type RouterizedExpressiveTeaRoute<TBase> = IExpressiveTeaRoute & TBase;
+export type ProxifyExpressiveTeaRoute<TBase> = IExpressiveTeaProxy & TBase;

package/types/core.js

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

package/types/injection-types.d.ts

@@ -0,0 +1,6 @@
+export declare const TYPES: {
+    Context: symbol;
+    Server: symbol;
+    SecureServer: symbol;
+    Settings: symbol;
+};

package/types/injection-types.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TYPES = void 0;
+// Service identifiers for dependency injection
+exports.TYPES = {
+    Context: Symbol.for('Context'),
+    Server: Symbol.for('Server'),
+    SecureServer: Symbol.for('SecureServer'),
+    Settings: Symbol.for('Settings')
+};

package/types/inversify.d.ts

@@ -0,0 +1,5 @@
+import { ServiceIdentifier as InversifyServiceIdentifier } from 'inversify';
+export type ServiceIdentifier<T = any> = InversifyServiceIdentifier<T> | (abstract new (...args: any[]) => T);
+export type LazyInversifyDecorator<T = any> = (serviceIdentifier: ServiceIdentifier<T>) => (proto: any, key: string) => void;
+export type LazyInversifyNamedDecorator<T = any> = (serviceIdentifier: ServiceIdentifier<T>, named: string) => (proto: any, key: string) => void;
+export type LazyInversifyTaggedDecorator<T = any> = (serviceIdentifier: ServiceIdentifier<T>, key: string, value: any) => (proto: any, propertyName: string) => void;

package/types/inversify.js

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