@react-router/node 7.18.0 → 8.0.0-pre.1

package/dist/index.d.ts

@@ -1,13 +1,15 @@
-import { RequestListener } from 'node:http';
-import { ServerBuild, UNSAFE_MiddlewareEnabled, RouterContextProvider, AppLoadContext, SessionData, SessionIdStorageStrategy, SessionStorage } from 'react-router';
-import { ClientAddress } from '@mjackson/node-fetch-server';
-import { Readable, Writable } from 'node:stream';
 
+import { ClientAddress } from "@remix-run/node-fetch-server";
+import { RouterContextProvider, ServerBuild, SessionData, SessionIdStorageStrategy, SessionStorage } from "react-router";
+import { Readable, Writable } from "node:stream";
+import { RequestListener } from "node:http";
+
+//#region server.d.ts
 type MaybePromise<T> = T | Promise<T>;
 interface RequestListenerOptions {
-    build: ServerBuild | (() => ServerBuild | Promise<ServerBuild>);
-    getLoadContext?: (request: Request, client: ClientAddress) => UNSAFE_MiddlewareEnabled extends true ? MaybePromise<RouterContextProvider> : MaybePromise<AppLoadContext>;
-    mode?: string;
+  build: ServerBuild | (() => ServerBuild | Promise<ServerBuild>);
+  getLoadContext?: (request: Request, client: ClientAddress) => MaybePromise<RouterContextProvider>;
+  mode?: string;
 }
 /**
  * Creates a request listener that handles requests using Node's built-in HTTP server.
@@ -16,17 +18,18 @@ interface RequestListenerOptions {
  * @returns A request listener that can be used with `http.createServer`.
  */
 declare function createRequestListener(options: RequestListenerOptions): RequestListener;
-
+//#endregion
+//#region sessions/fileStorage.d.ts
 interface FileSessionStorageOptions {
-    /**
-     * The Cookie used to store the session id on the client, or options used
-     * to automatically create one.
-     */
-    cookie?: SessionIdStorageStrategy["cookie"];
-    /**
-     * The directory to use to store session files.
-     */
-    dir: string;
+  /**
+   * The Cookie used to store the session id on the client, or options used
+   * to automatically create one.
+   */
+  cookie?: SessionIdStorageStrategy["cookie"];
+  /**
+   * The directory to use to store session files.
+   */
+  dir: string;
 }
 /**
  * Creates a SessionStorage that stores session data on a filesystem.
@@ -36,13 +39,17 @@ interface FileSessionStorageOptions {
  *
  * @see https://api.reactrouter.com/v7/functions/_react-router_node.createFileSessionStorage
  */
-declare function createFileSessionStorage<Data = SessionData, FlashData = Data>({ cookie, dir, }: FileSessionStorageOptions): SessionStorage<Data, FlashData>;
-
+declare function createFileSessionStorage<Data = SessionData, FlashData = Data>({
+  cookie,
+  dir
+}: FileSessionStorageOptions): SessionStorage<Data, FlashData>;
+//#endregion
+//#region stream.d.ts
 declare function writeReadableStreamToWritable(stream: ReadableStream, writable: Writable): Promise<void>;
 declare function writeAsyncIterableToWritable(iterable: AsyncIterable<Uint8Array>, writable: Writable): Promise<void>;
 declare function readableStreamToString(stream: ReadableStream<Uint8Array>, encoding?: BufferEncoding): Promise<string>;
 declare const createReadableStreamFromReadable: (source: Readable & {
-    readableHighWaterMark?: number;
-}) => ReadableStream<Uint8Array>;
-
-export { type RequestListenerOptions, createFileSessionStorage, createReadableStreamFromReadable, createRequestListener, readableStreamToString, writeAsyncIterableToWritable, writeReadableStreamToWritable };
+  readableHighWaterMark?: number;
+}) => ReadableStream<Uint8Array<ArrayBufferLike>>;
+//#endregion
+export { type RequestListenerOptions, createFileSessionStorage, createReadableStreamFromReadable, createRequestListener, readableStreamToString, writeAsyncIterableToWritable, writeReadableStreamToWritable };

package/dist/index.js

@@ -1,5 +1,5 @@
 /**
- * @react-router/node v7.18.0
+ * @react-router/node v8.0.0-pre.1
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -8,371 +8,286 @@
  *
  * @license MIT
  */
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// index.ts
-var index_exports = {};
-__export(index_exports, {
-  createFileSessionStorage: () => createFileSessionStorage,
-  createReadableStreamFromReadable: () => createReadableStreamFromReadable,
-  createRequestListener: () => createRequestListener,
-  readableStreamToString: () => readableStreamToString,
-  writeAsyncIterableToWritable: () => writeAsyncIterableToWritable,
-  writeReadableStreamToWritable: () => writeReadableStreamToWritable
-});
-module.exports = __toCommonJS(index_exports);
-
-// server.ts
-var import_react_router = require("react-router");
-var import_node_fetch_server = require("@mjackson/node-fetch-server");
+import { createRequestListener as createRequestListener$1 } from "@remix-run/node-fetch-server";
+import { createRequestHandler, createSessionStorage } from "react-router";
+import { promises } from "node:fs";
+import * as path from "node:path";
+import { Stream } from "node:stream";
+//#region server.ts
+/**
+* Creates a request listener that handles requests using Node's built-in HTTP server.
+*
+* @param options Options for creating a request listener.
+* @returns A request listener that can be used with `http.createServer`.
+*/
 function createRequestListener(options) {
-  let handleRequest = (0, import_react_router.createRequestHandler)(options.build, options.mode);
-  return (0, import_node_fetch_server.createRequestListener)(async (request, client) => {
-    let loadContext = await options.getLoadContext?.(request, client);
-    return handleRequest(request, loadContext);
-  });
+	let handleRequest = createRequestHandler(options.build, options.mode);
+	return createRequestListener$1(async (request, client) => {
+		return handleRequest(request, await options.getLoadContext?.(request, client));
+	});
 }
-
-// sessions/fileStorage.ts
-var import_node_fs = require("fs");
-var path = __toESM(require("path"));
-var import_react_router2 = require("react-router");
-function createFileSessionStorage({
-  cookie,
-  dir
-}) {
-  return (0, import_react_router2.createSessionStorage)({
-    cookie,
-    async createData(data, expires) {
-      let content = JSON.stringify({ data, expires });
-      while (true) {
-        let randomBytes = crypto.getRandomValues(new Uint8Array(8));
-        let id = Buffer.from(randomBytes).toString("hex");
-        try {
-          let file = getFile(dir, id);
-          if (!file) {
-            throw new Error("Error generating session");
-          }
-          await import_node_fs.promises.mkdir(path.dirname(file), { recursive: true });
-          await import_node_fs.promises.writeFile(file, content, { encoding: "utf-8", flag: "wx" });
-          return id;
-        } catch (error) {
-          if (error.code !== "EEXIST") throw error;
-        }
-      }
-    },
-    async readData(id) {
-      try {
-        let file = getFile(dir, id);
-        if (!file) {
-          return null;
-        }
-        let content = JSON.parse(await import_node_fs.promises.readFile(file, "utf-8"));
-        let data = content.data;
-        let expires = typeof content.expires === "string" ? new Date(content.expires) : null;
-        if (!expires || expires > /* @__PURE__ */ new Date()) {
-          return data;
-        }
-        if (expires) await import_node_fs.promises.unlink(file);
-        return null;
-      } catch (error) {
-        if (error.code !== "ENOENT") throw error;
-        return null;
-      }
-    },
-    async updateData(id, data, expires) {
-      let content = JSON.stringify({ data, expires });
-      let file = getFile(dir, id);
-      if (!file) {
-        return;
-      }
-      await import_node_fs.promises.mkdir(path.dirname(file), { recursive: true });
-      await import_node_fs.promises.writeFile(file, content, "utf-8");
-    },
-    async deleteData(id) {
-      if (!id) {
-        return;
-      }
-      let file = getFile(dir, id);
-      if (!file) {
-        return;
-      }
-      try {
-        await import_node_fs.promises.unlink(file);
-      } catch (error) {
-        if (error.code !== "ENOENT") throw error;
-      }
-    }
-  });
+//#endregion
+//#region sessions/fileStorage.ts
+/**
+* Creates a SessionStorage that stores session data on a filesystem.
+*
+* The advantage of using this instead of cookie session storage is that
+* files may contain much more data than cookies.
+*
+* @see https://api.reactrouter.com/v7/functions/_react-router_node.createFileSessionStorage
+*/
+function createFileSessionStorage({ cookie, dir }) {
+	return createSessionStorage({
+		cookie,
+		async createData(data, expires) {
+			let content = JSON.stringify({
+				data,
+				expires
+			});
+			while (true) {
+				let randomBytes = crypto.getRandomValues(new Uint8Array(8));
+				let id = Buffer.from(randomBytes).toString("hex");
+				try {
+					let file = getFile(dir, id);
+					if (!file) throw new Error("Error generating session");
+					await promises.mkdir(path.dirname(file), { recursive: true });
+					await promises.writeFile(file, content, {
+						encoding: "utf-8",
+						flag: "wx"
+					});
+					return id;
+				} catch (error) {
+					if (error.code !== "EEXIST") throw error;
+				}
+			}
+		},
+		async readData(id) {
+			try {
+				let file = getFile(dir, id);
+				if (!file) return null;
+				let content = JSON.parse(await promises.readFile(file, "utf-8"));
+				let data = content.data;
+				let expires = typeof content.expires === "string" ? new Date(content.expires) : null;
+				if (!expires || expires > /* @__PURE__ */ new Date()) return data;
+				if (expires) await promises.unlink(file);
+				return null;
+			} catch (error) {
+				if (error.code !== "ENOENT") throw error;
+				return null;
+			}
+		},
+		async updateData(id, data, expires) {
+			let content = JSON.stringify({
+				data,
+				expires
+			});
+			let file = getFile(dir, id);
+			if (!file) return;
+			await promises.mkdir(path.dirname(file), { recursive: true });
+			await promises.writeFile(file, content, "utf-8");
+		},
+		async deleteData(id) {
+			if (!id) return;
+			let file = getFile(dir, id);
+			if (!file) return;
+			try {
+				await promises.unlink(file);
+			} catch (error) {
+				if (error.code !== "ENOENT") throw error;
+			}
+		}
+	});
 }
 function getFile(dir, id) {
-  if (!/^[0-9a-f]{16}$/i.test(id)) {
-    return null;
-  }
-  return path.join(dir, id.slice(0, 4), id.slice(4));
+	if (!/^[0-9a-f]{16}$/i.test(id)) return null;
+	return path.join(dir, id.slice(0, 4), id.slice(4));
 }
-
-// stream.ts
-var import_node_stream = require("stream");
+//#endregion
+//#region stream.ts
 async function writeReadableStreamToWritable(stream, writable) {
-  let reader = stream.getReader();
-  let flushable = writable;
-  let writableError = monitorWritableError(writable);
-  try {
-    while (true) {
-      writableError.throwIfClosed();
-      let { done, value } = await writableError.race(reader.read());
-      if (done) {
-        writable.end();
-        break;
-      }
-      writableError.throwIfClosed();
-      let canContinueWriting = writable.write(value);
-      if (typeof flushable.flush === "function") {
-        flushable.flush();
-      }
-      if (!canContinueWriting) {
-        await waitForDrain(writable, writableError);
-      }
-    }
-  } catch (error) {
-    try {
-      reader.cancel(error).catch(() => {
-      });
-    } catch {
-    }
-    writable.destroy(error);
-    throw error;
-  } finally {
-    writableError.cleanup();
-    try {
-      reader.releaseLock();
-    } catch {
-    }
-  }
+	let reader = stream.getReader();
+	let flushable = writable;
+	let writableError = monitorWritableError(writable);
+	try {
+		while (true) {
+			writableError.throwIfClosed();
+			let { done, value } = await writableError.race(reader.read());
+			if (done) {
+				writable.end();
+				break;
+			}
+			writableError.throwIfClosed();
+			let canContinueWriting = writable.write(value);
+			if (typeof flushable.flush === "function") flushable.flush();
+			if (!canContinueWriting) await waitForDrain(writable, writableError);
+		}
+	} catch (error) {
+		try {
+			reader.cancel(error).catch(() => {});
+		} catch {}
+		writable.destroy(error);
+		throw error;
+	} finally {
+		writableError.cleanup();
+		try {
+			reader.releaseLock();
+		} catch {}
+	}
 }
 function monitorWritableError(writable) {
-  let settled = false;
-  let writableError;
-  let rejectWritableError;
-  let writableErrorPromise = new Promise((_, reject2) => {
-    rejectWritableError = reject2;
-  });
-  writableErrorPromise.catch(() => {
-  });
-  function cleanup() {
-    writable.off("error", onError);
-    writable.off("close", onClose);
-  }
-  function reject(error) {
-    if (settled) {
-      return;
-    }
-    settled = true;
-    writableError = error;
-    cleanup();
-    rejectWritableError(error);
-  }
-  function onError(error) {
-    reject(error);
-  }
-  function onClose() {
-    reject(new Error("Writable closed before stream finished"));
-  }
-  writable.once("error", onError);
-  writable.once("close", onClose);
-  return {
-    cleanup,
-    race(promise) {
-      return Promise.race([promise, writableErrorPromise]);
-    },
-    throwIfClosed() {
-      if (writableError) {
-        throw writableError;
-      }
-      if (writable.destroyed || writable.writableEnded) {
-        throw new Error("Cannot write to a destroyed or ended writable stream");
-      }
-    }
-  };
+	let settled = false;
+	let writableError;
+	let rejectWritableError;
+	let writableErrorPromise = new Promise((_, reject) => {
+		rejectWritableError = reject;
+	});
+	writableErrorPromise.catch(() => {});
+	function cleanup() {
+		writable.off("error", onError);
+		writable.off("close", onClose);
+	}
+	function reject(error) {
+		if (settled) return;
+		settled = true;
+		writableError = error;
+		cleanup();
+		rejectWritableError(error);
+	}
+	function onError(error) {
+		reject(error);
+	}
+	function onClose() {
+		reject(/* @__PURE__ */ new Error("Writable closed before stream finished"));
+	}
+	writable.once("error", onError);
+	writable.once("close", onClose);
+	return {
+		cleanup,
+		race(promise) {
+			return Promise.race([promise, writableErrorPromise]);
+		},
+		throwIfClosed() {
+			if (writableError) throw writableError;
+			if (writable.destroyed || writable.writableEnded) throw new Error("Cannot write to a destroyed or ended writable stream");
+		}
+	};
 }
 function waitForDrain(writable, writableError) {
-  let cleanup = () => {
-  };
-  let drainPromise = new Promise((resolve) => {
-    function onDrain() {
-      cleanup();
-      resolve();
-    }
-    cleanup = function cleanup2() {
-      writable.off("drain", onDrain);
-    };
-    writable.once("drain", onDrain);
-  });
-  return writableError.race(drainPromise).finally(cleanup);
+	let cleanup = () => {};
+	let drainPromise = new Promise((resolve) => {
+		function onDrain() {
+			cleanup();
+			resolve();
+		}
+		cleanup = function cleanup() {
+			writable.off("drain", onDrain);
+		};
+		writable.once("drain", onDrain);
+	});
+	return writableError.race(drainPromise).finally(cleanup);
 }
 async function writeAsyncIterableToWritable(iterable, writable) {
-  let writableError = monitorWritableError(writable);
-  let iterator = iterable[Symbol.asyncIterator]();
-  let completed = false;
-  try {
-    while (true) {
-      writableError.throwIfClosed();
-      let { done, value: chunk } = await writableError.race(iterator.next());
-      if (done) {
-        completed = true;
-        break;
-      }
-      writableError.throwIfClosed();
-      let canContinueWriting = writable.write(chunk);
-      if (!canContinueWriting) {
-        await waitForDrain(writable, writableError);
-      }
-    }
-    writable.end();
-  } catch (error) {
-    if (!completed) {
-      try {
-        Promise.resolve(iterator.return?.()).catch(() => {
-        });
-      } catch {
-      }
-    }
-    writable.destroy(error);
-    throw error;
-  } finally {
-    writableError.cleanup();
-  }
+	let writableError = monitorWritableError(writable);
+	let iterator = iterable[Symbol.asyncIterator]();
+	let completed = false;
+	try {
+		while (true) {
+			writableError.throwIfClosed();
+			let { done, value: chunk } = await writableError.race(iterator.next());
+			if (done) {
+				completed = true;
+				break;
+			}
+			writableError.throwIfClosed();
+			if (!writable.write(chunk)) await waitForDrain(writable, writableError);
+		}
+		writable.end();
+	} catch (error) {
+		if (!completed) try {
+			Promise.resolve(iterator.return?.()).catch(() => {});
+		} catch {}
+		writable.destroy(error);
+		throw error;
+	} finally {
+		writableError.cleanup();
+	}
 }
 async function readableStreamToString(stream, encoding) {
-  let reader = stream.getReader();
-  let chunks = [];
-  while (true) {
-    let { done, value } = await reader.read();
-    if (done) {
-      break;
-    }
-    if (value) {
-      chunks.push(value);
-    }
-  }
-  return Buffer.concat(chunks).toString(encoding);
+	let reader = stream.getReader();
+	let chunks = [];
+	while (true) {
+		let { done, value } = await reader.read();
+		if (done) break;
+		if (value) chunks.push(value);
+	}
+	return Buffer.concat(chunks).toString(encoding);
 }
-var createReadableStreamFromReadable = (source) => {
-  let pump = new StreamPump(source);
-  let stream = new ReadableStream(pump, pump);
-  return stream;
+const createReadableStreamFromReadable = (source) => {
+	let pump = new StreamPump(source);
+	return new ReadableStream(pump, pump);
 };
 var StreamPump = class {
-  highWaterMark;
-  accumulatedSize;
-  stream;
-  controller;
-  constructor(stream) {
-    this.highWaterMark = stream.readableHighWaterMark || new import_node_stream.Stream.Readable().readableHighWaterMark;
-    this.accumulatedSize = 0;
-    this.stream = stream;
-    this.enqueue = this.enqueue.bind(this);
-    this.error = this.error.bind(this);
-    this.close = this.close.bind(this);
-  }
-  size(chunk) {
-    return chunk?.byteLength || 0;
-  }
-  start(controller) {
-    this.controller = controller;
-    this.stream.on("data", this.enqueue);
-    this.stream.once("error", this.error);
-    this.stream.once("end", this.close);
-    this.stream.once("close", this.close);
-  }
-  pull() {
-    this.resume();
-  }
-  cancel(reason) {
-    if (this.stream.destroy) {
-      this.stream.destroy(reason);
-    }
-    this.stream.off("data", this.enqueue);
-    this.stream.off("error", this.error);
-    this.stream.off("end", this.close);
-    this.stream.off("close", this.close);
-  }
-  enqueue(chunk) {
-    if (this.controller) {
-      try {
-        let bytes = chunk instanceof Uint8Array ? chunk : Buffer.from(chunk);
-        let available = (this.controller.desiredSize || 0) - bytes.byteLength;
-        this.controller.enqueue(bytes);
-        if (available <= 0) {
-          this.pause();
-        }
-      } catch (e) {
-        this.controller.error(
-          new Error(
-            "Could not create Buffer, chunk must be of type string or an instance of Buffer, ArrayBuffer, or Array or an Array-like Object"
-          )
-        );
-        this.cancel();
-      }
-    }
-  }
-  pause() {
-    if (this.stream.pause) {
-      this.stream.pause();
-    }
-  }
-  resume() {
-    if (this.stream.readable && this.stream.resume) {
-      this.stream.resume();
-    }
-  }
-  close() {
-    if (this.controller) {
-      this.controller.close();
-      delete this.controller;
-    }
-  }
-  error(error) {
-    if (this.controller) {
-      this.controller.error(error);
-      delete this.controller;
-    }
-  }
+	highWaterMark;
+	accumulatedSize;
+	stream;
+	controller;
+	constructor(stream) {
+		this.highWaterMark = stream.readableHighWaterMark || new Stream.Readable().readableHighWaterMark;
+		this.accumulatedSize = 0;
+		this.stream = stream;
+		this.enqueue = this.enqueue.bind(this);
+		this.error = this.error.bind(this);
+		this.close = this.close.bind(this);
+	}
+	size(chunk) {
+		return chunk?.byteLength || 0;
+	}
+	start(controller) {
+		this.controller = controller;
+		this.stream.on("data", this.enqueue);
+		this.stream.once("error", this.error);
+		this.stream.once("end", this.close);
+		this.stream.once("close", this.close);
+	}
+	pull() {
+		this.resume();
+	}
+	cancel(reason) {
+		if (this.stream.destroy) this.stream.destroy(reason);
+		this.stream.off("data", this.enqueue);
+		this.stream.off("error", this.error);
+		this.stream.off("end", this.close);
+		this.stream.off("close", this.close);
+	}
+	enqueue(chunk) {
+		if (this.controller) try {
+			let bytes = typeof chunk === "string" ? Buffer.from(chunk) : new Uint8Array(chunk);
+			let available = (this.controller.desiredSize || 0) - bytes.byteLength;
+			this.controller.enqueue(bytes);
+			if (available <= 0) this.pause();
+		} catch (e) {
+			this.controller.error(/* @__PURE__ */ new Error("Could not create Buffer, chunk must be of type string or an instance of Buffer, ArrayBuffer, or Array or an Array-like Object"));
+			this.cancel();
+		}
+	}
+	pause() {
+		if (this.stream.pause) this.stream.pause();
+	}
+	resume() {
+		if (this.stream.readable && this.stream.resume) this.stream.resume();
+	}
+	close() {
+		if (this.controller) {
+			this.controller.close();
+			delete this.controller;
+		}
+	}
+	error(error) {
+		if (this.controller) {
+			this.controller.error(error);
+			delete this.controller;
+		}
+	}
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createFileSessionStorage,
-  createReadableStreamFromReadable,
-  createRequestListener,
-  readableStreamToString,
-  writeAsyncIterableToWritable,
-  writeReadableStreamToWritable
-});
+//#endregion
+export { createFileSessionStorage, createReadableStreamFromReadable, createRequestListener, readableStreamToString, writeAsyncIterableToWritable, writeReadableStreamToWritable };

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@react-router/node",
-  "version": "7.18.0",
+  "type": "module",
+  "version": "8.0.0-pre.1",
   "description": "Node.js platform abstractions for React Router",
   "bugs": {
     "url": "https://github.com/remix-run/react-router/issues"
@@ -15,25 +16,15 @@
   "main": "dist/index.js",
   "exports": {
     ".": {
-      "node": {
-        "types": "./dist/index.d.ts",
-        "module-sync": "./dist/index.mjs",
-        "default": "./dist/index.js"
-      },
-      "import": {
-        "types": "./dist/index.d.mts",
-        "default": "./dist/index.mjs"
-      },
-      "default": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      }
+      "types": "./dist/index.d.ts",
+      "module-sync": "./dist/index.js",
+      "default": "./dist/index.js"
     },
     "./package.json": "./package.json"
   },
   "wireit": {
     "build": {
-      "command": "tsup",
+      "command": "tsdown",
       "files": [
         "../../pnpm-workspace.yaml",
         "sessions/**",
@@ -47,17 +38,18 @@
     }
   },
   "dependencies": {
-    "@mjackson/node-fetch-server": "^0.2.0"
+    "@remix-run/node-fetch-server": "^0.13.3"
   },
   "devDependencies": {
-    "tsup": "^8.3.0",
-    "typescript": "^5.4.5",
-    "wireit": "0.14.9",
-    "react-router": "7.18.0"
+    "@types/node": "^22.19.19",
+    "tsdown": "^0.22.0",
+    "typescript": "^6.0.3",
+    "wireit": "0.14.12",
+    "react-router": "8.0.0-pre.1"
   },
   "peerDependencies": {
     "typescript": "^5.1.0 || ^6.0.0",
-    "react-router": "7.18.0"
+    "react-router": "8.0.0-pre.1"
   },
   "peerDependenciesMeta": {
     "typescript": {
@@ -65,7 +57,7 @@
     }
   },
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=22.22.0"
   },
   "files": [
     "dist/",

package/dist/index.d.mts

@@ -1,48 +0,0 @@
-import { RequestListener } from 'node:http';
-import { ServerBuild, UNSAFE_MiddlewareEnabled, RouterContextProvider, AppLoadContext, SessionData, SessionIdStorageStrategy, SessionStorage } from 'react-router';
-import { ClientAddress } from '@mjackson/node-fetch-server';
-import { Readable, Writable } from 'node:stream';
-
-type MaybePromise<T> = T | Promise<T>;
-interface RequestListenerOptions {
-    build: ServerBuild | (() => ServerBuild | Promise<ServerBuild>);
-    getLoadContext?: (request: Request, client: ClientAddress) => UNSAFE_MiddlewareEnabled extends true ? MaybePromise<RouterContextProvider> : MaybePromise<AppLoadContext>;
-    mode?: string;
-}
-/**
- * Creates a request listener that handles requests using Node's built-in HTTP server.
- *
- * @param options Options for creating a request listener.
- * @returns A request listener that can be used with `http.createServer`.
- */
-declare function createRequestListener(options: RequestListenerOptions): RequestListener;
-
-interface FileSessionStorageOptions {
-    /**
-     * The Cookie used to store the session id on the client, or options used
-     * to automatically create one.
-     */
-    cookie?: SessionIdStorageStrategy["cookie"];
-    /**
-     * The directory to use to store session files.
-     */
-    dir: string;
-}
-/**
- * Creates a SessionStorage that stores session data on a filesystem.
- *
- * The advantage of using this instead of cookie session storage is that
- * files may contain much more data than cookies.
- *
- * @see https://api.reactrouter.com/v7/functions/_react-router_node.createFileSessionStorage
- */
-declare function createFileSessionStorage<Data = SessionData, FlashData = Data>({ cookie, dir, }: FileSessionStorageOptions): SessionStorage<Data, FlashData>;
-
-declare function writeReadableStreamToWritable(stream: ReadableStream, writable: Writable): Promise<void>;
-declare function writeAsyncIterableToWritable(iterable: AsyncIterable<Uint8Array>, writable: Writable): Promise<void>;
-declare function readableStreamToString(stream: ReadableStream<Uint8Array>, encoding?: BufferEncoding): Promise<string>;
-declare const createReadableStreamFromReadable: (source: Readable & {
-    readableHighWaterMark?: number;
-}) => ReadableStream<Uint8Array>;
-
-export { type RequestListenerOptions, createFileSessionStorage, createReadableStreamFromReadable, createRequestListener, readableStreamToString, writeAsyncIterableToWritable, writeReadableStreamToWritable };

package/dist/index.mjs

@@ -1,337 +0,0 @@
-/**
- * @react-router/node v7.18.0
- *
- * Copyright (c) Remix Software Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE.md file in the root directory of this source tree.
- *
- * @license MIT
- */
-
-// server.ts
-import { createRequestHandler } from "react-router";
-import { createRequestListener as createRequestListener_ } from "@mjackson/node-fetch-server";
-function createRequestListener(options) {
-  let handleRequest = createRequestHandler(options.build, options.mode);
-  return createRequestListener_(async (request, client) => {
-    let loadContext = await options.getLoadContext?.(request, client);
-    return handleRequest(request, loadContext);
-  });
-}
-
-// sessions/fileStorage.ts
-import { promises as fsp } from "fs";
-import * as path from "path";
-import { createSessionStorage } from "react-router";
-function createFileSessionStorage({
-  cookie,
-  dir
-}) {
-  return createSessionStorage({
-    cookie,
-    async createData(data, expires) {
-      let content = JSON.stringify({ data, expires });
-      while (true) {
-        let randomBytes = crypto.getRandomValues(new Uint8Array(8));
-        let id = Buffer.from(randomBytes).toString("hex");
-        try {
-          let file = getFile(dir, id);
-          if (!file) {
-            throw new Error("Error generating session");
-          }
-          await fsp.mkdir(path.dirname(file), { recursive: true });
-          await fsp.writeFile(file, content, { encoding: "utf-8", flag: "wx" });
-          return id;
-        } catch (error) {
-          if (error.code !== "EEXIST") throw error;
-        }
-      }
-    },
-    async readData(id) {
-      try {
-        let file = getFile(dir, id);
-        if (!file) {
-          return null;
-        }
-        let content = JSON.parse(await fsp.readFile(file, "utf-8"));
-        let data = content.data;
-        let expires = typeof content.expires === "string" ? new Date(content.expires) : null;
-        if (!expires || expires > /* @__PURE__ */ new Date()) {
-          return data;
-        }
-        if (expires) await fsp.unlink(file);
-        return null;
-      } catch (error) {
-        if (error.code !== "ENOENT") throw error;
-        return null;
-      }
-    },
-    async updateData(id, data, expires) {
-      let content = JSON.stringify({ data, expires });
-      let file = getFile(dir, id);
-      if (!file) {
-        return;
-      }
-      await fsp.mkdir(path.dirname(file), { recursive: true });
-      await fsp.writeFile(file, content, "utf-8");
-    },
-    async deleteData(id) {
-      if (!id) {
-        return;
-      }
-      let file = getFile(dir, id);
-      if (!file) {
-        return;
-      }
-      try {
-        await fsp.unlink(file);
-      } catch (error) {
-        if (error.code !== "ENOENT") throw error;
-      }
-    }
-  });
-}
-function getFile(dir, id) {
-  if (!/^[0-9a-f]{16}$/i.test(id)) {
-    return null;
-  }
-  return path.join(dir, id.slice(0, 4), id.slice(4));
-}
-
-// stream.ts
-import { Stream } from "stream";
-async function writeReadableStreamToWritable(stream, writable) {
-  let reader = stream.getReader();
-  let flushable = writable;
-  let writableError = monitorWritableError(writable);
-  try {
-    while (true) {
-      writableError.throwIfClosed();
-      let { done, value } = await writableError.race(reader.read());
-      if (done) {
-        writable.end();
-        break;
-      }
-      writableError.throwIfClosed();
-      let canContinueWriting = writable.write(value);
-      if (typeof flushable.flush === "function") {
-        flushable.flush();
-      }
-      if (!canContinueWriting) {
-        await waitForDrain(writable, writableError);
-      }
-    }
-  } catch (error) {
-    try {
-      reader.cancel(error).catch(() => {
-      });
-    } catch {
-    }
-    writable.destroy(error);
-    throw error;
-  } finally {
-    writableError.cleanup();
-    try {
-      reader.releaseLock();
-    } catch {
-    }
-  }
-}
-function monitorWritableError(writable) {
-  let settled = false;
-  let writableError;
-  let rejectWritableError;
-  let writableErrorPromise = new Promise((_, reject2) => {
-    rejectWritableError = reject2;
-  });
-  writableErrorPromise.catch(() => {
-  });
-  function cleanup() {
-    writable.off("error", onError);
-    writable.off("close", onClose);
-  }
-  function reject(error) {
-    if (settled) {
-      return;
-    }
-    settled = true;
-    writableError = error;
-    cleanup();
-    rejectWritableError(error);
-  }
-  function onError(error) {
-    reject(error);
-  }
-  function onClose() {
-    reject(new Error("Writable closed before stream finished"));
-  }
-  writable.once("error", onError);
-  writable.once("close", onClose);
-  return {
-    cleanup,
-    race(promise) {
-      return Promise.race([promise, writableErrorPromise]);
-    },
-    throwIfClosed() {
-      if (writableError) {
-        throw writableError;
-      }
-      if (writable.destroyed || writable.writableEnded) {
-        throw new Error("Cannot write to a destroyed or ended writable stream");
-      }
-    }
-  };
-}
-function waitForDrain(writable, writableError) {
-  let cleanup = () => {
-  };
-  let drainPromise = new Promise((resolve) => {
-    function onDrain() {
-      cleanup();
-      resolve();
-    }
-    cleanup = function cleanup2() {
-      writable.off("drain", onDrain);
-    };
-    writable.once("drain", onDrain);
-  });
-  return writableError.race(drainPromise).finally(cleanup);
-}
-async function writeAsyncIterableToWritable(iterable, writable) {
-  let writableError = monitorWritableError(writable);
-  let iterator = iterable[Symbol.asyncIterator]();
-  let completed = false;
-  try {
-    while (true) {
-      writableError.throwIfClosed();
-      let { done, value: chunk } = await writableError.race(iterator.next());
-      if (done) {
-        completed = true;
-        break;
-      }
-      writableError.throwIfClosed();
-      let canContinueWriting = writable.write(chunk);
-      if (!canContinueWriting) {
-        await waitForDrain(writable, writableError);
-      }
-    }
-    writable.end();
-  } catch (error) {
-    if (!completed) {
-      try {
-        Promise.resolve(iterator.return?.()).catch(() => {
-        });
-      } catch {
-      }
-    }
-    writable.destroy(error);
-    throw error;
-  } finally {
-    writableError.cleanup();
-  }
-}
-async function readableStreamToString(stream, encoding) {
-  let reader = stream.getReader();
-  let chunks = [];
-  while (true) {
-    let { done, value } = await reader.read();
-    if (done) {
-      break;
-    }
-    if (value) {
-      chunks.push(value);
-    }
-  }
-  return Buffer.concat(chunks).toString(encoding);
-}
-var createReadableStreamFromReadable = (source) => {
-  let pump = new StreamPump(source);
-  let stream = new ReadableStream(pump, pump);
-  return stream;
-};
-var StreamPump = class {
-  highWaterMark;
-  accumulatedSize;
-  stream;
-  controller;
-  constructor(stream) {
-    this.highWaterMark = stream.readableHighWaterMark || new Stream.Readable().readableHighWaterMark;
-    this.accumulatedSize = 0;
-    this.stream = stream;
-    this.enqueue = this.enqueue.bind(this);
-    this.error = this.error.bind(this);
-    this.close = this.close.bind(this);
-  }
-  size(chunk) {
-    return chunk?.byteLength || 0;
-  }
-  start(controller) {
-    this.controller = controller;
-    this.stream.on("data", this.enqueue);
-    this.stream.once("error", this.error);
-    this.stream.once("end", this.close);
-    this.stream.once("close", this.close);
-  }
-  pull() {
-    this.resume();
-  }
-  cancel(reason) {
-    if (this.stream.destroy) {
-      this.stream.destroy(reason);
-    }
-    this.stream.off("data", this.enqueue);
-    this.stream.off("error", this.error);
-    this.stream.off("end", this.close);
-    this.stream.off("close", this.close);
-  }
-  enqueue(chunk) {
-    if (this.controller) {
-      try {
-        let bytes = chunk instanceof Uint8Array ? chunk : Buffer.from(chunk);
-        let available = (this.controller.desiredSize || 0) - bytes.byteLength;
-        this.controller.enqueue(bytes);
-        if (available <= 0) {
-          this.pause();
-        }
-      } catch (e) {
-        this.controller.error(
-          new Error(
-            "Could not create Buffer, chunk must be of type string or an instance of Buffer, ArrayBuffer, or Array or an Array-like Object"
-          )
-        );
-        this.cancel();
-      }
-    }
-  }
-  pause() {
-    if (this.stream.pause) {
-      this.stream.pause();
-    }
-  }
-  resume() {
-    if (this.stream.readable && this.stream.resume) {
-      this.stream.resume();
-    }
-  }
-  close() {
-    if (this.controller) {
-      this.controller.close();
-      delete this.controller;
-    }
-  }
-  error(error) {
-    if (this.controller) {
-      this.controller.error(error);
-      delete this.controller;
-    }
-  }
-};
-export {
-  createFileSessionStorage,
-  createReadableStreamFromReadable,
-  createRequestListener,
-  readableStreamToString,
-  writeAsyncIterableToWritable,
-  writeReadableStreamToWritable
-};