@remix-run/node-hmr 0.0.0 → 0.1.0

package/dist/lib/runtime-api.d.ts

@@ -0,0 +1,7 @@
+import type { BrowserHmrChannel } from './browser-events.ts';
+export interface NodeHmrRuntimeApi {
+    createBrowserHmrChannel(): Promise<BrowserHmrChannel>;
+    emitServerReady(): void;
+}
+export declare const nodeHmrRuntimeUnavailableError = "The node-hmr/runtime API is only available when running inside node-hmr";
+//# sourceMappingURL=runtime-api.d.ts.map

package/dist/lib/runtime-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-api.d.ts","sourceRoot":"","sources":["../../src/lib/runtime-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAE5D,MAAM,WAAW,iBAAiB;IAChC,uBAAuB,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAAA;IACrD,eAAe,IAAI,IAAI,CAAA;CACxB;AAED,eAAO,MAAM,8BAA8B,4EACgC,CAAA"}

package/dist/lib/runtime-api.js

@@ -0,0 +1 @@
+export const nodeHmrRuntimeUnavailableError = 'The node-hmr/runtime API is only available when running inside node-hmr';

package/dist/lib/runtime.d.ts

@@ -0,0 +1,46 @@
+import { type BrowserHmrChannel, type BrowserHmrFileEvent } from './browser-events.ts';
+/**
+ * Hot module context available at `import.meta.hot`.
+ */
+export interface ImportMetaHot {
+    /** Mutable state preserved for this module across accepted updates and passed to dispose handlers. */
+    readonly data: Record<string, unknown>;
+    /** Accepts updates to this module, optionally receiving its newly evaluated namespace. */
+    accept(callback?: (module: HotModule) => HotCallbackResult): void;
+    /** Accepts updates from one dependency, optionally receiving its newly evaluated namespace. */
+    accept(dep: string, callback?: (module: HotModule) => HotCallbackResult): void;
+    /**
+     * Accepts updates from multiple dependencies. The callback array preserves `deps` order and
+     * contains the updated namespace only at the position of the dependency that changed.
+     */
+    accept(deps: readonly string[], callback?: (modules: Array<HotModule | undefined>) => HotCallbackResult): void;
+    /** Registers cleanup that runs before this module is re-evaluated or the runtime is disposed. */
+    dispose(callback: (data: Record<string, unknown>) => HotCallbackResult): void;
+    /** Declines the current update and asks the runner to restart the child process. */
+    invalidate(message?: string): void;
+    /** Registers a custom-event listener for API compatibility. Server modules receive no events. */
+    on(event: string, callback: (data: unknown) => void | Promise<void>): void;
+}
+type HotModule = Readonly<Record<string, unknown>> & {
+    readonly [Symbol.toStringTag]: 'Module';
+};
+export interface RemixNodeHmrRuntime {
+    createBrowserHmrChannel(): Promise<BrowserHmrChannel>;
+    createHotContext(url: string, resolveDependency?: (specifier: string) => string): ImportMetaHot;
+    disposeAll(): Promise<void>;
+    emitServerReady(): void;
+    handleBrowserHmrFileEvents(requestId: number, events: readonly BrowserHmrFileEvent[]): void;
+    reportAcceptedDependencies(url: string, acceptedDeps: string[]): void;
+    update(url: string, timestamp: number, acceptedUrl?: string): Promise<void>;
+}
+type HotCallbackResult = void | Promise<void>;
+export declare function getNodeHmrRuntime(): RemixNodeHmrRuntime | undefined;
+/**
+ * Notifies the parent process that the child server is ready.
+ */
+export declare function emitServerReady(): void;
+export declare function installNodeHmrRuntime(options?: {
+    browserEventUrl?: string;
+}): RemixNodeHmrRuntime;
+export {};
+//# sourceMappingURL=runtime.d.ts.map

package/dist/lib/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/lib/runtime.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,mBAAmB,EAIzB,MAAM,qBAAqB,CAAA;AAI5B;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,sGAAsG;IACtG,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACtC,0FAA0F;IAC1F,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,iBAAiB,GAAG,IAAI,CAAA;IACjE,+FAA+F;IAC/F,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,iBAAiB,GAAG,IAAI,CAAA;IAC9E;;;OAGG;IACH,MAAM,CACJ,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,KAAK,CAAC,SAAS,GAAG,SAAS,CAAC,KAAK,iBAAiB,GACtE,IAAI,CAAA;IACP,iGAAiG;IACjG,OAAO,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,iBAAiB,GAAG,IAAI,CAAA;IAC7E,oFAAoF;IACpF,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,iGAAiG;IACjG,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;CAC3E;AAED,KAAK,SAAS,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG;IACnD,QAAQ,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAA;CACxC,CAAA;AAED,MAAM,WAAW,mBAAmB;IAClC,uBAAuB,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAAA;IACrD,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,GAAG,aAAa,CAAA;IAC/F,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IAC3B,eAAe,IAAI,IAAI,CAAA;IACvB,0BAA0B,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,mBAAmB,EAAE,GAAG,IAAI,CAAA;IAC3F,0BAA0B,CAAC,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,IAAI,CAAA;IACrE,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAC5E;AAMD,KAAK,iBAAiB,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AAiL7C,wBAAgB,iBAAiB,IAAI,mBAAmB,GAAG,SAAS,CAGnE;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,IAAI,CAEtC;AAED,wBAAgB,qBAAqB,CACnC,OAAO,GAAE;IACP,eAAe,CAAC,EAAE,MAAM,CAAA;CACpB,GACL,mBAAmB,CAiPrB"}

package/dist/lib/runtime.js

@@ -0,0 +1,374 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { fileURLToPath } from 'node:url';
+import { sendHmrEventPayload, } from './browser-events.js';
+import { emitServerHmrEvent, emitServerHmrUpdate } from './events.js';
+import { hasNodeHmrParentProcess } from './process-state.js';
+const browserHmrChannelRequestTimeoutMs = 5_000;
+class NodeHotContext {
+    data;
+    url;
+    #acceptCallbacks = [];
+    #acceptDependencyCallbacks = [];
+    #disposeCallbacks = [];
+    #invalidated = false;
+    #invalidationMessage;
+    #isUpdating = false;
+    #disposeSelf;
+    #disposeDependency;
+    #resolveDependency;
+    constructor(url, data, disposeSelf, disposeDependency, resolveDependency) {
+        this.data = data;
+        this.url = url;
+        this.#disposeSelf = disposeSelf;
+        this.#disposeDependency = disposeDependency;
+        this.#resolveDependency = resolveDependency;
+    }
+    accept(deps, callback = () => { }) {
+        if (typeof deps === 'string') {
+            let normalizedDeps = [this.#normalizeAcceptedDependency(deps)];
+            let dependencyCallback = callback;
+            this.#acceptDependencyCallbacks.push({
+                callback(module) {
+                    return dependencyCallback(module);
+                },
+                deps: normalizedDeps,
+            });
+            return;
+        }
+        if (isDependencyArray(deps)) {
+            let normalizedDeps = deps.map((dep) => this.#normalizeAcceptedDependency(dep));
+            let dependencyCallback = callback;
+            this.#acceptDependencyCallbacks.push({
+                callback(module, acceptedUrl) {
+                    return dependencyCallback(normalizedDeps.map((dep) => (dep === acceptedUrl ? module : undefined)));
+                },
+                deps: normalizedDeps,
+            });
+            return;
+        }
+        this.#acceptCallbacks.push(deps ?? (() => { }));
+    }
+    dispose(callback) {
+        this.#disposeCallbacks.push(callback);
+    }
+    invalidate(message) {
+        this.#invalidated = true;
+        this.#invalidationMessage = message;
+        if (this.#isUpdating) {
+            if (message !== undefined)
+                console.warn(message);
+            return;
+        }
+        requestRestart(message);
+    }
+    on(_event, _callback) {
+        void _event;
+        void _callback;
+    }
+    async disposeAll() {
+        for (let callback of this.#disposeCallbacks) {
+            await callback(this.data);
+        }
+    }
+    async update(timestamp, acceptedUrl) {
+        this.#invalidated = false;
+        this.#invalidationMessage = undefined;
+        if (acceptedUrl !== this.url) {
+            return await this.updateDependency(timestamp, acceptedUrl);
+        }
+        if (this.#acceptCallbacks.length === 0) {
+            requestRestart(`No HMR accept handler found for ${this.url}`);
+            return 'restart-requested';
+        }
+        await this.#disposeSelf();
+        this.#isUpdating = true;
+        try {
+            let updatedModule = await import(__rewriteRelativeImportExtension(`${this.url}?t=${timestamp}`));
+            for (let callback of this.#acceptCallbacks) {
+                await callback(updatedModule);
+            }
+        }
+        finally {
+            this.#isUpdating = false;
+        }
+        return this.#invalidated ? 'invalidated' : 'accepted';
+    }
+    get invalidationMessage() {
+        return this.#invalidationMessage;
+    }
+    async updateDependency(timestamp, acceptedUrl) {
+        let callbacks = this.#acceptDependencyCallbacks.filter((callback) => callback.deps.includes(acceptedUrl));
+        if (callbacks.length === 0) {
+            requestRestart(`No HMR accept handler found for ${acceptedUrl} via ${this.url}`);
+            return 'restart-requested';
+        }
+        this.#isUpdating = true;
+        try {
+            await this.#disposeDependency(acceptedUrl);
+            let updatedModule = await import(__rewriteRelativeImportExtension(`${acceptedUrl}?t=${timestamp}`));
+            for (let { callback } of callbacks) {
+                await callback(updatedModule, acceptedUrl);
+            }
+        }
+        finally {
+            this.#isUpdating = false;
+        }
+        return this.#invalidated ? 'invalidated' : 'accepted';
+    }
+    #normalizeAcceptedDependency(dep) {
+        let resolved = this.#resolveDependency(dep);
+        let url = new URL(resolved);
+        url.search = '';
+        url.hash = '';
+        return url.href;
+    }
+}
+function isDependencyArray(deps) {
+    return Array.isArray(deps);
+}
+export function getNodeHmrRuntime() {
+    let runtimeGlobal = globalThis;
+    return runtimeGlobal.__remixNodeHmr;
+}
+/**
+ * Notifies the parent process that the child server is ready.
+ */
+export function emitServerReady() {
+    getNodeHmrRuntime()?.emitServerReady();
+}
+export function installNodeHmrRuntime(options = {}) {
+    let runtimeGlobal = globalThis;
+    if (runtimeGlobal.__remixNodeHmr)
+        return runtimeGlobal.__remixNodeHmr;
+    let dataByUrl = new Map();
+    let updateContextsByUrl = new Map();
+    let latestContextsByUrl = new Map();
+    let browserEventUrl = options.browserEventUrl;
+    let browserHmrChannelId = 0;
+    let browserHmrChannelRequestId = 0;
+    let pendingBrowserHmrChannelRequests = new Map();
+    let browserHmrChannels = new Map();
+    process.on('message', (message) => {
+        if (!isBrowserHmrChannelMessage(message))
+            return;
+        let request = pendingBrowserHmrChannelRequests.get(message.requestId);
+        if (request === undefined)
+            return;
+        clearTimeout(request.timer);
+        pendingBrowserHmrChannelRequests.delete(message.requestId);
+        request.resolve(message.url);
+    });
+    let runtime = {
+        async createBrowserHmrChannel() {
+            browserEventUrl ??= await requestBrowserHmrChannelUrl();
+            if (browserEventUrl === undefined) {
+                throw new Error('Browser HMR is disabled for this node-hmr runtime');
+            }
+            let id = browserHmrChannelId++;
+            let watchedFiles = new Set();
+            let handlers = new Set();
+            let closed = false;
+            browserHmrChannels.set(id, {
+                async handleFileEvents(events) {
+                    let eventGroups = await Promise.all([...handlers].map((handler) => handler(events)));
+                    return eventGroups.flat();
+                },
+            });
+            function updateWatchedFiles(delta) {
+                if (closed)
+                    return;
+                for (let file of delta.add) {
+                    watchedFiles.add(file);
+                }
+                for (let file of delta.remove) {
+                    watchedFiles.delete(file);
+                }
+                process.send?.({
+                    id,
+                    delta,
+                    type: 'node-hmr:child:browser-hmr-watch-files-changed',
+                });
+            }
+            return {
+                close() {
+                    if (closed)
+                        return;
+                    closed = true;
+                    browserHmrChannels.delete(id);
+                    handlers.clear();
+                    let remove = [...watchedFiles];
+                    watchedFiles.clear();
+                    process.send?.({
+                        id,
+                        delta: { add: [], remove },
+                        type: 'node-hmr:child:browser-hmr-watch-files-changed',
+                    });
+                },
+                onFileEvents(handler) {
+                    if (closed)
+                        return () => { };
+                    handlers.add(handler);
+                    return () => {
+                        handlers.delete(handler);
+                    };
+                },
+                updateWatchedFiles,
+                url: browserEventUrl,
+            };
+        },
+        createHotContext(url, resolveDependency = (specifier) => new URL(specifier, url).href) {
+            let data = dataByUrl.get(url);
+            if (data === undefined) {
+                data = {};
+                dataByUrl.set(url, data);
+            }
+            let context = new NodeHotContext(url, data, async () => {
+                await latestContextsByUrl.get(url)?.disposeAll();
+            }, async (dependencyUrl) => {
+                await latestContextsByUrl.get(dependencyUrl)?.disposeAll();
+            }, resolveDependency);
+            if (!updateContextsByUrl.has(url)) {
+                updateContextsByUrl.set(url, context);
+            }
+            latestContextsByUrl.set(url, context);
+            return context;
+        },
+        emitServerReady() {
+            if (!hasNodeHmrParentProcess())
+                return;
+            process.send?.({
+                type: 'node-hmr:child:server-ready',
+            });
+        },
+        handleBrowserHmrFileEvents(requestId, events) {
+            if (!hasNodeHmrParentProcess())
+                return;
+            Promise.all([...browserHmrChannels.values()].map((browserHmrChannel) => browserHmrChannel.handleFileEvents(events)))
+                .then((eventGroups) => {
+                process.send?.({
+                    events: eventGroups.flat(),
+                    requestId,
+                    type: 'node-hmr:child:browser-hmr-file-events-handled',
+                });
+            })
+                .catch((error) => {
+                process.send?.({
+                    error: formatUnknownError(error),
+                    events: [],
+                    requestId,
+                    type: 'node-hmr:child:browser-hmr-file-events-handled',
+                });
+            });
+        },
+        reportAcceptedDependencies(url, acceptedDeps) {
+            if (!hasNodeHmrParentProcess())
+                return;
+            process.send?.({
+                type: 'node-hmr:child:accepted-deps-resolved',
+                url,
+                acceptedDeps,
+            });
+        },
+        async disposeAll() {
+            for (let context of latestContextsByUrl.values()) {
+                await context.disposeAll();
+            }
+            updateContextsByUrl.clear();
+            latestContextsByUrl.clear();
+        },
+        async update(url, timestamp, acceptedUrl = url) {
+            let context = updateContextsByUrl.get(url);
+            if (context === undefined) {
+                requestRestart(`No HMR context found for ${url}`);
+                return;
+            }
+            try {
+                let updateResult = await context.update(timestamp, acceptedUrl);
+                if (updateResult === 'invalidated') {
+                    process.send?.({
+                        acceptedUrl,
+                        message: context.invalidationMessage,
+                        timestamp,
+                        type: 'node-hmr:child:hot-module-invalidated',
+                        url,
+                    });
+                    return;
+                }
+                if (updateResult === 'restart-requested')
+                    return;
+                emitServerHmrUpdate({
+                    ...(acceptedUrl === url ? {} : { acceptedUrl }),
+                    filePath: acceptedUrl.startsWith('file:') ? fileURLToPath(acceptedUrl) : acceptedUrl,
+                    timestamp,
+                    type: 'update',
+                    url,
+                });
+            }
+            catch (error) {
+                requestRestart(`Failed to hot update ${url}: ${formatUnknownError(error)}`);
+            }
+        },
+    };
+    runtimeGlobal.__remixNodeHmr = runtime;
+    return runtime;
+    function requestBrowserHmrChannelUrl() {
+        if (!hasNodeHmrParentProcess())
+            return Promise.resolve(undefined);
+        let requestId = browserHmrChannelRequestId++;
+        return new Promise((resolvePromise) => {
+            let timer = setTimeout(() => {
+                pendingBrowserHmrChannelRequests.delete(requestId);
+                resolvePromise(undefined);
+            }, browserHmrChannelRequestTimeoutMs);
+            pendingBrowserHmrChannelRequests.set(requestId, {
+                resolve: resolvePromise,
+                timer,
+            });
+            if (!process.send?.({
+                requestId,
+                type: 'node-hmr:child:browser-hmr-channel-requested',
+            })) {
+                clearTimeout(timer);
+                pendingBrowserHmrChannelRequests.delete(requestId);
+                resolvePromise(undefined);
+            }
+        });
+    }
+}
+function isBrowserHmrChannelMessage(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        message.type === 'node-hmr:parent:browser-hmr-channel' &&
+        'requestId' in message &&
+        typeof message.requestId === 'number' &&
+        (!('url' in message) || typeof message.url === 'string'));
+}
+function requestRestart(message) {
+    if (message !== undefined) {
+        console.warn(message);
+    }
+    emitServerHmrEvent({
+        reason: message,
+        timestamp: Date.now(),
+        type: 'restart',
+    });
+    if (process.send) {
+        process.send({
+            type: 'node-hmr:child:restart-requested',
+            message,
+        });
+        return;
+    }
+    process.kill(process.pid, 'SIGTERM');
+}
+function formatUnknownError(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/register.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=register.d.ts.map

package/dist/register.d.ts.map

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