@react-router/node 7.0.0-pre.2 → 7.0.0-pre.4

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # `@remix-run/node`
 
+## 7.0.0-pre.4
+
+### Patch Changes
+
+- Updated dependencies:
+  - `react-router@7.0.0-pre.4`
+
+## 7.0.0-pre.3
+
+### Patch Changes
+
+- Updated dependencies:
+  - `react-router@7.0.0-pre.3`
+
 ## 7.0.0-pre.2
 
 ### Major Changes

package/dist/index.d.mts

@@ -0,0 +1,32 @@
+import { SessionData, SessionStorage, SessionIdStorageStrategy } from 'react-router';
+import { Writable, Readable } from 'node:stream';
+
+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://remix.run/utils/sessions#createfilesessionstorage-node
+ */
+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 { createFileSessionStorage, createReadableStreamFromReadable, readableStreamToString, writeAsyncIterableToWritable, writeReadableStreamToWritable };

package/dist/index.d.ts

@@ -1,2 +1,32 @@
-export { createFileSessionStorage } from "./sessions/fileStorage";
-export { createReadableStreamFromReadable, readableStreamToString, writeAsyncIterableToWritable, writeReadableStreamToWritable, } from "./stream";
+import { SessionData, SessionStorage, SessionIdStorageStrategy } from 'react-router';
+import { Writable, Readable } from 'node:stream';
+
+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://remix.run/utils/sessions#createfilesessionstorage-node
+ */
+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 { createFileSessionStorage, createReadableStreamFromReadable, readableStreamToString, writeAsyncIterableToWritable, writeReadableStreamToWritable };

package/dist/index.js

@@ -1,5 +1,5 @@
 /**
- * @react-router/node v7.0.0-pre.2
+ * @react-router/node v7.0.0-pre.4
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -8,17 +8,243 @@
  *
  * @license MIT
  */
-'use strict';
+"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);
 
-Object.defineProperty(exports, '__esModule', { value: true });
+// index.ts
+var react_router_node_exports = {};
+__export(react_router_node_exports, {
+  createFileSessionStorage: () => createFileSessionStorage,
+  createReadableStreamFromReadable: () => createReadableStreamFromReadable,
+  readableStreamToString: () => readableStreamToString,
+  writeAsyncIterableToWritable: () => writeAsyncIterableToWritable,
+  writeReadableStreamToWritable: () => writeReadableStreamToWritable
+});
+module.exports = __toCommonJS(react_router_node_exports);
 
-var fileStorage = require('./sessions/fileStorage.js');
-var stream = require('./stream.js');
+// sessions/fileStorage.ts
+var import_node_fs = require("fs");
+var path = __toESM(require("path"));
+var import_react_router = require("react-router");
+function createFileSessionStorage({
+  cookie,
+  dir
+}) {
+  return (0, import_react_router.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);
+          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);
+        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);
+      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;
+      }
+      try {
+        await import_node_fs.promises.unlink(getFile(dir, id));
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+    }
+  });
+}
+function getFile(dir, id) {
+  return path.join(dir, id.slice(0, 4), id.slice(4));
+}
 
-
-
-exports.createFileSessionStorage = fileStorage.createFileSessionStorage;
-exports.createReadableStreamFromReadable = stream.createReadableStreamFromReadable;
-exports.readableStreamToString = stream.readableStreamToString;
-exports.writeAsyncIterableToWritable = stream.writeAsyncIterableToWritable;
-exports.writeReadableStreamToWritable = stream.writeReadableStreamToWritable;
+// stream.ts
+var import_node_stream = require("stream");
+async function writeReadableStreamToWritable(stream, writable) {
+  let reader = stream.getReader();
+  let flushable = writable;
+  try {
+    while (true) {
+      let { done, value } = await reader.read();
+      if (done) {
+        writable.end();
+        break;
+      }
+      writable.write(value);
+      if (typeof flushable.flush === "function") {
+        flushable.flush();
+      }
+    }
+  } catch (error) {
+    writable.destroy(error);
+    throw error;
+  }
+}
+async function writeAsyncIterableToWritable(iterable, writable) {
+  try {
+    for await (let chunk of iterable) {
+      writable.write(chunk);
+    }
+    writable.end();
+  } catch (error) {
+    writable.destroy(error);
+    throw error;
+  }
+}
+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;
+  accumalatedSize;
+  stream;
+  controller;
+  constructor(stream) {
+    this.highWaterMark = stream.readableHighWaterMark || new import_node_stream.Stream.Readable().readableHighWaterMark;
+    this.accumalatedSize = 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 (error) {
+        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;
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createFileSessionStorage,
+  createReadableStreamFromReadable,
+  readableStreamToString,
+  writeAsyncIterableToWritable,
+  writeReadableStreamToWritable
+});

package/dist/{stream.js → index.mjs}

@@ -1,5 +1,5 @@
 /**
- * @react-router/node v7.0.0-pre.2
+ * @react-router/node v7.0.0-pre.4
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -8,21 +8,78 @@
  *
  * @license MIT
  */
-'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var node_stream = require('node:stream');
+// sessions/fileStorage.ts
+import { promises as fsp } from "node:fs";
+import * as path from "node: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);
+          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);
+        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);
+      await fsp.mkdir(path.dirname(file), { recursive: true });
+      await fsp.writeFile(file, content, "utf-8");
+    },
+    async deleteData(id) {
+      if (!id) {
+        return;
+      }
+      try {
+        await fsp.unlink(getFile(dir, id));
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+    }
+  });
+}
+function getFile(dir, id) {
+  return path.join(dir, id.slice(0, 4), id.slice(4));
+}
 
+// stream.ts
+import { Stream } from "node:stream";
 async function writeReadableStreamToWritable(stream, writable) {
   let reader = stream.getReader();
   let flushable = writable;
   try {
     while (true) {
-      let {
-        done,
-        value
-      } = await reader.read();
+      let { done, value } = await reader.read();
       if (done) {
         writable.end();
         break;
@@ -52,10 +109,7 @@ async function readableStreamToString(stream, encoding) {
   let reader = stream.getReader();
   let chunks = [];
   while (true) {
-    let {
-      done,
-      value
-    } = await reader.read();
+    let { done, value } = await reader.read();
     if (done) {
       break;
     }
@@ -65,14 +119,18 @@ async function readableStreamToString(stream, encoding) {
   }
   return Buffer.concat(chunks).toString(encoding);
 }
-const createReadableStreamFromReadable = source => {
+var createReadableStreamFromReadable = (source) => {
   let pump = new StreamPump(source);
   let stream = new ReadableStream(pump, pump);
   return stream;
 };
-class StreamPump {
+var StreamPump = class {
+  highWaterMark;
+  accumalatedSize;
+  stream;
+  controller;
   constructor(stream) {
-    this.highWaterMark = stream.readableHighWaterMark || new node_stream.Stream.Readable().readableHighWaterMark;
+    this.highWaterMark = stream.readableHighWaterMark || new Stream.Readable().readableHighWaterMark;
     this.accumalatedSize = 0;
     this.stream = stream;
     this.enqueue = this.enqueue.bind(this);
@@ -80,7 +138,7 @@ class StreamPump {
     this.close = this.close.bind(this);
   }
   size(chunk) {
-    return (chunk === null || chunk === void 0 ? void 0 : chunk.byteLength) || 0;
+    return chunk?.byteLength || 0;
   }
   start(controller) {
     this.controller = controller;
@@ -111,7 +169,11 @@ class StreamPump {
           this.pause();
         }
       } catch (error) {
-        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.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();
       }
     }
@@ -138,9 +200,11 @@ class StreamPump {
       delete this.controller;
     }
   }
-}
-
-exports.createReadableStreamFromReadable = createReadableStreamFromReadable;
-exports.readableStreamToString = readableStreamToString;
-exports.writeAsyncIterableToWritable = writeAsyncIterableToWritable;
-exports.writeReadableStreamToWritable = writeReadableStreamToWritable;
+};
+export {
+  createFileSessionStorage,
+  createReadableStreamFromReadable,
+  readableStreamToString,
+  writeAsyncIterableToWritable,
+  writeReadableStreamToWritable
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-router/node",
-  "version": "7.0.0-pre.2",
+  "version": "7.0.0-pre.4",
   "description": "Node.js platform abstractions for React Router",
   "bugs": {
     "url": "https://github.com/remix-run/react-router/issues"
@@ -11,12 +11,38 @@
     "directory": "packages/react-router-node"
   },
   "license": "MIT",
+  "types": "dist/index.d.ts",
   "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
+      "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"
+      }
+    },
+    "./install": {
+      "node": {
+        "types": "./dist/install.d.ts",
+        "module-sync": "./dist/install.mjs",
+        "default": "./dist/install.js"
+      },
+      "import": {
+        "types": "./dist/install.d.mts",
+        "default": "./dist/install.mjs"
+      },
+      "default": {
+        "types": "./dist/install.d.ts",
+        "default": "./dist/install.js"
+      }
     },
     "./package.json": "./package.json"
   },
@@ -24,6 +50,20 @@
     "./dist/install.js",
     "./dist/install.mjs"
   ],
+  "wireit": {
+    "build": {
+      "command": "tsup",
+      "files": [
+        "sessions/**",
+        "*.ts",
+        "tsconfig.json",
+        "package.json"
+      ],
+      "output": [
+        "dist/**"
+      ]
+    }
+  },
   "dependencies": {
     "@web3-storage/multipart-parser": "^1.0.0",
     "source-map-support": "^0.5.21",
@@ -32,12 +72,14 @@
   },
   "devDependencies": {
     "@types/source-map-support": "^0.5.4",
+    "tsup": "^8.3.0",
     "typescript": "^5.1.6",
-    "react-router": "7.0.0-pre.2"
+    "wireit": "0.14.9",
+    "react-router": "7.0.0-pre.4"
   },
   "peerDependencies": {
     "typescript": "^5.1.0",
-    "react-router": "7.0.0-pre.2"
+    "react-router": "7.0.0-pre.4"
   },
   "peerDependenciesMeta": {
     "typescript": {
@@ -57,6 +99,6 @@
     "README.md"
   ],
   "scripts": {
-    "tsc": "tsc"
+    "build": "wireit"
   }
 }

package/dist/sessions/fileStorage.d.ts

@@ -1,23 +0,0 @@
-import type { SessionStorage, SessionIdStorageStrategy, SessionData } from "react-router";
-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://remix.run/utils/sessions#createfilesessionstorage-node
- */
-export declare function createFileSessionStorage<Data = SessionData, FlashData = Data>({ cookie, dir, }: FileSessionStorageOptions): SessionStorage<Data, FlashData>;
-export declare function getFile(dir: string, id: string): string;
-export {};

package/dist/sessions/fileStorage.js

@@ -1,132 +0,0 @@
-/**
- * @react-router/node v7.0.0-pre.2
- *
- * 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
- */
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var node_fs = require('node:fs');
-var path = require('node:path');
-var reactRouter = require('react-router');
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n["default"] = e;
-  return Object.freeze(n);
-}
-
-var path__namespace = /*#__PURE__*/_interopNamespace(path);
-
-/**
- * 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://remix.run/utils/sessions#createfilesessionstorage-node
- */
-function createFileSessionStorage({
-  cookie,
-  dir
-}) {
-  return reactRouter.createSessionStorage({
-    cookie,
-    async createData(data, expires) {
-      let content = JSON.stringify({
-        data,
-        expires
-      });
-      while (true) {
-        let randomBytes = crypto.getRandomValues(new Uint8Array(8));
-        // This storage manages an id space of 2^64 ids, which is far greater
-        // than the maximum number of files allowed on an NTFS or ext4 volume
-        // (2^32). However, the larger id space should help to avoid collisions
-        // with existing ids when creating new sessions, which speeds things up.
-        let id = Buffer.from(randomBytes).toString("hex");
-        try {
-          let file = getFile(dir, id);
-          await node_fs.promises.mkdir(path__namespace.dirname(file), {
-            recursive: true
-          });
-          await 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);
-        let content = JSON.parse(await 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 > new Date()) {
-          return data;
-        }
-
-        // Remove expired session data.
-        if (expires) await 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);
-      await node_fs.promises.mkdir(path__namespace.dirname(file), {
-        recursive: true
-      });
-      await node_fs.promises.writeFile(file, content, "utf-8");
-    },
-    async deleteData(id) {
-      // Return early if the id is empty, otherwise we'll end up trying to
-      // unlink the dir, which will cause the EPERM error.
-      if (!id) {
-        return;
-      }
-      try {
-        await node_fs.promises.unlink(getFile(dir, id));
-      } catch (error) {
-        if (error.code !== "ENOENT") throw error;
-      }
-    }
-  });
-}
-function getFile(dir, id) {
-  // Divide the session id up into a directory (first 2 bytes) and filename
-  // (remaining 6 bytes) to reduce the chance of having very large directories,
-  // which should speed up file access. This is a maximum of 2^16 directories,
-  // each with 2^48 files.
-  return path__namespace.join(dir, id.slice(0, 4), id.slice(4));
-}
-
-exports.createFileSessionStorage = createFileSessionStorage;
-exports.getFile = getFile;

package/dist/stream.d.ts

@@ -1,9 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import type { Readable, Writable } from "node:stream";
-export declare function writeReadableStreamToWritable(stream: ReadableStream, writable: Writable): Promise<void>;
-export declare function writeAsyncIterableToWritable(iterable: AsyncIterable<Uint8Array>, writable: Writable): Promise<void>;
-export declare function readableStreamToString(stream: ReadableStream<Uint8Array>, encoding?: BufferEncoding): Promise<string>;
-export declare const createReadableStreamFromReadable: (source: Readable & {
-    readableHighWaterMark?: number;
-}) => ReadableStream<Uint8Array>;