Web APIs: File and FormData

BUILD.gn

@@ -78,9 +78,11 @@ ts_sources = [
   "js/dom_types.ts",
   "js/errors.ts",
   "js/fetch.ts",
+  "js/file.ts",
   "js/file_info.ts",
   "js/files.ts",
   "js/flatbuffers.ts",
+  "js/form_data.ts",
   "js/global_eval.ts",
   "js/globals.ts",
   "js/io.ts",

js/blob.ts

@@ -97,6 +97,12 @@ function toUint8Arrays(
       ret.push(element[bytesSymbol]);
     } else if (element instanceof Uint8Array) {
       ret.push(element);
+    } else if (element instanceof Uint16Array) {
+      const uint8 = new Uint8Array(element.buffer);
+      ret.push(uint8);
+    } else if (element instanceof Uint32Array) {
+      const uint8 = new Uint8Array(element.buffer);
+      ret.push(uint8);
     } else if (ArrayBuffer.isView(element)) {
       // Convert view to Uint8Array.
       const uint8 = new Uint8Array(element.buffer);
@@ -105,6 +111,8 @@ function toUint8Arrays(
       // Create a new Uint8Array view for the given ArrayBuffer.
       const uint8 = new Uint8Array(element);
       ret.push(uint8);
+    } else {
+      ret.push(enc.encode(String(element)));
     }
   }
   return ret;

js/dom_types.ts

@@ -31,7 +31,7 @@ type ReferrerPolicy =
   | "origin-when-cross-origin"
   | "unsafe-url";
 export type BlobPart = BufferSource | Blob | string;
-type FormDataEntryValue = File | string;
+export type FormDataEntryValue = File | string;
 export type EventListenerOrEventListenerObject =
   | EventListener
   | EventListenerObject;
@@ -158,7 +158,7 @@ interface Event {
   readonly NONE: number;
 }
 
-interface File extends Blob {
+export interface File extends Blob {
   readonly lastModified: number;
   readonly name: string;
 }

js/file.ts

@@ -0,0 +1,24 @@
+// Copyright 2018 the Deno authors. All rights reserved. MIT license.
+import * as domTypes from "./dom_types";
+import { DenoBlob } from "./blob";
+
+export class DenoFile extends DenoBlob implements domTypes.File {
+  lastModified: number;
+  name: string;
+
+  constructor(
+    fileBits: domTypes.BlobPart[],
+    fileName: string,
+    options?: domTypes.FilePropertyBag
+  ) {
+    options = options || {};
+    super(fileBits, options);
+
+    // 4.1.2.1 Replace any "/" character (U+002F SOLIDUS)
+    // with a ":" (U + 003A COLON)
+    this.name = String(fileName).replace(/\u002F/g, "\u003A");
+    // 4.1.3.3 If lastModified is not provided, set lastModified to the current
+    // date and time represented in number of milliseconds since the Unix Epoch.
+    this.lastModified = options.lastModified || Date.now();
+  }
+}

js/file_test.ts

@@ -0,0 +1,106 @@
+// Copyright 2018 the Deno authors. All rights reserved. MIT license.
+import { test, assert, assertEqual } from "./test_util.ts";
+import { DenoFile } from "./file.ts";
+import { DenoBlob } from "./blob.ts";
+
+function testFirstArgument(arg1, expectedSize) {
+  const file = new DenoFile(arg1, "name");
+  assert(file instanceof DenoFile);
+  assertEqual(file.name, "name");
+  assertEqual(file.size, expectedSize);
+  assertEqual(file.type, "");
+}
+
+test(function fileEmptyFileBits() {
+  testFirstArgument([], 0);
+});
+
+test(function fileStringFileBits() {
+  testFirstArgument(["bits"], 4);
+});
+
+test(function fileUnicodeStringFileBits() {
+  testFirstArgument(["𝓽𝓮𝔁𝓽"], 16);
+});
+
+test(function fileStringObjectFileBits() {
+  // tslint:disable-next-line no-construct
+  testFirstArgument([new String("string object")], 13);
+});
+
+test(function fileEmptyBlobFileBits() {
+  testFirstArgument([new DenoBlob()], 0);
+});
+
+test(function fileBlobFileBits() {
+  testFirstArgument([new DenoBlob(["bits"])], 4);
+});
+
+test(function fileEmptyFileFileBits() {
+  testFirstArgument([new DenoFile([], "world.txt")], 0);
+});
+
+test(function fileFileFileBits() {
+  testFirstArgument([new DenoFile(["bits"], "world.txt")], 4);
+});
+
+test(function fileArrayBufferFileBits() {
+  testFirstArgument([new ArrayBuffer(8)], 8);
+});
+
+test(function fileTypedArrayFileBits() {
+  testFirstArgument([new Uint8Array([0x50, 0x41, 0x53, 0x53])], 4);
+});
+
+test(function fileVariousFileBits() {
+  testFirstArgument(
+    [
+      "bits",
+      new DenoBlob(["bits"]),
+      new DenoBlob(),
+      new Uint8Array([0x50, 0x41]),
+      new Uint16Array([0x5353]),
+      new Uint32Array([0x53534150])
+    ],
+    16
+  );
+});
+
+test(function fileNumberInFileBits() {
+  testFirstArgument([12], 2);
+});
+
+test(function fileArrayInFileBits() {
+  testFirstArgument([[1, 2, 3]], 5);
+});
+
+test(function fileObjectInFileBits() {
+  // "[object Object]"
+  testFirstArgument([{}], 15);
+});
+
+function testSecondArgument(arg2, expectedFileName) {
+  const file = new DenoFile(["bits"], arg2);
+  assert(file instanceof DenoFile);
+  assertEqual(file.name, expectedFileName);
+}
+
+test(function fileUsingFileName() {
+  testSecondArgument("dummy", "dummy");
+});
+
+test(function fileUsingSpecialCharacterInFileName() {
+  testSecondArgument("dummy/foo", "dummy:foo");
+});
+
+test(function fileUsingNullFileName() {
+  testSecondArgument(null, "null");
+});
+
+test(function fileUsingNumberFileName() {
+  testSecondArgument(1, "1");
+});
+
+test(function fileUsingEmptyStringFileName() {
+  testSecondArgument("", "");
+});

js/form_data.ts

@@ -0,0 +1,173 @@
+// Copyright 2018 the Deno authors. All rights reserved. MIT license.
+import * as domTypes from "./dom_types";
+import { CreateIterableIterator } from "./util";
+import { DenoBlob } from "./blob";
+import { DenoFile } from "./file";
+
+export class FormData implements domTypes.FormData {
+  private data: Array<[string, domTypes.FormDataEntryValue]> = [];
+
+  /** Appends a new value onto an existing key inside a `FormData`
+   * object, or adds the key if it does not already exist.
+   *
+   *       formData.append('name', 'first');
+   *       formData.append('name', 'second');
+   */
+  append(name: string, value: string): void;
+  append(name: string, value: DenoBlob, filename?: string): void;
+  append(name: string, value: string | DenoBlob, filename?: string): void {
+    if (value instanceof DenoBlob) {
+      const file = new DenoFile([value], filename || name);
+      this.data.push([name, file]);
+    } else {
+      this.data.push([name, value]);
+    }
+  }
+
+  /** Deletes a key/value pair from a `FormData` object.
+   *
+   *       formData.delete('name');
+   */
+  delete(name: string): void {
+    let i = 0;
+    while (i < this.data.length) {
+      if (this.data[i][0] === name) {
+        this.data.splice(i, 1);
+      } else {
+        i++;
+      }
+    }
+  }
+
+  /** Returns an array of all the values associated with a given key
+   * from within a `FormData`.
+   *
+   *       formData.getAll('name');
+   */
+  getAll(name: string): domTypes.FormDataEntryValue[] {
+    const values = [];
+    for (const entry of this.data) {
+      if (entry[0] === name) {
+        values.push(entry[1]);
+      }
+    }
+
+    return values;
+  }
+
+  /** Returns the first value associated with a given key from within a
+   * `FormData` object.
+   *
+   *       formData.get('name');
+   */
+  get(name: string): domTypes.FormDataEntryValue | null {
+    for (const entry of this.data) {
+      if (entry[0] === name) {
+        return entry[1];
+      }
+    }
+
+    return null;
+  }
+
+  /** Returns a boolean stating whether a `FormData` object contains a
+   * certain key/value pair.
+   *
+   *       formData.has('name');
+   */
+  has(name: string): boolean {
+    return this.data.some(entry => entry[0] === name);
+  }
+
+  /** Sets a new value for an existing key inside a `FormData` object, or
+   * adds the key/value if it does not already exist.
+   *
+   *       formData.set('name', 'value');
+   */
+  set(name: string, value: string): void;
+  set(name: string, value: DenoBlob, filename?: string): void;
+  set(name: string, value: string | DenoBlob, filename?: string): void {
+    this.delete(name);
+    if (value instanceof DenoBlob) {
+      const file = new DenoFile([value], filename || name);
+      this.data.push([name, file]);
+    } else {
+      this.data.push([name, value]);
+    }
+  }
+
+  /** Calls a function for each element contained in this object in
+   * place and return undefined. Optionally accepts an object to use
+   * as this when executing callback as second argument.
+   *
+   *       formData.forEach((value, key, parent) => {
+   *         console.log(value, key, parent);
+   *       });
+   */
+  forEach(
+    callbackfn: (
+      value: domTypes.FormDataEntryValue,
+      key: string,
+      parent: FormData
+    ) => void,
+    // tslint:disable-next-line:no-any
+    thisArg?: any
+  ) {
+    if (typeof thisArg !== "undefined") {
+      callbackfn = callbackfn.bind(thisArg);
+    }
+    for (const [key, value] of this.entries()) {
+      callbackfn(value, key, this);
+    }
+  }
+
+  /** Returns an iterator allowing to go through all keys contained
+   * in this object.
+   *
+   *       for (const key of formData.keys()) {
+   *         console.log(key);
+   *       }
+   */
+  keys(): IterableIterator<string> {
+    const list = this.data.map(entry => entry[0]);
+    const iterators = list.values();
+    return new CreateIterableIterator(iterators);
+  }
+
+  /** Returns an iterator allowing to go through all values contained
+   * in this object.
+   *
+   *       for (const value of formData.values()) {
+   *         console.log(value);
+   *       }
+   */
+  values(): IterableIterator<domTypes.FormDataEntryValue> {
+    const list = this.data.map(entry => entry[1]);
+    const iterators = list.values();
+    return new CreateIterableIterator(iterators);
+  }
+
+  /** Returns an iterator allowing to go through all key/value
+   * pairs contained in this object.
+   *
+   *       for (const [key, value] of formData.entries()) {
+   *         console.log(key, value);
+   *       }
+   */
+  entries(): IterableIterator<[string, domTypes.FormDataEntryValue]> {
+    const iterators = this.data.values();
+    return new CreateIterableIterator(iterators);
+  }
+
+  /** Returns an iterator allowing to go through all key/value
+   * pairs contained in this object.
+   *
+   *       for (const [key, value] of formData[Symbol.iterator]()) {
+   *         console.log(key, value);
+   *       }
+   */
+  [Symbol.iterator](): IterableIterator<[string, domTypes.FormDataEntryValue]> {
+    const iterators = this.data.values();
+    return new CreateIterableIterator(iterators);
+  }
+}