Add double

Author: domenic

README.md

@@ -26,10 +26,12 @@ This package's main module's default export is an object with a variety of metho
 
 ## Status
 
-So far only `boolean` and `DOMString` types are implemented. This list will grow over time in service of the [HTML as Custom Elements](https://github.com/dglazkov/html-as-custom-elements) project, but in the meantime, pull requests welcome!
+So far only `boolean`, `DOMString`, and `double` types are implemented. This list will grow over time in service of the [HTML as Custom Elements](https://github.com/dglazkov/html-as-custom-elements) project, but in the meantime, pull requests welcome!
 
 I'm not sure yet what the strategy will be for modifiers, e.g. [`[Clamp]`](http://heycam.github.io/webidl/#Clamp). Maybe something like `conversions["unsigned long"](x, { clamp: true })`? We'll see.
 
+We might also want to extend the API to give better error messages, e.g. "Argument 1 of HTMLMediaElement.fastSeek is not a finite floating-point value" instead of "Argument is not a finite floating-point value." This would require passing in more information to the conversion functions than we currently do.
+
 ## Background
 
 What's actually going on here, conceptually, is pretty weird. Let's try to explain.

lib/index.js

@@ -2,6 +2,18 @@ var conversions = {};
 export default conversions;
 
 var global_String = String;
+var Number_isFinite = Number.isFinite;
 
 conversions["boolean"] = val => !!val;
+
 conversions["DOMString"] = val => global_String(val);
+
+conversions["double"] = val => {
+    var asNumber = +val;
+
+    if (!Number_isFinite(asNumber)) {
+        throw new TypeError("Argument is not a finite floating-point value.");
+    }
+
+    return asNumber;
+};

test/dom-string.js

@@ -37,9 +37,7 @@ describe("WebIDL DOMString type", () => {
     });
 
     it("should throw a TypeError for a symbol", () => {
-        assert.throws(() => {
-            sut(new Symbol());
-        }, TypeError);
+        assert.throws(() => sut(new Symbol()), TypeError);
     });
 
     it("should prefer toString to valueOf on objects", () => {

test/double.js

@@ -0,0 +1,70 @@
+var assert = require("assert");
+
+import conversions from "..";
+
+// Adapted pretty directly from
+// https://github.com/marcoscaceres/webidl.js/blob/e631bcf2c1ba2d3ea283f5a39ed7bd1470743552/test/WebIDL.Double-tests.js
+
+describe("WebIDL double type", () => {
+    var sut = conversions["double"];
+
+    it("should return `0` for `0`", () => {
+        assert.strictEqual(sut(0), 0);
+    });
+
+    it("should return `42` for `42`", () => {
+        assert.strictEqual(sut(42), 42);
+    });
+
+    it("should return `0` for `null`", () => {
+        assert.strictEqual(sut(null), 0);
+    });
+
+    it("should return `0` for `\"\"`", () => {
+        assert.strictEqual(sut(""), 0);
+    });
+
+    it("should return `0` for `false`", () => {
+        assert.strictEqual(sut(0), 0);
+    });
+
+    it("should return `1` for `true`", () => {
+        assert.strictEqual(sut(null), 0);
+    });
+
+    it("should return `0` for random whitespace", () => {
+        assert.strictEqual(sut(" \t\n\t "), 0);
+    });
+
+    it("should return `123` for `\" 123 \"`", () => {
+        assert.strictEqual(sut(" 123 "), 123);
+    });
+
+    it("should return `-123.123` for `\" -123.123 \"`", () => {
+        assert.strictEqual(sut(" -123.123 "), -123.123);
+    });
+
+    it("should throw a TypeError for no argument", () => {
+        assert.throws(() => sut(), TypeError);
+    });
+
+    it("should throw a TypeError for `undefined`", () => {
+        assert.throws(() => sut(undefined), TypeError);
+    });
+
+    it("should throw a TypeError for `NaN`", () => {
+        assert.throws(() => sut(NaN), TypeError);
+    });
+
+    it("should throw a TypeError for `+Infinity`", () => {
+        assert.throws(() => sut(+Infinity), TypeError);
+    });
+
+    it("should throw a TypeError for `-Infinity`", () => {
+        assert.throws(() => sut(-Infinity), TypeError);
+    });
+
+    it("should throw a TypeError for `\" 123,123 \"` (since it becomes `NaN`)", () => {
+        assert.throws(() => sut(" 123,123 "), TypeError);
+    });
+});