@remix-run/node 1.0.4 → 1.1.1

package/README.md

@@ -0,0 +1,13 @@
+# Welcome to Remix!
+
+[Remix](https://remix.run) is a web framework that helps you build better websites with React.
+
+To get started, open a new shell and run:
+
+```sh
+$ npx create-remix@latest
+```
+
+Then follow the prompts you see in your terminal.
+
+For more information about Remix, [visit remix.run](https://remix.run)!

package/base64.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/node v1.0.4
+ * @remix-run/node v1.1.1
  *
  * Copyright (c) Remix Software Inc.
  *

package/cookieSigning.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/node v1.0.4
+ * @remix-run/node v1.1.1
  *
  * Copyright (c) Remix Software Inc.
  *

package/errors.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/node v1.0.4
+ * @remix-run/node v1.1.1
  *
  * Copyright (c) Remix Software Inc.
  *

package/fetch.d.ts

@@ -1,12 +1,19 @@
+import type AbortController from "abort-controller";
 import type { RequestInfo, RequestInit, Response } from "node-fetch";
-import { Request as NodeRequest } from "node-fetch";
-import { RemixFormData } from "./form-data";
-export type { HeadersInit, RequestInfo, RequestInit, ResponseInit } from "node-fetch";
+import { Request as BaseNodeRequest } from "node-fetch";
+import type { UploadHandler } from "./formData";
+export type { HeadersInit, RequestInfo, ResponseInit } from "node-fetch";
 export { Headers, Response } from "node-fetch";
-export declare class Request extends NodeRequest {
-    constructor(input: RequestInfo, init?: RequestInit | undefined);
-    formData(): Promise<RemixFormData>;
+interface NodeRequestInit extends RequestInit {
+    abortController?: AbortController;
 }
+declare class NodeRequest extends BaseNodeRequest {
+    private abortController?;
+    constructor(input: RequestInfo, init?: NodeRequestInit | undefined);
+    formData(uploadHandler?: UploadHandler): Promise<FormData>;
+    clone(): NodeRequest;
+}
+export { NodeRequest as Request, NodeRequestInit as RequestInit };
 /**
  * A `fetch` function for node that matches the web Fetch API. Based on
  * `node-fetch`.

package/fetch.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/node v1.0.4
+ * @remix-run/node v1.1.1
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -12,21 +12,99 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var stream = require('stream');
+var FormStream = require('form-data');
 var nodeFetch = require('node-fetch');
-var formData = require('./form-data.js');
+var formData = require('./formData.js');
+var parseMultipartFormData = require('./parseMultipartFormData.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
+var FormStream__default = /*#__PURE__*/_interopDefaultLegacy(FormStream);
 var nodeFetch__default = /*#__PURE__*/_interopDefaultLegacy(nodeFetch);
 
-class Request extends nodeFetch.Request {
+function formDataToStream(formData$1) {
+  let formStream = new FormStream__default["default"]();
+
+  function toNodeStream(input) {
+    // The input is either a Node stream or a web stream, if it has
+    //  a `on` method it's a node stream so we can just return it
+    if (typeof (input === null || input === void 0 ? void 0 : input.on) === "function") {
+      return input;
+    }
+
+    let passthrough = new stream.PassThrough();
+    let stream$1 = input;
+    let reader = stream$1.getReader();
+    reader.read().then(async ({
+      done,
+      value
+    }) => {
+      while (!done) {
+        passthrough.push(value);
+        ({
+          done,
+          value
+        } = await reader.read());
+      }
+
+      passthrough.push(null);
+    }).catch(error => {
+      passthrough.emit("error", error);
+    });
+    return passthrough;
+  }
+
+  for (let [key, value] of formData$1.entries()) {
+    if (typeof value === "string") {
+      formStream.append(key, value);
+    } else if (formData.isFile(value)) {
+      let stream = toNodeStream(value.stream());
+      formStream.append(key, stream, {
+        filename: value.name,
+        contentType: value.type,
+        knownLength: value.size
+      });
+    } else {
+      let file = value;
+      let stream = toNodeStream(file.stream());
+      formStream.append(key, stream, {
+        filename: "unknown"
+      });
+    }
+  }
+
+  return formStream;
+}
+
+class NodeRequest extends nodeFetch.Request {
   constructor(input, init) {
+    var _init;
+
+    if (((_init = init) === null || _init === void 0 ? void 0 : _init.body) instanceof formData.FormData) {
+      init = { ...init,
+        body: formDataToStream(init.body)
+      };
+    }
+
     super(input, init);
+    let anyInput = input;
+    let anyInit = init;
+    this.abortController = (anyInput === null || anyInput === void 0 ? void 0 : anyInput.abortController) || (anyInit === null || anyInit === void 0 ? void 0 : anyInit.abortController);
   }
 
-  async formData() {
-    let body = await this.clone().text();
-    return new formData.RemixFormData(body);
+  async formData(uploadHandler) {
+    let contentType = this.headers.get("Content-Type");
+
+    if (contentType) {
+      return await parseMultipartFormData.internalParseFormData(contentType, this.body, this.abortController, uploadHandler);
+    }
+
+    throw new Error("Invalid MIME type");
+  }
+
+  clone() {
+    return new NodeRequest(this);
   }
 
 }
@@ -39,13 +117,23 @@ class Request extends nodeFetch.Request {
  */
 
 function fetch(input, init) {
-  // Default to { compress: false } so responses can be proxied through more
-  // easily in loaders. Otherwise the response stream encoding will not match
-  // the Content-Encoding response header.
-  return nodeFetch__default["default"](input, {
+  var _init2;
+
+  init = {
     compress: false,
     ...init
-  });
+  };
+
+  if (((_init2 = init) === null || _init2 === void 0 ? void 0 : _init2.body) instanceof formData.FormData) {
+    init = { ...init,
+      body: formDataToStream(init.body)
+    };
+  } // Default to { compress: false } so responses can be proxied through more
+  // easily in loaders. Otherwise the response stream encoding will not match
+  // the Content-Encoding response header.
+
+
+  return nodeFetch__default["default"](input, init);
 }
 
 Object.defineProperty(exports, 'Headers', {
@@ -56,5 +144,5 @@ Object.defineProperty(exports, 'Response', {
   enumerable: true,
   get: function () { return nodeFetch.Response; }
 });
-exports.Request = Request;
+exports.Request = NodeRequest;
 exports.fetch = fetch;

package/{form-data.d.ts → formData.d.ts}

@@ -1,6 +1,17 @@
-export declare class RemixFormData implements FormData {
-    private _params;
-    constructor(body?: string);
+/// <reference types="node" />
+import type { Readable } from "stream";
+export declare type UploadHandlerArgs = {
+    name: string;
+    stream: Readable;
+    filename: string;
+    encoding: string;
+    mimetype: string;
+};
+export declare type UploadHandler = (args: UploadHandlerArgs) => Promise<string | File | undefined>;
+export declare function isFile(blob: Blob): blob is File;
+declare class NodeFormData implements FormData {
+    private _fields;
+    constructor(form?: any);
     append(name: string, value: string | Blob, fileName?: string): void;
     delete(name: string): void;
     get(name: string): FormDataEntryValue | null;
@@ -13,3 +24,4 @@ export declare class RemixFormData implements FormData {
     values(): IterableIterator<FormDataEntryValue>;
     [Symbol.iterator](): IterableIterator<[string, FormDataEntryValue]>;
 }
+export { NodeFormData as FormData };

package/formData.js

@@ -0,0 +1,108 @@
+/**
+ * @remix-run/node v1.1.1
+ *
+ * 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 });
+
+function isBlob(value) {
+  return typeof value === "object" && (typeof value.arrayBuffer === "function" || typeof value.size === "number" || typeof value.slice === "function" || typeof value.stream === "function" || typeof value.text === "function" || typeof value.type === "string");
+}
+
+function isFile(blob) {
+  let file = blob;
+  return typeof file.name === "string";
+}
+
+class NodeFormData {
+  constructor(form) {
+    if (typeof form !== "undefined") {
+      throw new Error("Form data on the server is not supported.");
+    }
+
+    this._fields = {};
+  }
+
+  append(name, value, fileName) {
+    if (typeof value !== "string" && !isBlob(value)) {
+      throw new Error("formData.append can only accept a string or Blob");
+    }
+
+    this._fields[name] = this._fields[name] || [];
+
+    if (typeof value === "string" || isFile(value)) {
+      this._fields[name].push(value);
+    } else {
+      this._fields[name].push(new File([value], fileName || "unknown"));
+    }
+  }
+
+  delete(name) {
+    delete this._fields[name];
+  }
+
+  get(name) {
+    let arr = this._fields[name];
+    return (arr === null || arr === void 0 ? void 0 : arr.slice(-1)[0]) || null;
+  }
+
+  getAll(name) {
+    let arr = this._fields[name];
+    return arr || [];
+  }
+
+  has(name) {
+    return name in this._fields;
+  }
+
+  set(name, value, fileName) {
+    if (typeof value !== "string" && !isBlob(value)) {
+      throw new Error("formData.set can only accept a string or Blob");
+    }
+
+    if (typeof value === "string" || isFile(value)) {
+      this._fields[name] = [value];
+    } else {
+      this._fields[name] = [new File([value], fileName || "unknown")];
+    }
+  }
+
+  forEach(callbackfn, thisArg) {
+    Object.entries(this._fields).forEach(([name, values]) => {
+      values.forEach(value => callbackfn(value, name, thisArg), thisArg);
+    });
+  }
+
+  entries() {
+    return Object.entries(this._fields).reduce((entries, [name, values]) => {
+      values.forEach(value => entries.push([name, value]));
+      return entries;
+    }, []).values();
+  }
+
+  keys() {
+    return Object.keys(this._fields).values();
+  }
+
+  values() {
+    return Object.entries(this._fields).reduce((results, [name, values]) => {
+      values.forEach(value => results.push(value));
+      return results;
+    }, []).values();
+  }
+
+  *[Symbol.iterator]() {
+    yield* this.entries();
+  }
+
+}
+
+exports.FormData = NodeFormData;
+exports.isFile = isFile;

package/globals.d.ts

@@ -2,13 +2,19 @@ import type { InternalSignFunctionDoNotUseMe, InternalUnsignFunctionDoNotUseMe }
 import { atob, btoa } from "./base64";
 declare global {
     namespace NodeJS {
+        interface ProcessEnv {
+            NODE_ENV: "development" | "production" | "test";
+        }
         interface Global {
             atob: typeof atob;
             btoa: typeof btoa;
+            Blob: typeof Blob;
+            File: typeof File;
             Headers: typeof Headers;
             Request: typeof Request;
             Response: typeof Response;
             fetch: typeof fetch;
+            FormData: typeof FormData;
             sign: InternalSignFunctionDoNotUseMe;
             unsign: InternalUnsignFunctionDoNotUseMe;
         }

package/globals.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/node v1.0.4
+ * @remix-run/node v1.1.1
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -12,18 +12,23 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var file = require('@web-std/file');
 var base64 = require('./base64.js');
 var cookieSigning = require('./cookieSigning.js');
 var fetch = require('./fetch.js');
+var formData = require('./formData.js');
 var nodeFetch = require('node-fetch');
 
 function installGlobals() {
   global.atob = base64.atob;
   global.btoa = base64.btoa;
+  global.Blob = file.Blob;
+  global.File = file.File;
   global.Headers = nodeFetch.Headers;
   global.Request = fetch.Request;
   global.Response = nodeFetch.Response;
   global.fetch = fetch.fetch;
+  global.FormData = formData.FormData;
   global.sign = cookieSigning.sign;
   global.unsign = cookieSigning.unsign;
 }

package/index.d.ts

@@ -1,5 +1,10 @@
+export { AbortController } from "abort-controller";
 export { formatServerError } from "./errors";
 export type { HeadersInit, RequestInfo, RequestInit, ResponseInit } from "./fetch";
 export { Headers, Request, Response, fetch } from "./fetch";
+export { FormData } from "./formData";
 export { installGlobals } from "./globals";
+export { parseMultipartFormData as unstable_parseMultipartFormData } from "./parseMultipartFormData";
 export { createFileSessionStorage } from "./sessions/fileStorage";
+export { createFileUploadHandler as unstable_createFileUploadHandler, NodeOnDiskFile } from "./upload/fileUploadHandler";
+export { createMemoryUploadHandler as unstable_createMemoryUploadHandler } from "./upload/memoryUploadHandler";

package/index.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/node v1.0.4
+ * @remix-run/node v1.1.1
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -12,19 +12,33 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var abortController = require('abort-controller');
 var errors = require('./errors.js');
 var fetch = require('./fetch.js');
+var formData = require('./formData.js');
 var globals = require('./globals.js');
+var parseMultipartFormData = require('./parseMultipartFormData.js');
 var fileStorage = require('./sessions/fileStorage.js');
+var fileUploadHandler = require('./upload/fileUploadHandler.js');
+var memoryUploadHandler = require('./upload/memoryUploadHandler.js');
 var nodeFetch = require('node-fetch');
 
 
 
+Object.defineProperty(exports, 'AbortController', {
+  enumerable: true,
+  get: function () { return abortController.AbortController; }
+});
 exports.formatServerError = errors.formatServerError;
 exports.Request = fetch.Request;
 exports.fetch = fetch.fetch;
+exports.FormData = formData.FormData;
 exports.installGlobals = globals.installGlobals;
+exports.unstable_parseMultipartFormData = parseMultipartFormData.parseMultipartFormData;
 exports.createFileSessionStorage = fileStorage.createFileSessionStorage;
+exports.NodeOnDiskFile = fileUploadHandler.NodeOnDiskFile;
+exports.unstable_createFileUploadHandler = fileUploadHandler.createFileUploadHandler;
+exports.unstable_createMemoryUploadHandler = memoryUploadHandler.createMemoryUploadHandler;
 Object.defineProperty(exports, 'Headers', {
   enumerable: true,
   get: function () { return nodeFetch.Headers; }

package/magicExports/{browser → esm}/platform.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/node v1.0.4
+ * @remix-run/node v1.1.1
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -8,4 +8,4 @@
  *
  * @license MIT
  */
-export { createFileSessionStorage } from '@remix-run/node';
+export { createFileSessionStorage, unstable_createFileUploadHandler, unstable_createMemoryUploadHandler, unstable_parseMultipartFormData } from '@remix-run/node';

package/magicExports/platform.d.ts

@@ -1 +1 @@
-export { createFileSessionStorage } from "@remix-run/node";
+export { createFileSessionStorage, unstable_createFileUploadHandler, unstable_createMemoryUploadHandler, unstable_parseMultipartFormData } from "@remix-run/node";

package/magicExports/platform.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/node v1.0.4
+ * @remix-run/node v1.1.1
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -17,6 +17,18 @@ var node = require('@remix-run/node');
 
 
 Object.defineProperty(exports, 'createFileSessionStorage', {
-	enumerable: true,
-	get: function () { return node.createFileSessionStorage; }
+  enumerable: true,
+  get: function () { return node.createFileSessionStorage; }
+});
+Object.defineProperty(exports, 'unstable_createFileUploadHandler', {
+  enumerable: true,
+  get: function () { return node.unstable_createFileUploadHandler; }
+});
+Object.defineProperty(exports, 'unstable_createMemoryUploadHandler', {
+  enumerable: true,
+  get: function () { return node.unstable_createMemoryUploadHandler; }
+});
+Object.defineProperty(exports, 'unstable_parseMultipartFormData', {
+  enumerable: true,
+  get: function () { return node.unstable_parseMultipartFormData; }
 });

package/package.json

@@ -1,16 +1,31 @@
 {
   "name": "@remix-run/node",
   "description": "Node.js platform abstractions for Remix",
-  "version": "1.0.4",
-  "repository": "https://github.com/remix-run/packages",
+  "version": "1.1.1",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/remix-run/remix",
+    "directory": "packages/remix-node"
+  },
+  "bugs": {
+    "url": "https://github.com/remix-run/remix/issues"
+  },
   "dependencies": {
-    "@remix-run/server-runtime": "1.0.4",
+    "@remix-run/server-runtime": "1.1.1",
+    "@types/busboy": "^0.3.1",
     "@types/node-fetch": "^2.5.12",
+    "@web-std/file": "^3.0.0",
+    "abort-controller": "^3.0.0",
+    "blob-stream": "^0.1.3",
+    "busboy": "^0.3.1",
     "cookie-signature": "^1.1.0",
+    "form-data": "^4.0.0",
     "node-fetch": "^2.6.1",
     "source-map": "^0.7.3"
   },
   "devDependencies": {
+    "@types/blob-stream": "^0.1.30",
     "@types/cookie-signature": "^1.0.3"
   },
   "sideEffects": false

package/parseMultipartFormData.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import { Readable } from "stream";
+import type { UploadHandler } from "./formData";
+import { FormData as NodeFormData } from "./formData";
+export declare function parseMultipartFormData(request: Request, uploadHandler: UploadHandler): Promise<FormData>;
+export declare function internalParseFormData(contentType: string, body: string | Buffer | Readable, abortController?: AbortController, uploadHandler?: UploadHandler): Promise<NodeFormData>;

package/parseMultipartFormData.js

@@ -0,0 +1,104 @@
+/**
+ * @remix-run/node v1.1.1
+ *
+ * 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 stream = require('stream');
+var Busboy = require('busboy');
+var formData = require('./formData.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var Busboy__default = /*#__PURE__*/_interopDefaultLegacy(Busboy);
+
+function parseMultipartFormData(request, uploadHandler) {
+  return request.formData(uploadHandler);
+}
+async function internalParseFormData(contentType, body, abortController, uploadHandler) {
+  let formData$1 = new formData.FormData();
+  let fileWorkQueue = [];
+  let stream$1;
+
+  if (typeof body === "string" || Buffer.isBuffer(body)) {
+    stream$1 = stream.Readable.from(body.toString());
+  } else {
+    stream$1 = body;
+  }
+
+  await new Promise(async (resolve, reject) => {
+    let busboy = new Busboy__default["default"]({
+      highWaterMark: 2 * 1024 * 1024,
+      headers: {
+        "content-type": contentType
+      }
+    });
+    let aborted = false;
+
+    function abort(error) {
+      if (aborted) return;
+      aborted = true;
+      stream$1.unpipe();
+      stream$1.removeAllListeners();
+      busboy.removeAllListeners();
+      abortController === null || abortController === void 0 ? void 0 : abortController.abort();
+      reject(error || new Error("failed to parse form data"));
+    }
+
+    busboy.on("field", (name, value) => {
+      formData$1.append(name, value);
+    });
+    busboy.on("file", (name, filestream, filename, encoding, mimetype) => {
+      if (uploadHandler) {
+        fileWorkQueue.push((async () => {
+          try {
+            let value = await uploadHandler({
+              name,
+              stream: filestream,
+              filename,
+              encoding,
+              mimetype
+            });
+
+            if (typeof value !== "undefined") {
+              formData$1.append(name, value);
+            }
+          } catch (error) {
+            // Emit error to busboy to bail early if possible
+            busboy.emit("error", error); // It's possible that the handler is doing stuff and fails
+            // *after* busboy has finished. Rethrow the error for surfacing
+            // in the Promise.all(fileWorkQueue) below.
+
+            throw error;
+          } finally {
+            filestream.resume();
+          }
+        })());
+      } else {
+        filestream.resume();
+      }
+
+      if (!uploadHandler) {
+        console.warn(`Tried to parse multipart file upload for field "${name}" but no uploadHandler was provided.` + " Read more here: https://remix.run/api/remix#parseMultipartFormData-node");
+      }
+    });
+    stream$1.on("error", abort);
+    stream$1.on("aborted", abort);
+    busboy.on("error", abort);
+    busboy.on("finish", resolve);
+    stream$1.pipe(busboy);
+  });
+  await Promise.all(fileWorkQueue);
+  return formData$1;
+}
+
+exports.internalParseFormData = internalParseFormData;
+exports.parseMultipartFormData = parseMultipartFormData;

package/sessions/fileStorage.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/node v1.0.4
+ * @remix-run/node v1.1.1
  *
  * Copyright (c) Remix Software Inc.
  *

package/upload/fileUploadHandler.d.ts

@@ -0,0 +1,60 @@
+/// <reference types="node" />
+import type { UploadHandler } from "../formData";
+export declare type FileUploadHandlerFilterArgs = {
+    filename: string;
+    encoding: string;
+    mimetype: string;
+};
+export declare type FileUploadHandlerPathResolverArgs = {
+    filename: string;
+    encoding: string;
+    mimetype: string;
+};
+/**
+ * Chooses the path of the file to be uploaded. If a string is not
+ * returned the file will not be written.
+ */
+export declare type FileUploadHandlerPathResolver = (args: FileUploadHandlerPathResolverArgs) => string | undefined;
+export declare 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).
+     */
+    maxFileSize?: number;
+    /**
+     *
+     * @param filename
+     * @param mimetype
+     * @param encoding
+     */
+    filter?(args: FileUploadHandlerFilterArgs): boolean | Promise<boolean>;
+};
+export declare function createFileUploadHandler({ directory, avoidFileConflicts, file, filter, maxFileSize }: FileUploadHandlerOptions): UploadHandler;
+export declare class NodeOnDiskFile implements File {
+    private filepath;
+    size: number;
+    type: string;
+    name: string;
+    lastModified: number;
+    webkitRelativePath: string;
+    constructor(filepath: string, size: number, type: string);
+    arrayBuffer(): Promise<ArrayBuffer>;
+    slice(start?: any, end?: any, contentType?: any): Blob;
+    stream(): ReadableStream<any>;
+    stream(): NodeJS.ReadableStream;
+    text(): Promise<string>;
+}

package/upload/fileUploadHandler.js

@@ -0,0 +1,159 @@
+/**
+ * @remix-run/node v1.1.1
+ *
+ * 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('crypto');
+var fs = require('fs');
+var fsp = require('fs/promises');
+var os = require('os');
+var path = require('path');
+var meter = require('./meter.js');
+
+let defaultFilePathResolver = ({
+  filename
+}) => {
+  let ext = filename ? path.extname(filename) : "";
+  return "upload_" + crypto.randomBytes(4).readUInt32LE(0) + ext;
+};
+
+async function uniqueFile(filepath) {
+  let ext = path.extname(filepath);
+  let uniqueFilepath = filepath;
+
+  for (let i = 1; await fsp.stat(uniqueFilepath).then(() => true).catch(() => false); i++) {
+    uniqueFilepath = (ext ? filepath.slice(0, -ext.length) : filepath) + `-${new Date().getTime()}${ext}`;
+  }
+
+  return uniqueFilepath;
+}
+
+function createFileUploadHandler({
+  directory = os.tmpdir(),
+  avoidFileConflicts = true,
+  file = defaultFilePathResolver,
+  filter,
+  maxFileSize = 3000000
+}) {
+  return async ({
+    name,
+    stream,
+    filename,
+    encoding,
+    mimetype
+  }) => {
+    if (filter && !(await filter({
+      filename,
+      encoding,
+      mimetype
+    }))) {
+      stream.resume();
+      return;
+    }
+
+    let dir = typeof directory === "string" ? directory : directory({
+      filename,
+      encoding,
+      mimetype
+    });
+
+    if (!dir) {
+      stream.resume();
+      return;
+    }
+
+    let filedir = path.resolve(dir);
+    let path$1 = typeof file === "string" ? file : file({
+      filename,
+      encoding,
+      mimetype
+    });
+
+    if (!path$1) {
+      stream.resume();
+      return;
+    }
+
+    let filepath = path.resolve(filedir, path$1);
+
+    if (avoidFileConflicts) {
+      filepath = await uniqueFile(filepath);
+    }
+
+    await fsp.mkdir(path.dirname(filepath), {
+      recursive: true
+    }).catch(() => {});
+    let meter$1 = new meter.Meter(name, maxFileSize);
+    await new Promise((resolve, reject) => {
+      let writeFileStream = fs.createWriteStream(filepath);
+      let aborted = false;
+
+      async function abort(error) {
+        if (aborted) return;
+        aborted = true;
+        stream.unpipe();
+        meter$1.unpipe();
+        stream.removeAllListeners();
+        meter$1.removeAllListeners();
+        writeFileStream.removeAllListeners();
+        await fsp.rm(filepath, {
+          force: true
+        }).catch(() => {});
+        reject(error);
+      }
+
+      stream.on("error", abort);
+      meter$1.on("error", abort);
+      writeFileStream.on("error", abort);
+      writeFileStream.on("finish", resolve);
+      stream.pipe(meter$1).pipe(writeFileStream);
+    });
+    return new NodeOnDiskFile(filepath, meter$1.bytes, mimetype);
+  };
+}
+class NodeOnDiskFile {
+  lastModified = 0;
+  webkitRelativePath = "";
+
+  constructor(filepath, size, type) {
+    this.filepath = filepath;
+    this.size = size;
+    this.type = type;
+    this.name = path.basename(filepath);
+  }
+
+  async arrayBuffer() {
+    let stream = fs.createReadStream(this.filepath);
+    return new Promise((resolve, reject) => {
+      const buf = [];
+      stream.on("data", chunk => buf.push(chunk));
+      stream.on("end", () => resolve(Buffer.concat(buf)));
+      stream.on("error", err => reject(err));
+    });
+  }
+
+  slice(start, end, contentType) {
+    throw new Error("Method not implemented.");
+  }
+
+  stream() {
+    return fs.createReadStream(this.filepath);
+  }
+
+  text() {
+    return fsp.readFile(this.filepath, "utf-8");
+  }
+
+}
+
+exports.NodeOnDiskFile = NodeOnDiskFile;
+exports.createFileUploadHandler = createFileUploadHandler;

package/upload/memoryUploadHandler.d.ts

@@ -0,0 +1,21 @@
+import type { UploadHandler } from "../formData";
+export declare type MemoryUploadHandlerFilterArgs = {
+    filename: string;
+    encoding: string;
+    mimetype: string;
+};
+export declare type MemoryUploadHandlerOptions = {
+    /**
+     * The maximum upload size allowed. If the size is exceeded an error will be thrown.
+     * Defaults to 3000000B (3MB).
+     */
+    maxFileSize?: number;
+    /**
+     *
+     * @param filename
+     * @param mimetype
+     * @param encoding
+     */
+    filter?(args: MemoryUploadHandlerFilterArgs): boolean | Promise<boolean>;
+};
+export declare function createMemoryUploadHandler({ filter, maxFileSize }: MemoryUploadHandlerOptions): UploadHandler;

package/upload/memoryUploadHandler.js

@@ -0,0 +1,80 @@
+/**
+ * @remix-run/node v1.1.1
+ *
+ * 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 stream = require('stream');
+var file = require('@web-std/file');
+var meter = require('./meter.js');
+
+function createMemoryUploadHandler({
+  filter,
+  maxFileSize = 3000000
+}) {
+  return async ({
+    name,
+    stream,
+    filename,
+    encoding,
+    mimetype
+  }) => {
+    if (filter && !(await filter({
+      filename,
+      encoding,
+      mimetype
+    }))) {
+      stream.resume();
+      return;
+    }
+
+    let bufferStream = new BufferStream();
+    await new Promise((resolve, reject) => {
+      let meter$1 = new meter.Meter(name, maxFileSize);
+      let aborted = false;
+
+      async function abort(error) {
+        if (aborted) return;
+        aborted = true;
+        stream.unpipe();
+        meter$1.unpipe();
+        stream.removeAllListeners();
+        meter$1.removeAllListeners();
+        bufferStream.removeAllListeners();
+        reject(error);
+      }
+
+      stream.on("error", abort);
+      meter$1.on("error", abort);
+      bufferStream.on("error", abort);
+      bufferStream.on("finish", resolve);
+      stream.pipe(meter$1).pipe(bufferStream);
+    });
+    return new file.File(bufferStream.data, filename, {
+      type: mimetype
+    });
+  };
+}
+
+class BufferStream extends stream.Transform {
+  constructor() {
+    super();
+    this.data = [];
+  }
+
+  _transform(chunk, _, callback) {
+    this.data.push(chunk);
+    callback();
+  }
+
+}
+
+exports.createMemoryUploadHandler = createMemoryUploadHandler;

package/upload/meter.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import type { TransformCallback } from "stream";
+import { Transform } from "stream";
+export declare class Meter extends Transform {
+    field: string;
+    maxBytes: number | undefined;
+    bytes: number;
+    constructor(field: string, maxBytes: number | undefined);
+    _transform(chunk: any, _: BufferEncoding, callback: TransformCallback): void;
+}
+export declare class MeterError extends Error {
+    field: string;
+    maxBytes: number;
+    constructor(field: string, maxBytes: number);
+}

package/upload/meter.js

@@ -0,0 +1,47 @@
+/**
+ * @remix-run/node v1.1.1
+ *
+ * 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 stream = require('stream');
+
+class Meter extends stream.Transform {
+  constructor(field, maxBytes) {
+    super();
+    this.field = field;
+    this.maxBytes = maxBytes;
+    this.bytes = 0;
+  }
+
+  _transform(chunk, _, callback) {
+    this.bytes += chunk.length;
+    this.push(chunk);
+
+    if (typeof this.maxBytes === "number" && this.bytes > this.maxBytes) {
+      return callback(new MeterError(this.field, this.maxBytes));
+    }
+
+    callback();
+  }
+
+}
+class MeterError extends Error {
+  constructor(field, maxBytes) {
+    super(`Field "${field}" exceeded upload size of ${maxBytes} bytes.`);
+    this.field = field;
+    this.maxBytes = maxBytes;
+  }
+
+}
+
+exports.Meter = Meter;
+exports.MeterError = MeterError;

package/form-data.js

@@ -1,74 +0,0 @@
-/**
- * @remix-run/node v1.0.4
- *
- * 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 });
-
-class RemixFormData {
-  constructor(body) {
-    this._params = new URLSearchParams(body);
-  }
-
-  append(name, value, fileName) {
-    if (typeof value !== "string") {
-      throw new Error("formData.append can only accept a string");
-    }
-
-    this._params.append(name, value);
-  }
-
-  delete(name) {
-    this._params.delete(name);
-  }
-
-  get(name) {
-    return this._params.get(name);
-  }
-
-  getAll(name) {
-    return this._params.getAll(name);
-  }
-
-  has(name) {
-    return this._params.has(name);
-  }
-
-  set(name, value, fileName) {
-    if (typeof value !== "string") {
-      throw new Error("formData.set can only accept a string");
-    }
-
-    this._params.set(name, value);
-  }
-
-  forEach(callbackfn, thisArg) {
-    this._params.forEach(callbackfn, thisArg);
-  }
-
-  entries() {
-    return this._params.entries();
-  }
-
-  keys() {
-    return this._params.keys();
-  }
-
-  values() {
-    return this._params.values();
-  }
-
-  *[Symbol.iterator]() {
-    yield* this._params;
-  }
-
-}
-
-exports.RemixFormData = RemixFormData;