cindel 1.0.0

package/dist/server/hmr-server.d.ts

@@ -0,0 +1,378 @@
+/**
+ * @typedef {Object} TLSConfig
+ * @property {string} key - Path to the private key file (PEM)
+ * @property {string} cert - Path to the certificate file (PEM)
+ * @property {string} [ca] - Path to a CA certificate file for mutual TLS
+ * @property {string} [passphrase] - Passphrase for an encrypted private key
+ */
+/**
+ * @typedef {Object} CORSProxyConfig
+ * @property {string|RegExp} [path='/proxy'] - Path prefix or regex that triggers the proxy
+ * @property {function(string, Request): Object} [getHeaders] - Return custom headers for the outbound request. Receives `(targetUrl, incomingRequest)`.
+ * @property {function(Response): Promise<Response>} [transformResponse] - Transform the upstream response before returning it to the client
+ */
+/**
+ * @typedef {Object} WSProxyConfig
+ * @property {string} [path='/proxy'] - Path prefix that triggers the proxy. The remainder of the path must be the full upstream `ws://` or `wss://` URL.
+ * @property {Object} [headers] - Static headers sent to every upstream connection.
+ * @property {boolean|string[]} [forwardHeaders] - Forward incoming client headers to the upstream connection.
+ *   `true` forwards all headers; an array of header name strings forwards only the listed ones (case-insensitive).
+ *   Applied before `headers` and `getHeaders`, so explicit values always win.
+ * @property {function(string, Object): Object} [getHeaders] - Return dynamic headers per connection. Receives `(targetUrl, incomingHeaders)`. Merged on top of `headers`.
+ * @property {function(string): void} [onConnect] - Called when the upstream connection opens. Receives `targetUrl`.
+ * @property {function(*, WebSocket, WebSocket): void} [onClientMessage] - Intercept messages from the browser before forwarding upstream. Receives `(message, clientSocket, upstreamSocket)`.
+ * @property {function(*, WebSocket, WebSocket): void} [onUpstreamMessage] - Intercept messages from upstream before forwarding to the browser. Receives `(message, clientSocket, upstreamSocket)`.
+ * @property {Object} [options] - Extra options passed to the upstream `WebSocket` constructor (e.g. `options: { perMessageDeflate: true }`)
+ */
+/**
+ * HMR server with optional HTTP features (static files, CORS proxy, WebSocket proxy).
+ * All features are opt-in via configuration.
+ *
+ * @example
+ * // Minimal HMR only
+ * const hmr = new HMRServer({
+ *   port: 1338,
+ *   watch: ['src']
+ * });
+ *
+ * @example
+ * // HMR + Development Server
+ * const dev = new HMRServer({
+ *   port: 1338,
+ *   watch: ['src'],
+ *   static: '.',
+ *   injectLoader: 'loader.js'
+ * });
+ *
+ * @example
+ * // HMR + Proxies
+ * const proxy = new HMRServer({
+ *   port: 1338,
+ *   watch: ['src'],
+ *   corsProxy: { path: '/proxy' },
+ *   wsProxy: {
+ *     path: '/proxy',
+ *     headers: {
+ *       Origin: 'https://www.example.com',
+ *       'User-Agent': 'Mozilla/5.0'
+ *     }
+ *   }
+ * });
+ *
+ * @example
+ * // Full Stack
+ * const server = new HMRServer({
+ *   port: 1338,
+ *   watch: ['src'],
+ *   static: '.',
+ *   corsProxy: true,
+ *   wsProxy: {
+ *     path: '/proxy',
+ *     headers: {
+ *       Origin: 'https://www.example.com'
+ *     },
+ *     options: { perMessageDeflate: true }
+ *   },
+ *   injectLoader: 'loader.js',
+ *   tls: {
+ *     key: 'localhost-key.pem',
+ *     cert: 'localhost.pem'
+ *   }
+ * });
+ */
+export class HMRServer {
+    /**
+     * @param {Object} [options={}]
+     * @param {number} [options.port=1338] - Port to listen on.
+     * @param {string} [options.bindHost='localhost'] - Network interface to bind to. Use `'0.0.0.0'` to listen on all interfaces and expose the server on your local network.
+     * @param {boolean} [options.watchFiles=true] - Use chokidar to watch files. Set to `false` to scan once at startup for initial file loading only.
+     * @param {string} [options.wsPath='/hmr'] - WebSocket upgrade path. Clients must connect to this path.
+     * @param {string[]} [options.watch=[]] - Paths or glob patterns to watch (e.g. `['src', 'lib']`)
+     * @param {string[]} [options.ignore] - Glob patterns to ignore.
+     * @param {string[]} [options.cold] - Glob patterns for files that require a full page reload instead of HMR (e.g. `['**\/*.config.js']`)
+     * @param {string[]} [options.extensions] - File extensions to watch. Defaults to `.js .cjs .mjs .css`
+     * @param {function(WebSocket, {files: string[], config: Object}): void} [options.onConnect] - Called when an HMR client connects. Defaults to sending an `init` message with the file list.
+     * @param {function(WebSocket): void} [options.onDisconnect] - Called when an HMR client disconnects
+     * @param {boolean} [options.logFiles=false] - Log every watched file during watcher initialization
+     * @param {boolean|{cors?: boolean, ws?: boolean}} [options.logProxy=false] - Log proxy traffic.
+     *   `true` enables both. Pass `{ cors: true, ws: false }` to enable only one.
+     * @param {string} [options.static] - Directory to serve static files from (e.g. `'.'` or `'public'`), Defaults to `'.'` for serving from project root.
+     * @param {string} [options.indexPath='index.html'] - Path to index.html, used as the `/` fallback and for loader injection
+     * @param {string} [options.injectLoader] - Path to a script that will be injected into index.html via `<script>` before `</head>`
+     * @param {boolean|string|CORSProxyConfig} [options.corsProxy] - Enable the HTTP CORS proxy. `true` mounts at `/proxy`. A string uses that as the path directly e.g. `'/cors'`.
+     * @param {WSProxyConfig} [options.wsProxy] - Proxy WebSocket connections to an upstream server
+     * @param {function(): string[]} [options.getFiles] - Override the file list sent to connecting clients. Called on every new connection.
+     * @param {boolean|string} [options.filesEndpoint] - Expose the watched file list as JSON. `true` mounts at `/files`, a string uses that as the path.
+     * @param {boolean|string} [options.configEndpoint] - Expose the server config as JSON. `true` mounts at `/config`, a string uses that as the path.
+     * @param {TLSConfig} [options.tls] - Enable HTTPS/WSS
+     * @param {boolean|string[]} [options.handleSignals=true] - Register signal handlers that call `stop()` and exit cleanly.
+     *    Default `yes` adds `SIGINT`/`SIGTERM`; `false` disables; or pass an array (e.g. `['SIGINT','SIGTERM','SIGHUP']`).
+     */
+    constructor(options?: {
+        port?: number;
+        bindHost?: string;
+        watchFiles?: boolean;
+        wsPath?: string;
+        watch?: string[];
+        ignore?: string[];
+        cold?: string[];
+        extensions?: string[];
+        onConnect?: (arg0: WebSocket, arg1: {
+            files: string[];
+            config: any;
+        }) => void;
+        onDisconnect?: (arg0: WebSocket) => void;
+        logFiles?: boolean;
+        logProxy?: boolean | {
+            cors?: boolean;
+            ws?: boolean;
+        };
+        static?: string;
+        indexPath?: string;
+        injectLoader?: string;
+        corsProxy?: boolean | string | CORSProxyConfig;
+        wsProxy?: WSProxyConfig;
+        getFiles?: () => string[];
+        filesEndpoint?: boolean | string;
+        configEndpoint?: boolean | string;
+        tls?: TLSConfig;
+        handleSignals?: boolean | string[];
+    });
+    port: number;
+    bindHost: string;
+    wsPath: string;
+    watchFiles: boolean;
+    watchPaths: string[];
+    ignorePaths: string[];
+    coldPatterns: string[];
+    extensions: string[];
+    onConnectCallback: any;
+    onDisconnectCallback: (arg0: WebSocket) => void;
+    logFiles: boolean;
+    logProxy: {
+        cors: boolean;
+        ws: boolean;
+    };
+    logger: Logger;
+    watcher: FileWatcher;
+    server: Bun.Server<undefined>;
+    /** @type {Set<WebSocket>} */
+    clients: Set<WebSocket>;
+    staticDir: string;
+    getFilesCallback: () => string[];
+    filesEndpoint: any;
+    configEndpoint: any;
+    corsProxy: {
+        path: any;
+        getHeaders?: undefined;
+        transformResponse?: undefined;
+    } | {
+        path: any;
+        getHeaders: (arg0: string, arg1: Request) => any;
+        transformResponse: (arg0: Response) => Promise<Response>;
+    };
+    wsProxy: {
+        path: any;
+        /**
+         * - Static headers sent to every upstream connection.
+         */
+        headers?: any;
+        /**
+         * - Forward incoming client headers to the upstream connection.
+         * `true` forwards all headers; an array of header name strings forwards only the listed ones (case-insensitive).
+         * Applied before `headers` and `getHeaders`, so explicit values always win.
+         */
+        forwardHeaders?: boolean | string[];
+        /**
+         * - Return dynamic headers per connection. Receives `(targetUrl, incomingHeaders)`. Merged on top of `headers`.
+         */
+        getHeaders?: (arg0: string, arg1: any) => any;
+        /**
+         * - Called when the upstream connection opens. Receives `targetUrl`.
+         */
+        onConnect?: (arg0: string) => void;
+        /**
+         * - Intercept messages from the browser before forwarding upstream. Receives `(message, clientSocket, upstreamSocket)`.
+         */
+        onClientMessage?: (arg0: any, arg1: WebSocket, arg2: WebSocket) => void;
+        /**
+         * - Intercept messages from upstream before forwarding to the browser. Receives `(message, clientSocket, upstreamSocket)`.
+         */
+        onUpstreamMessage?: (arg0: any, arg1: WebSocket, arg2: WebSocket) => void;
+        /**
+         * - Extra options passed to the upstream `WebSocket` constructor (e.g. `options: { perMessageDeflate: true }`)
+         */
+        options?: any;
+    };
+    loaderPath: string;
+    injectLoader: boolean;
+    indexPath: string;
+    tls: TLSConfig;
+    handleSignals: boolean | string[];
+    isColdFile(file: any): any;
+    /**
+     * Send a message to a single HMR client
+     * @param {WebSocket} client - The client to send to
+     * @param {Object} payload - The payload to send, will be JSON serialized
+     * @returns {boolean} Whether the message was sent successfully
+     */
+    send(client: WebSocket, payload: any): boolean;
+    defaultOnConnect(ws: any, data: any): void;
+    getConfig(): {
+        port: number;
+        bindHost: string;
+        wsPath: string;
+        watch: string[];
+        ignore: string[];
+        cold: string[];
+        watchFiles: boolean;
+        extensions: string[];
+        static: string;
+        corsProxy: {
+            path: any;
+            getHeaders?: undefined;
+            transformResponse?: undefined;
+        } | {
+            path: any;
+            getHeaders: (arg0: string, arg1: Request) => any;
+            transformResponse: (arg0: Response) => Promise<Response>;
+        };
+        wsProxy: {
+            path: any;
+            /**
+             * - Static headers sent to every upstream connection.
+             */
+            headers?: any;
+            /**
+             * - Forward incoming client headers to the upstream connection.
+             * `true` forwards all headers; an array of header name strings forwards only the listed ones (case-insensitive).
+             * Applied before `headers` and `getHeaders`, so explicit values always win.
+             */
+            forwardHeaders?: boolean | string[];
+            /**
+             * - Return dynamic headers per connection. Receives `(targetUrl, incomingHeaders)`. Merged on top of `headers`.
+             */
+            getHeaders?: (arg0: string, arg1: any) => any;
+            /**
+             * - Called when the upstream connection opens. Receives `targetUrl`.
+             */
+            onConnect?: (arg0: string) => void;
+            /**
+             * - Intercept messages from the browser before forwarding upstream. Receives `(message, clientSocket, upstreamSocket)`.
+             */
+            onClientMessage?: (arg0: any, arg1: WebSocket, arg2: WebSocket) => void;
+            /**
+             * - Intercept messages from upstream before forwarding to the browser. Receives `(message, clientSocket, upstreamSocket)`.
+             */
+            onUpstreamMessage?: (arg0: any, arg1: WebSocket, arg2: WebSocket) => void;
+            /**
+             * - Extra options passed to the upstream `WebSocket` constructor (e.g. `options: { perMessageDeflate: true }`)
+             */
+            options?: any;
+        };
+        wsProxyHeaders: any;
+        wsProxyPrefix: any;
+        filesEndpoint: any;
+        injectLoader: boolean;
+        loaderPath: string;
+        indexPath: string;
+        tls: TLSConfig;
+        handleSignals: boolean | string[];
+        logProxy: {
+            cors: boolean;
+            ws: boolean;
+        };
+        logFiles: boolean;
+    };
+    setupWatcher(): Promise<void>;
+    staticFiles: string[];
+    broadcast(action: any, file: any, extra?: {}): void;
+    handleHMRConnection(client: any): void;
+    handleHMRDisconnect(client: any): void;
+    getWebSocketConfig(): {
+        open: (client: any) => void;
+        message: (client: any, message: any) => void;
+        close: (client: any) => void;
+    };
+    /**
+     * Start the HMR server
+     * @returns {Promise<void>}
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the HMR server and clean up resources
+     * @returns {Promise<void>}
+     */
+    stop(): Promise<void>;
+}
+export type TLSConfig = {
+    /**
+     * - Path to the private key file (PEM)
+     */
+    key: string;
+    /**
+     * - Path to the certificate file (PEM)
+     */
+    cert: string;
+    /**
+     * - Path to a CA certificate file for mutual TLS
+     */
+    ca?: string;
+    /**
+     * - Passphrase for an encrypted private key
+     */
+    passphrase?: string;
+};
+export type CORSProxyConfig = {
+    /**
+     * - Path prefix or regex that triggers the proxy
+     */
+    path?: string | RegExp;
+    /**
+     * - Return custom headers for the outbound request. Receives `(targetUrl, incomingRequest)`.
+     */
+    getHeaders?: (arg0: string, arg1: Request) => any;
+    /**
+     * - Transform the upstream response before returning it to the client
+     */
+    transformResponse?: (arg0: Response) => Promise<Response>;
+};
+export type WSProxyConfig = {
+    /**
+     * - Path prefix that triggers the proxy. The remainder of the path must be the full upstream `ws://` or `wss://` URL.
+     */
+    path?: string;
+    /**
+     * - Static headers sent to every upstream connection.
+     */
+    headers?: any;
+    /**
+     * - Forward incoming client headers to the upstream connection.
+     * `true` forwards all headers; an array of header name strings forwards only the listed ones (case-insensitive).
+     * Applied before `headers` and `getHeaders`, so explicit values always win.
+     */
+    forwardHeaders?: boolean | string[];
+    /**
+     * - Return dynamic headers per connection. Receives `(targetUrl, incomingHeaders)`. Merged on top of `headers`.
+     */
+    getHeaders?: (arg0: string, arg1: any) => any;
+    /**
+     * - Called when the upstream connection opens. Receives `targetUrl`.
+     */
+    onConnect?: (arg0: string) => void;
+    /**
+     * - Intercept messages from the browser before forwarding upstream. Receives `(message, clientSocket, upstreamSocket)`.
+     */
+    onClientMessage?: (arg0: any, arg1: WebSocket, arg2: WebSocket) => void;
+    /**
+     * - Intercept messages from upstream before forwarding to the browser. Receives `(message, clientSocket, upstreamSocket)`.
+     */
+    onUpstreamMessage?: (arg0: any, arg1: WebSocket, arg2: WebSocket) => void;
+    /**
+     * - Extra options passed to the upstream `WebSocket` constructor (e.g. `options: { perMessageDeflate: true }`)
+     */
+    options?: any;
+};
+import { Logger } from '../shared/logger.js';
+import { FileWatcher } from './file-watcher.js';
+//# sourceMappingURL=hmr-server.d.ts.map

package/dist/server/hmr-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hmr-server.d.ts","sourceRoot":"","sources":["../../src/server/hmr-server.js"],"names":[],"mappings":"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"}

package/dist/server/routes.d.ts

@@ -0,0 +1,2 @@
+export function handleRoutes(req: any, server: any): Promise<Response>;
+//# sourceMappingURL=routes.d.ts.map

package/dist/server/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../src/server/routes.js"],"names":[],"mappings":"AAEA,uEAyBC"}

package/dist/server/ws-proxy.d.ts

@@ -0,0 +1,5 @@
+export function handleWSProxy(client: any, path: any, config: any, logger: any, logProxy: any): {
+    onMessage: (message: any) => void;
+    onClose: () => void;
+};
+//# sourceMappingURL=ws-proxy.d.ts.map

package/dist/server/ws-proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ws-proxy.d.ts","sourceRoot":"","sources":["../../src/server/ws-proxy.js"],"names":[],"mappings":"AAAA;;;EA4JC"}

package/dist/shared/constants.d.ts

@@ -0,0 +1,24 @@
+export const DEFAULT_PORT: 1338;
+export const WATCHABLE_EXTENSIONS: string[];
+export const DEFAULT_FILES_ENDPOINT: "/files";
+export const DEFAULT_CONFIG_ENDPOINT: "/config";
+export const DEFAULT_CORS_PROXY_PATH: "/proxy";
+export const DEFAULT_WS_PROXY_PATH: "/proxy";
+export namespace WATCHER_CONFIG {
+    let persistent: boolean;
+    let ignoreInitial: boolean;
+    namespace awaitWriteFinish {
+        let stabilityThreshold: number;
+        let pollInterval: number;
+    }
+    let usePolling: boolean;
+    let alwaysStat: boolean;
+    let atomic: boolean;
+}
+export namespace HMR_ACTIONS {
+    let RELOAD: string;
+    let ADD: string;
+    let REMOVE: string;
+    let INIT: string;
+}
+//# sourceMappingURL=constants.d.ts.map

package/dist/shared/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/shared/constants.js"],"names":[],"mappings":"AAAA,2BAA4B,IAAI,CAAC;AACjC,4CAAoE;AAEpE,qCAAsC,QAAQ,CAAA;AAC9C,sCAAuC,SAAS,CAAA;AAEhD,sCAAuC,QAAQ,CAAC;AAChD,oCAAqC,QAAQ,CAAC"}

package/dist/shared/logger.d.ts

@@ -0,0 +1,39 @@
+export class Logger {
+    symbols: {
+        debug: string;
+        info: string;
+        success: string;
+        warning: string;
+        error: string;
+        config: string;
+        connect: string;
+        disconnect: string;
+        change: string;
+        add: string;
+        remove: string;
+        inject: string;
+        startup: string;
+        shutdown: string;
+        corsProxy: string;
+        wsProxy: string;
+        watch: string;
+        dirAdd: string;
+        dirRemove: string;
+        glob: string;
+    };
+    debug(message: any): void;
+    info(message: any): void;
+    success(message: any): void;
+    warning(message: any): void;
+    error(message: any): void;
+    custom(symbol: any, message: any, color?: string): void;
+    file(symbol: any, filePath: any, color?: string, prefix?: string): void;
+    banner(name: any, config: any): void;
+    corsProxyRequest(method: any, url: any, { reqBody, status, statusText, resBody }?: {}): void;
+    wsProxyConnect(id: any, url: any, headers: any): void;
+    shutdown(): void;
+    watcherStart(paths: any): void;
+    logInitFile(filePath: any, ignored: any, reason?: string): void;
+    watcherNoFiles(patterns: any, extensions: any): void;
+}
+//# sourceMappingURL=logger.d.ts.map

package/dist/shared/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/shared/logger.js"],"names":[],"mappings":"AAGA;IAEI;;;;;;;;;;;;;;;;;;;;;MAqBC;IAGH,0BAEC;IAED,yBAEC;IAED,4BAEC;IAED,4BAEC;IAED,0BAEC;IAED,wDAIC;IAED,wEASC;IAED,qCAiCC;IAGD,6FAgBC;IAGD,sDAYC;IAED,iBAEC;IAED,+BAIC;IAED,gEAOC;IAED,qDAOC;CACF"}

package/dist/shared/utils.d.ts

@@ -0,0 +1,13 @@
+export function matchGlob(file: any, patterns: any): any;
+export function formatTime(): string;
+export function getBrowserFromUA(userAgent: any): "Unknown" | "Chrome" | "Firefox" | "Safari" | "Edge" | "Opera";
+export function getFileName(path: any): any;
+export function getFilePath(path: any): any;
+export function normalizeUrl(url: any): any;
+export function normalizeProxyPath(path: any, defaultPath: any): any;
+export function resolveEndpoint(value: any, defaultPath: any): any;
+export function resolveConnectionUrls(options: any, wsPath?: string): {
+    wsUrl: any;
+    httpUrl: any;
+};
+//# sourceMappingURL=utils.d.ts.map

package/dist/shared/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/shared/utils.js"],"names":[],"mappings":"AAKA,yDAKC;AAED,qCAOC;AAED,iHAUC;AAED,4CAEC;AAED,4CAIC;AAED,4CAEC;AAED,qEAEC;AAED,mEAIC;AA6BD;;;EAuCC"}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "cindel",
+  "version": "1.0.0",
+  "description": "Hot module replacement server and client with file watching, static file serving, CORS proxy and WebSocket proxy support",
+  "license": "GPL-3.0-or-later",
+  "author": "sneazy-ibo",
+  "homepage": "https://github.com/sneazy-ibo/cindel#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sneazy-ibo/cindel"
+  },
+  "bugs": "https://github.com/sneazy-ibo/cindel/issues",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./client": {
+      "import": "./dist/client.js",
+      "types": "./dist/client.d.ts"
+    },
+    "./server": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "main": "dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "bun build.js",
+    "prepublishOnly": "bun run build"
+  },
+  "types": "dist/index.d.ts",
+  "dependencies": {
+    "chalk": "^5.0.0",
+    "chokidar": "^5.0.0",
+    "picomatch": "^4.0.0"
+  },
+  "devDependencies": {
+    "bun-types": "latest",
+    "esbuild": "^0.27.3",
+    "typescript": "^5.0.0"
+  },
+  "keywords": [
+    "cors",
+    "dev-server",
+    "file-watcher",
+    "game-modding",
+    "hmr",
+    "hot-module-reload",
+    "hot-module-replacement",
+    "hot-reload",
+    "websocket",
+    "ws-proxy"
+  ],
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "jsdelivr": "dist/client.iife.min.js",
+  "unpkg": "dist/client.iife.min.js"
+}