@react-router/node 0.0.0-experimental-c0856287f

package/dist/implementations.d.ts

@@ -0,0 +1,4 @@
+export declare const createCookie: import("@react-router/server-runtime").CreateCookieFunction;
+export declare const createCookieSessionStorage: import("@react-router/server-runtime").CreateCookieSessionStorageFunction;
+export declare const createSessionStorage: import("@react-router/server-runtime").CreateSessionStorageFunction;
+export declare const createMemorySessionStorage: import("@react-router/server-runtime").CreateMemorySessionStorageFunction;

package/dist/implementations.js

@@ -0,0 +1,29 @@
+/**
+ * @react-router/node v0.0.0-experimental-c0856287f
+ *
+ * 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 serverRuntime = require('@react-router/server-runtime');
+var crypto = require('./crypto.js');
+
+const createCookie = serverRuntime.createCookieFactory({
+  sign: crypto.sign,
+  unsign: crypto.unsign
+});
+const createCookieSessionStorage = serverRuntime.createCookieSessionStorageFactory(createCookie);
+const createSessionStorage = serverRuntime.createSessionStorageFactory(createCookie);
+const createMemorySessionStorage = serverRuntime.createMemorySessionStorageFactory(createSessionStorage);
+
+exports.createCookie = createCookie;
+exports.createCookieSessionStorage = createCookieSessionStorage;
+exports.createMemorySessionStorage = createMemorySessionStorage;
+exports.createSessionStorage = createSessionStorage;

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { installGlobals } from "./globals";
+export { createFileSessionStorage } from "./sessions/fileStorage";
+export { createFileUploadHandler as unstable_createFileUploadHandler, NodeOnDiskFile, } from "./upload/fileUploadHandler";
+export { createCookie, createCookieSessionStorage, createMemorySessionStorage, createSessionStorage, } from "./implementations";
+export { createReadableStreamFromReadable, readableStreamToString, writeAsyncIterableToWritable, writeReadableStreamToWritable, } from "./stream";
+export { createRequestHandler, createSession, defer, isCookie, isSession, json, MaxPartSizeExceededError, redirect, redirectDocument, unstable_composeUploadHandlers, unstable_createMemoryUploadHandler, unstable_parseMultipartFormData, } from "@react-router/server-runtime";
+export type { ActionFunction, ActionFunctionArgs, AppLoadContext, Cookie, CookieOptions, CookieParseOptions, CookieSerializeOptions, CookieSignatureOptions, DataFunctionArgs, EntryContext, ErrorResponse, HandleDataRequestFunction, HandleDocumentRequestFunction, HeadersArgs, HeadersFunction, HtmlLinkDescriptor, JsonFunction, LinkDescriptor, LinksFunction, LoaderFunction, LoaderFunctionArgs, MemoryUploadHandlerFilterArgs, MemoryUploadHandlerOptions, HandleErrorFunction, PageLinkDescriptor, RequestHandler, SerializeFrom, ServerBuild, ServerEntryModule, ServerRuntimeMetaArgs as MetaArgs, ServerRuntimeMetaDescriptor as MetaDescriptor, ServerRuntimeMetaFunction as MetaFunction, Session, SessionData, SessionIdStorageStrategy, SessionStorage, SignFunction, TypedDeferredData, TypedResponse, UnsignFunction, UploadHandler, UploadHandlerPart, } from "@react-router/server-runtime";

package/dist/index.js

@@ -0,0 +1,83 @@
+/**
+ * @react-router/node v0.0.0-experimental-c0856287f
+ *
+ * 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 globals = require('./globals.js');
+var fileStorage = require('./sessions/fileStorage.js');
+var fileUploadHandler = require('./upload/fileUploadHandler.js');
+var implementations = require('./implementations.js');
+var stream = require('./stream.js');
+var serverRuntime = require('@react-router/server-runtime');
+
+
+
+exports.installGlobals = globals.installGlobals;
+exports.createFileSessionStorage = fileStorage.createFileSessionStorage;
+exports.NodeOnDiskFile = fileUploadHandler.NodeOnDiskFile;
+exports.unstable_createFileUploadHandler = fileUploadHandler.createFileUploadHandler;
+exports.createCookie = implementations.createCookie;
+exports.createCookieSessionStorage = implementations.createCookieSessionStorage;
+exports.createMemorySessionStorage = implementations.createMemorySessionStorage;
+exports.createSessionStorage = implementations.createSessionStorage;
+exports.createReadableStreamFromReadable = stream.createReadableStreamFromReadable;
+exports.readableStreamToString = stream.readableStreamToString;
+exports.writeAsyncIterableToWritable = stream.writeAsyncIterableToWritable;
+exports.writeReadableStreamToWritable = stream.writeReadableStreamToWritable;
+Object.defineProperty(exports, 'MaxPartSizeExceededError', {
+	enumerable: true,
+	get: function () { return serverRuntime.MaxPartSizeExceededError; }
+});
+Object.defineProperty(exports, 'createRequestHandler', {
+	enumerable: true,
+	get: function () { return serverRuntime.createRequestHandler; }
+});
+Object.defineProperty(exports, 'createSession', {
+	enumerable: true,
+	get: function () { return serverRuntime.createSession; }
+});
+Object.defineProperty(exports, 'defer', {
+	enumerable: true,
+	get: function () { return serverRuntime.defer; }
+});
+Object.defineProperty(exports, 'isCookie', {
+	enumerable: true,
+	get: function () { return serverRuntime.isCookie; }
+});
+Object.defineProperty(exports, 'isSession', {
+	enumerable: true,
+	get: function () { return serverRuntime.isSession; }
+});
+Object.defineProperty(exports, 'json', {
+	enumerable: true,
+	get: function () { return serverRuntime.json; }
+});
+Object.defineProperty(exports, 'redirect', {
+	enumerable: true,
+	get: function () { return serverRuntime.redirect; }
+});
+Object.defineProperty(exports, 'redirectDocument', {
+	enumerable: true,
+	get: function () { return serverRuntime.redirectDocument; }
+});
+Object.defineProperty(exports, 'unstable_composeUploadHandlers', {
+	enumerable: true,
+	get: function () { return serverRuntime.unstable_composeUploadHandlers; }
+});
+Object.defineProperty(exports, 'unstable_createMemoryUploadHandler', {
+	enumerable: true,
+	get: function () { return serverRuntime.unstable_createMemoryUploadHandler; }
+});
+Object.defineProperty(exports, 'unstable_parseMultipartFormData', {
+	enumerable: true,
+	get: function () { return serverRuntime.unstable_parseMultipartFormData; }
+});

package/dist/sessions/fileStorage.d.ts

@@ -0,0 +1,23 @@
+import type { SessionStorage, SessionIdStorageStrategy, SessionData } from "@react-router/server-runtime";
+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

@@ -0,0 +1,135 @@
+/**
+ * @react-router/node v0.0.0-experimental-c0856287f
+ *
+ * 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 crypto = require('node:crypto');
+var node_fs = require('node:fs');
+var path = require('node:path');
+var implementations = require('../implementations.js');
+
+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 crypto__namespace = /*#__PURE__*/_interopNamespace(crypto);
+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 implementations.createSessionStorage({
+    cookie,
+    async createData(data, expires) {
+      let content = JSON.stringify({
+        data,
+        expires
+      });
+      while (true) {
+        // TODO: Once Node v19 is supported we should use the globally provided
+        // Web Crypto API's crypto.getRandomValues() function here instead.
+        let randomBytes = crypto__namespace.webcrypto.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

@@ -0,0 +1,9 @@
+/// <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>;

package/dist/stream.js

@@ -0,0 +1,146 @@
+/**
+ * @react-router/node v0.0.0-experimental-c0856287f
+ *
+ * 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_stream = require('node: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);
+}
+const createReadableStreamFromReadable = source => {
+  let pump = new StreamPump(source);
+  let stream = new ReadableStream(pump, pump);
+  return stream;
+};
+class StreamPump {
+  constructor(stream) {
+    this.highWaterMark = stream.readableHighWaterMark || new 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 === null || chunk === void 0 ? void 0 : 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;
+    }
+  }
+}
+
+exports.createReadableStreamFromReadable = createReadableStreamFromReadable;
+exports.readableStreamToString = readableStreamToString;
+exports.writeAsyncIterableToWritable = writeAsyncIterableToWritable;
+exports.writeReadableStreamToWritable = writeReadableStreamToWritable;

package/dist/upload/fileUploadHandler.d.ts

@@ -0,0 +1,68 @@
+/// <reference types="node" />
+import type { UploadHandler } from "@react-router/server-runtime";
+export type FileUploadHandlerFilterArgs = {
+    filename: string;
+    contentType: string;
+    name: string;
+};
+export type FileUploadHandlerPathResolverArgs = {
+    filename: string;
+    contentType: string;
+    name: string;
+};
+/**
+ * Chooses the path of the file to be uploaded. If a string is not
+ * returned the file will not be written.
+ */
+export type FileUploadHandlerPathResolver = (args: FileUploadHandlerPathResolverArgs) => string | undefined;
+export type FileUploadHandlerOptions = {
+    /**
+     * Avoid file conflicts by appending a count on the end of the filename
+     * if it already exists on disk. Defaults to `true`.
+     */
+    avoidFileConflicts?: boolean;
+    /**
+     * The directory to write the upload.
+     */
+    directory?: string | FileUploadHandlerPathResolver;
+    /**
+     * The name of the file in the directory. Can be a relative path, the directory
+     * structure will be created if it does not exist.
+     */
+    file?: FileUploadHandlerPathResolver;
+    /**
+     * The maximum upload size allowed. If the size is exceeded an error will be thrown.
+     * Defaults to 3000000B (3MB).
+     */
+    maxPartSize?: number;
+    /**
+     *
+     * @param filename
+     * @param contentType
+     * @param name
+     */
+    filter?(args: FileUploadHandlerFilterArgs): boolean | Promise<boolean>;
+};
+export declare function createFileUploadHandler({ directory, avoidFileConflicts, file, filter, maxPartSize, }?: FileUploadHandlerOptions): UploadHandler;
+export declare class NodeOnDiskFile implements Omit<File, "constructor"> {
+    private filepath;
+    type: string;
+    private slicer?;
+    name: string;
+    lastModified: number;
+    webkitRelativePath: string;
+    prototype: File;
+    constructor(filepath: string, type: string, slicer?: {
+        start: number;
+        end: number;
+    } | undefined);
+    get size(): number;
+    slice(start?: number, end?: number, type?: string): Blob;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    stream(): ReadableStream<any>;
+    stream(): NodeJS.ReadableStream;
+    text(): Promise<string>;
+    get [Symbol.toStringTag](): string;
+    remove(): Promise<void>;
+    getFilePath(): string;
+}