@expressive-tea/core 2.0.0

package/exceptions/RequestExceptions.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnauthorizedException = exports.BadRequestException = exports.GenericRequestException = void 0;
+/**
+ * @namespace Exceptions
+ */
+/**
+ * HTTP Generic Exception Use this Exception to easily return a HTTP Error on the endpoints handlers.
+ * @export
+ * @class GenericRequestException
+ * @extends {Error}
+ * @param {string} message='Server Error' Provide the Error message.
+ * @param {number} [statusCode=500] HTTP Response Code
+ * @summary HTTP Exception Helper
+ * @example
+ * {REPLACE-AT}Router('/')
+ * class ExceptionExampleController {
+ *   {REPLACE-AT}Get('/exception')
+ *   exceptionMethod(req, res, next) {
+ *     try {
+ *       throw new GenericRequestException('Page not found', 404);
+ *     } catch (e) {
+ *       res.status(e.code).send(e.message);
+ *     }
+ *   }
+ * }
+ */
+class GenericRequestException extends Error {
+    constructor(message, statusCode = 500) {
+        super(message);
+        this.statusCode = 500;
+        this.message = 'Server Error';
+        this.statusCode = statusCode;
+        this.message = message;
+    }
+}
+exports.GenericRequestException = GenericRequestException;
+/**
+ * Shortcut Exception for 400 HTTP Errors (Bad Request).
+ * @export
+ * @class BadRequestException
+ * @extends {GenericRequestException}
+ * @param {string} [message='Bad Request'] Provide the Error message.
+ * @summary 400 Exception
+ * @example
+ * {REPLACE-AT}Router('/')
+ * class ExceptionExampleController {
+ *   {REPLACE-AT}Get('/exception')
+ *   exceptionMethod(req, res, next) {
+ *     try {
+ *       throw new BadRequestException();
+ *     } catch (e) {
+ *       res.status(e.code).send(e.message);
+ *     }
+ *   }
+ * }
+ */
+class BadRequestException extends GenericRequestException {
+    constructor(message = 'Bad Request') {
+        super(message, 400);
+    }
+}
+exports.BadRequestException = BadRequestException;
+/**
+ * Shortcut Exception for 401 HTTP Errors (Unauthorized Request).
+ * @export
+ * @class UnauthorizedException
+ * @extends {GenericRequestException}
+ * @param {string} [message='Unauthorized Request'] Provide the Error message.
+ * @summary 401 Exception
+ * @example
+ * {REPLACE-AT}Router('/')
+ * class ExceptionExampleController {
+ *   {REPLACE-AT}Get('/exception')
+ *   exceptionMethod(req, res, next) {
+ *     try {
+ *       throw new UnauthorizedException();
+ *     } catch (e) {
+ *       res.status(e.code).send(e.message);
+ *     }
+ *   }
+ * }
+ */
+class UnauthorizedException extends GenericRequestException {
+    constructor(message = 'Unauthorized Request') {
+        super(message, 401);
+    }
+}
+exports.UnauthorizedException = UnauthorizedException;

package/helpers/boot-helper.d.ts

@@ -0,0 +1,7 @@
+import { BOOT_STAGES } from '@expressive-tea/commons';
+import { type Express } from 'express';
+import type Boot from '../classes/Boot';
+export declare function resolveStage(stage: BOOT_STAGES, ctx: Boot, server: Express, ...extraArgs: unknown[]): Promise<void>;
+export declare function resolveDirectives(instance: typeof Boot | Boot, server: Express): void;
+export declare function resolveStatic(instance: typeof Boot | Boot, server: Express): void;
+export declare function resolveProxy(ProxyContainer: any, server: Express): void;

package/helpers/boot-helper.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveStage = resolveStage;
+exports.resolveDirectives = resolveDirectives;
+exports.resolveStatic = resolveStatic;
+exports.resolveProxy = resolveProxy;
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-return */
+const commons_1 = require("@expressive-tea/commons");
+const express = require("express");
+const commons_2 = require("@expressive-tea/commons");
+const commons_3 = require("@expressive-tea/commons");
+const BootLoaderExceptions_1 = require("../exceptions/BootLoaderExceptions");
+const DependencyInjection_1 = require("../services/DependencyInjection");
+async function resolveStage(stage, ctx, server, ...extraArgs) {
+    try {
+        await bootloaderResolve(stage, server, ctx, ...extraArgs);
+        if (stage === commons_1.BOOT_STAGES.APPLICATION) {
+            resolveModules(ctx, server);
+        }
+    }
+    catch (e) {
+        if (checkIfStageFails(e)) {
+            throw e;
+        }
+    }
+}
+function resolveDirectives(instance, server) {
+    const registeredDirectives = commons_2.Metadata.get(commons_1.REGISTERED_DIRECTIVES_KEY, (0, commons_3.getClass)(instance)) || [];
+    registeredDirectives.forEach((options) => {
+        // @ts-expect-error Settings can be any parameter
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        server.set(options.name, ...options.settings);
+    });
+}
+function resolveStatic(instance, server) {
+    const registeredStatic = commons_2.Metadata.get(commons_1.REGISTERED_STATIC_KEY, (0, commons_3.getClass)(instance)) || [];
+    registeredStatic.forEach((staticOptions) => {
+        if (staticOptions.virtual) {
+            server.use(staticOptions.virtual, express.static(staticOptions.root, staticOptions.options));
+        }
+        else {
+            server.use(express.static(staticOptions.root, staticOptions.options));
+        }
+    });
+}
+function resolveProxy(ProxyContainer, server) {
+    const proxyContainer = new ProxyContainer();
+    proxyContainer.__register(server);
+}
+function resolveModules(instance, server) {
+    // Metadata is stored on the class by decorators, so we need to get the constructor
+    // If instance is already a class (typeof === 'function'), use it directly
+    // If instance is an object, get its constructor
+    const target = typeof instance === 'function' ? instance : instance.constructor;
+    const registeredModules = commons_2.Metadata.get(commons_1.REGISTERED_MODULE_KEY, target, 'start') || [];
+    for (const Module of registeredModules) {
+        const moduleInstance = (0, DependencyInjection_1.getInstanceOf)(Module);
+        moduleInstance.__register(server);
+    }
+}
+async function bootloaderResolve(STAGE, server, instance, ...args) {
+    const bootLoader = commons_2.Metadata.get(commons_1.BOOT_STAGES_KEY, (0, commons_3.getClass)(instance)) || commons_1.STAGES_INIT;
+    for (const loader of bootLoader[STAGE] || []) {
+        try {
+            await selectLoaderType(loader, server, ...args);
+        }
+        catch (e) {
+            shouldFailIfRequire(e, loader);
+        }
+    }
+}
+function selectLoaderType(loader, server, ...args) {
+    return loader.method(server, ...args);
+}
+function checkIfStageFails(e) {
+    return !(e instanceof BootLoaderExceptions_1.BootLoaderSoftExceptions);
+}
+function shouldFailIfRequire(e, loader) {
+    const failMessage = `Failed [${loader.name}]: ${e.message}`;
+    if (!loader || loader.required) {
+        throw new BootLoaderExceptions_1.BootLoaderRequiredExceptions(failMessage);
+    }
+    throw new BootLoaderExceptions_1.BootLoaderSoftExceptions(`${failMessage} and will be not enabled`);
+}

package/helpers/decorators.d.ts

@@ -0,0 +1 @@
+export declare function addAnnotation(type: string, target: object, propertyKey: string | symbol, ...args: any[]): void;

package/helpers/decorators.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addAnnotation = addAnnotation;
+const commons_1 = require("@expressive-tea/commons");
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+const commons_2 = require("@expressive-tea/commons");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function addAnnotation(type, target, propertyKey, ...args) {
+    const annotations = commons_1.Metadata.get(commons_2.ROUTER_ANNOTATIONS_KEY, target, propertyKey) || [];
+    annotations.unshift({
+        arguments: args,
+        type
+    });
+    commons_1.Metadata.set(commons_2.ROUTER_ANNOTATIONS_KEY, annotations, target, propertyKey);
+}

package/helpers/promise-helper.d.ts

@@ -0,0 +1 @@
+export declare function delay(ms: number): Promise<void>;

package/helpers/promise-helper.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delay = delay;
+async function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}

package/helpers/server.d.ts

@@ -0,0 +1,35 @@
+import { type NextFunction, type Request, type Response } from 'express';
+import { type ExpressiveTeaAnnotations, type ExpressiveTeaArgumentOptions } from '@expressive-tea/commons';
+import { type ExpressiveTeaHandlerOptionsWithInstrospectedArgs } from '../interfaces';
+import { TFunction } from '../types/core';
+import { type ExpressiveTeaServerProps } from '@expressive-tea/commons';
+interface ExecuteRequestContext {
+    options: ExpressiveTeaHandlerOptionsWithInstrospectedArgs;
+    decoratedArguments: ExpressiveTeaArgumentOptions[];
+    annotations: ExpressiveTeaAnnotations[];
+    self: any;
+}
+export interface FileSettingsResult {
+    config: ExpressiveTeaServerProps;
+    source: string | null;
+}
+export declare function autoResponse(_: any, response: Response, annotations: ExpressiveTeaAnnotations[], responseResult?: any): void;
+export declare function executeRequest(this: ExecuteRequestContext, request: Request, response: Response, next: NextFunction): Promise<void>;
+export declare function mapArguments(decoratedArguments: ExpressiveTeaArgumentOptions[], request: Request, response: Response, next: NextFunction, introspectedArgs?: string[]): any[];
+export declare function extractParameters(target: unknown, args?: string | string[], propertyName?: string): any;
+export declare function generateRoute(route: string, verb: string, ...settings: any): (target: object, propertyKey: string | symbol, descriptor: PropertyDescriptor) => void;
+export declare function router(verb: string, route: string, target: any, handler: TFunction, propertyKey: string | symbol, settings?: any): void;
+/**
+ * Load configuration from .expressive-tea files.
+ *
+ * Supports YAML (.yaml, .yml) and JSON formats with priority order:
+ * 1. .expressive-tea.yaml (highest)
+ * 2. .expressive-tea.yml
+ * 3. .expressive-tea (JSON, lowest)
+ *
+ * @returns Configuration object and source file path
+ * @throws {Error} If config file is invalid (JSON/YAML parse error)
+ * @since 2.0.1
+ */
+export declare function fileSettings(): FileSettingsResult;
+export {};

package/helpers/server.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoResponse = autoResponse;
+exports.executeRequest = executeRequest;
+exports.mapArguments = mapArguments;
+exports.extractParameters = extractParameters;
+exports.generateRoute = generateRoute;
+exports.router = router;
+exports.fileSettings = fileSettings;
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-return */
+const utilities_1 = require("../libs/utilities");
+const commons_1 = require("@expressive-tea/commons");
+const commons_2 = require("@expressive-tea/commons");
+const commons_3 = require("@expressive-tea/commons");
+const fs = require("node:fs");
+const yaml = require("js-yaml");
+const path = require("node:path");
+function autoResponse(_, response, annotations, responseResult) {
+    const view = (0, utilities_1.find)(annotations, { type: 'view' });
+    if (view && view.arguments) {
+        response.render(view.arguments[0], responseResult);
+        return;
+    }
+    response.send((0, utilities_1.isNumber)(responseResult) ? responseResult.toString() : responseResult);
+}
+async function executeRequest(request, response, next) {
+    let isNextUsed = false;
+    const nextWrapper = (error) => {
+        if (error) {
+            isNextUsed = true;
+            return next(error);
+        }
+        isNextUsed = true;
+        next();
+    };
+    const result = await this.options.handler.apply(this.self, mapArguments(this.decoratedArguments, request, response, nextWrapper, this.options.introspectedArgs));
+    if (!response.headersSent && !isNextUsed) {
+        autoResponse(request, response, this.annotations, result);
+    }
+    // Express 5 handles async rejections automatically
+}
+function mapArguments(decoratedArguments, request, response, next, introspectedArgs = []) {
+    return (0, utilities_1.chain)(decoratedArguments)
+        .sortBy('index')
+        .map((argument) => {
+        switch (argument.type) {
+            case commons_2.ARGUMENT_TYPES.REQUEST:
+                return request;
+            case commons_2.ARGUMENT_TYPES.RESPONSE:
+                return response;
+            case commons_2.ARGUMENT_TYPES.NEXT:
+                return next;
+            case commons_2.ARGUMENT_TYPES.QUERY:
+                return extractParameters(request.query, argument.arguments, (0, utilities_1.get)(introspectedArgs, argument.index));
+            case commons_2.ARGUMENT_TYPES.BODY:
+                return extractParameters(request.body, argument.arguments, (0, utilities_1.get)(introspectedArgs, argument.index));
+            case commons_2.ARGUMENT_TYPES.GET_PARAM:
+                return extractParameters(request.params, argument.arguments, (0, utilities_1.get)(introspectedArgs, argument.index));
+            default:
+                return undefined;
+        }
+    })
+        .thru((args) => (0, utilities_1.size)(args) ? args : [request, response, next])
+        .value();
+}
+function extractParameters(target, args, propertyName) {
+    if (!args && !target) {
+        return;
+    }
+    if (args && (0, utilities_1.size)(args)) {
+        if (Array.isArray(args)) {
+            return (0, utilities_1.pick)(target, args);
+        }
+        return (0, utilities_1.get)(target, args);
+    }
+    if (propertyName && (0, utilities_1.has)(target, propertyName)) {
+        return (0, utilities_1.get)(target, propertyName);
+    }
+    return target;
+}
+function generateRoute(route, verb, ...settings) {
+    return (target, propertyKey, descriptor) => {
+        router(verb, route, target, descriptor.value, propertyKey, settings);
+    };
+}
+function router(verb, route, target, handler, propertyKey, settings) {
+    const introspectedArgs = (0, commons_3.getOwnArgumentNames)(handler);
+    const existedRoutesHandlers = commons_1.Metadata.get(commons_2.ROUTER_HANDLERS_KEY, target) || [];
+    existedRoutesHandlers.unshift({ verb, route, handler, target, propertyKey, settings, introspectedArgs });
+    commons_1.Metadata.set(commons_2.ROUTER_HANDLERS_KEY, existedRoutesHandlers, target);
+}
+/**
+ * Load configuration from .expressive-tea files.
+ *
+ * Supports YAML (.yaml, .yml) and JSON formats with priority order:
+ * 1. .expressive-tea.yaml (highest)
+ * 2. .expressive-tea.yml
+ * 3. .expressive-tea (JSON, lowest)
+ *
+ * @returns Configuration object and source file path
+ * @throws {Error} If config file is invalid (JSON/YAML parse error)
+ * @since 2.0.1
+ */
+function fileSettings() {
+    const cwd = process.cwd();
+    // Priority order: YAML > YML > JSON
+    const configFiles = [
+        { path: '.expressive-tea.yaml', type: 'yaml' },
+        { path: '.expressive-tea.yml', type: 'yaml' },
+        { path: '.expressive-tea', type: 'json' }
+    ];
+    for (const file of configFiles) {
+        const filePath = path.join(cwd, file.path);
+        if (fs.existsSync(filePath)) {
+            try {
+                const content = fs.readFileSync(filePath, 'utf-8');
+                let config;
+                if (file.type === 'yaml') {
+                    const parsed = yaml.load(content);
+                    // yaml.load returns undefined for empty strings and null for whitespace/comments
+                    // Treat empty YAML files as empty configuration objects
+                    config = (parsed !== null && parsed !== void 0 ? parsed : {});
+                }
+                else {
+                    config = JSON.parse(content);
+                }
+                // Debug log which file was loaded
+                console.debug(`[Expressive Tea] Loaded configuration from: ${file.path}`);
+                return { config, source: file.path };
+            }
+            catch (error) {
+                const errorMsg = file.type === 'yaml'
+                    ? `Invalid YAML in ${file.path}: ${error.message}`
+                    : `Invalid JSON in ${file.path}: ${error.message}`;
+                throw new Error(errorMsg);
+            }
+        }
+    }
+    // No config file found
+    return { config: {}, source: null };
+}

package/helpers/teapot-helper.d.ts

@@ -0,0 +1,18 @@
+import { type KeyPairSyncResult } from 'node:crypto';
+import { type NextFunction, type Request, type Response } from 'express';
+import type ProxyRoute from '../classes/ProxyRoute';
+export interface EncryptedMessage {
+    iv: string;
+    message: string;
+    authTag: string;
+}
+export type TeaGatewayMessage = Record<string, any>;
+export default class TeaGatewayHelper {
+    static encrypt(data: TeaGatewayMessage, signature: Buffer): EncryptedMessage;
+    static decrypt(data: EncryptedMessage, signature: Buffer): TeaGatewayMessage;
+    static sign(data: string, privateKey: string, passphrase: string): Buffer;
+    static verify(data: string, publicKey: string, signature: Buffer): boolean;
+    static generateKeys(passphrase: string): KeyPairSyncResult<any, any>;
+    static proxyResponse(proxyRoute: ProxyRoute, req: Request, res: Response, next: NextFunction): void;
+    static httpSchema(schema: string): "http:" | "https:";
+}

package/helpers/teapot-helper.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto = require("node:crypto");
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-return */
+const node_crypto_1 = require("node:crypto");
+class TeaGatewayHelper {
+    static encrypt(data, signature) {
+        const iv = crypto.randomBytes(16);
+        const packet = JSON.stringify(data);
+        // HKDF key derivation - separate encryption key from signature
+        const derivedKey = Buffer.from(crypto.hkdfSync('sha256', signature, Buffer.alloc(32), 'expressive-tea-encryption', 32));
+        // AES-256-GCM - authenticated encryption
+        const cipher = crypto.createCipheriv('aes-256-gcm', derivedKey, iv);
+        const encrypted = Buffer.concat([cipher.update(packet), cipher.final()]);
+        const authTag = cipher.getAuthTag();
+        return {
+            iv: iv.toString('hex'),
+            message: encrypted.toString('base64'),
+            authTag: authTag.toString('hex')
+        };
+    }
+    static decrypt(data, signature) {
+        // Input validation
+        if (!data || !data.iv || !data.message || !data.authTag) {
+            throw new Error('Invalid encrypted message format');
+        }
+        if (!signature || signature.length !== 64) {
+            throw new Error('Invalid signature');
+        }
+        const iv = Buffer.from(data.iv, 'hex');
+        const message = Buffer.from(data.message, 'base64');
+        const authTag = Buffer.from(data.authTag, 'hex');
+        // HKDF key derivation - same as encrypt
+        const derivedKey = Buffer.from(crypto.hkdfSync('sha256', signature, Buffer.alloc(32), 'expressive-tea-encryption', 32));
+        // AES-256-GCM with auth tag verification
+        const decipher = crypto.createDecipheriv('aes-256-gcm', derivedKey, iv);
+        decipher.setAuthTag(authTag);
+        try {
+            const decrypted = Buffer.concat([decipher.update(message), decipher.final()]);
+            return JSON.parse(decrypted.toString());
+        }
+        catch (_a) {
+            throw new Error('Decryption failed: message tampered or wrong key');
+        }
+    }
+    static sign(data, privateKey, passphrase) {
+        return crypto.sign(null, Buffer.from(data), {
+            key: privateKey,
+            passphrase
+        });
+    }
+    static verify(data, publicKey, signature) {
+        return crypto.verify(null, Buffer.from(data), {
+            key: publicKey
+        }, signature);
+    }
+    static generateKeys(passphrase) {
+        return (0, node_crypto_1.generateKeyPairSync)('ed25519', {
+            modulusLength: 2048,
+            publicKeyEncoding: {
+                type: 'spki',
+                format: 'pem'
+            },
+            privateKeyEncoding: {
+                type: 'pkcs8',
+                format: 'pem',
+                cipher: 'aes-256-cbc',
+                passphrase
+            }
+        });
+    }
+    static proxyResponse(proxyRoute, req, res, next) {
+        const router = proxyRoute.registerRoute();
+        if (!proxyRoute.hasClients()) {
+            next();
+            return;
+        }
+        router(req, res, next);
+    }
+    static httpSchema(schema) {
+        if (schema.includes('teapot'))
+            return 'http:';
+        if (schema.includes('teapots'))
+            return 'https:';
+        throw new Error(`Invalid Schema: ${schema}`);
+    }
+}
+exports.default = TeaGatewayHelper;

package/helpers/websocket-helper.d.ts

@@ -0,0 +1,3 @@
+import type * as http from 'http';
+import type * as https from 'https';
+export declare function initWebsocket(server: http.Server, secureServer: https.Server): void;

package/helpers/websocket-helper.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initWebsocket = initWebsocket;
+const WebsocketService_1 = require("../services/WebsocketService");
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+const WebSocket = require("ws");
+const Settings_1 = require("../classes/Settings");
+function initWebsocket(server, secureServer) {
+    const settings = Settings_1.default.getInstance();
+    const isDetached = settings.get('detachWebsocket');
+    if (settings.get('startWebsocket')) {
+        WebsocketService_1.default.init();
+        WebsocketService_1.default.getInstance().setWebSocket(new WebSocket.Server(isDetached ? { noServer: true } : { server }));
+        if (secureServer) {
+            WebsocketService_1.default.getInstance().setSecureWebsocket(new WebSocket.Server(isDetached ? { noServer: true } : { server: secureServer }));
+        }
+        WebsocketService_1.default.getInstance().setHttpServer(server);
+        WebsocketService_1.default.getInstance().setHttpServer(secureServer);
+    }
+}

package/interfaces/index.d.ts

@@ -0,0 +1,4 @@
+import { type ExpressiveTeaHandlerOptions } from '@expressive-tea/commons';
+export interface ExpressiveTeaHandlerOptionsWithInstrospectedArgs extends ExpressiveTeaHandlerOptions {
+    introspectedArgs: string[];
+}

package/interfaces/index.js

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

package/inversify.config.d.ts

@@ -0,0 +1,9 @@
+import { Container } from 'inversify';
+declare const container: Container;
+export declare const decorators: {
+    lazyInject: (serviceIdentifier: string | symbol | interfaces.Newable<any> | interfaces.Abstract<any>) => (proto: any, key: string) => void;
+    lazyInjectNamed: (serviceIdentifier: string | symbol | interfaces.Newable<any> | interfaces.Abstract<any>, named: string) => (proto: any, key: string) => void;
+    lazyInjectTagged: (serviceIdentifier: string | symbol | interfaces.Newable<any> | interfaces.Abstract<any>, key: string, value: any) => (proto: any, propertyName: string) => void;
+    lazyMultiInject: (serviceIdentifier: string | symbol | interfaces.Newable<any> | interfaces.Abstract<any>) => (proto: any, key: string) => void;
+};
+export default container;

package/inversify.config.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decorators = void 0;
+const inversify_1 = require("inversify");
+const inversify_inject_decorators_1 = require("inversify-inject-decorators");
+const container = new inversify_1.Container({ autobind: true });
+exports.decorators = (0, inversify_inject_decorators_1.default)(container);
+exports.default = container;

package/libs/classNames.d.ts

@@ -0,0 +1 @@
+export declare const EXPRESSIVE_TEA_PROXY_CLASS = "ExpressiveTeaProxy";

package/libs/classNames.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXPRESSIVE_TEA_PROXY_CLASS = void 0;
+exports.EXPRESSIVE_TEA_PROXY_CLASS = 'ExpressiveTeaProxy';