style: apply prettier (#564)

Author: saschanaz

.eslintrc.json

@@ -1,25 +1,25 @@
 {
-    "env": {
-        "browser": true,
-        "commonjs": true,
-        "es2020": true,
-        "node": true,
-        "mocha": true
-    },
-    "extends": "eslint:recommended",
-    "plugins": ["import"],
-    "rules": {
-        "eol-last": "error",
-        "import/extensions": ["error", "always"],
-        "no-console": "error",
-        "no-constant-condition": ["error", { "checkLoops": false }],
-        "no-eval": "error",
-        "no-implied-eval": "error",
-        "no-trailing-spaces": "error",
-        "prefer-const": "error",
-        "semi": "error"
-    },
-    "parserOptions": {
-        "sourceType": "module"
-    }
+  "env": {
+    "browser": true,
+    "commonjs": true,
+    "es2020": true,
+    "node": true,
+    "mocha": true
+  },
+  "extends": ["eslint:recommended", "plugin:prettier/recommended"],
+  "plugins": ["import"],
+  "rules": {
+    "eol-last": "error",
+    "import/extensions": ["error", "always"],
+    "no-console": "error",
+    "no-constant-condition": ["error", { "checkLoops": false }],
+    "no-eval": "error",
+    "no-implied-eval": "error",
+    "no-trailing-spaces": "error",
+    "prefer-const": "error",
+    "semi": "error"
+  },
+  "parserOptions": {
+    "sourceType": "module"
+  }
 }

lib/error.js

@@ -21,7 +21,7 @@ function contextAsText(node) {
     hierarchy.unshift(parent);
     node = parent;
   }
-  return hierarchy.map(n => appendIfExist(n.type, n.name)).join(" -> ");
+  return hierarchy.map((n) => appendIfExist(n.type, n.name)).join(" -> ");
 }
 
 /**
@@ -33,18 +33,25 @@ function contextAsText(node) {
  * @param {"Syntax" | "Validation"} kind error type
  * @param {WebIDL2ErrorOptions} [options]
  */
-function error(source, position, current, message, kind, { level = "error", autofix, ruleName } = {}) {
+function error(
+  source,
+  position,
+  current,
+  message,
+  kind,
+  { level = "error", autofix, ruleName } = {}
+) {
   /**
    * @param {number} count
    */
   function sliceTokens(count) {
-    return count > 0 ?
-      source.slice(position, position + count) :
-      source.slice(Math.max(position + count, 0), position);
+    return count > 0
+      ? source.slice(position, position + count)
+      : source.slice(Math.max(position + count, 0), position);
   }
 
   function tokensToText(inputs, { precedes } = {}) {
-    const text = inputs.map(t => t.trivia + t.value).join("");
+    const text = inputs.map((t) => t.trivia + t.value).join("");
     const nextToken = source[position];
     if (nextToken.type === "eof") {
       return text;
@@ -57,9 +64,11 @@ function error(source, position, current, message, kind, { level = "error", auto
 
   const maxTokens = 5; // arbitrary but works well enough
   const line =
-    source[position].type !== "eof" ? source[position].line :
-    source.length > 1 ? source[position - 1].line :
-    1;
+    source[position].type !== "eof"
+      ? source[position].line
+      : source.length > 1
+      ? source[position - 1].line
+      : 1;
 
   const precedingLastLine = lastLine(
     tokensToText(sliceTokens(-maxTokens), { precedes: true })
@@ -74,7 +83,12 @@ function error(source, position, current, message, kind, { level = "error", auto
 
   const contextType = kind === "Syntax" ? "since" : "inside";
   const inSourceName = source.name ? ` in ${source.name}` : "";
-  const grammaticalContext = (current && current.name) ? `, ${contextType} \`${current.partial ? "partial " : ""}${contextAsText(current)}\`` : "";
+  const grammaticalContext =
+    current && current.name
+      ? `, ${contextType} \`${current.partial ? "partial " : ""}${contextAsText(
+          current
+        )}\``
+      : "";
   const context = `${kind} error at line ${line}${inSourceName}${grammaticalContext}:\n${sourceContext}`;
   return {
     message: `${context} ${message}`,
@@ -86,7 +100,7 @@ function error(source, position, current, message, kind, { level = "error", auto
     ruleName,
     autofix,
     input: subsequentText,
-    tokens: subsequentTokens
+    tokens: subsequentTokens,
   };
 }
 
@@ -101,7 +115,20 @@ export function syntaxError(source, position, current, message) {
  * @param {string} message error message
  * @param {WebIDL2ErrorOptions} [options]
  */
-export function validationError(token, current, ruleName, message, options = {}) {
+export function validationError(
+  token,
+  current,
+  ruleName,
+  message,
+  options = {}
+) {
   options.ruleName = ruleName;
-  return error(current.source, token.index, current, message, "Validation", options);
+  return error(
+    current.source,
+    token.index,
+    current,
+    message,
+    "Validation",
+    options
+  );
 }

lib/productions/argument.js

@@ -3,10 +3,18 @@
 import { Base } from "./base.js";
 import { Default } from "./default.js";
 import { ExtendedAttributes } from "./extended-attributes.js";
-import { unescape, type_with_extended_attributes, autoParenter, getFirstToken } from "./helpers.js";
+import {
+  unescape,
+  type_with_extended_attributes,
+  autoParenter,
+  getFirstToken,
+} from "./helpers.js";
 import { argumentNameKeywords, Tokeniser } from "../tokeniser.js";
 import { validationError } from "../error.js";
-import { idlTypeIncludesDictionary, dictionaryIncludesRequiredField } from "../validators/helpers.js";
+import {
+  idlTypeIncludesDictionary,
+  dictionaryIncludesRequiredField,
+} from "../validators/helpers.js";
 
 export class Argument extends Base {
   /**
@@ -16,7 +24,9 @@ export class Argument extends Base {
     const start_position = tokeniser.position;
     /** @type {Base["tokens"]} */
     const tokens = {};
-    const ret = autoParenter(new Argument({ source: tokeniser.source, tokens }));
+    const ret = autoParenter(
+      new Argument({ source: tokeniser.source, tokens })
+    );
     ret.extAttrs = ExtendedAttributes.parse(tokeniser);
     tokens.optional = tokeniser.consume("optional");
     ret.idlType = type_with_extended_attributes(tokeniser, "argument-type");
@@ -52,23 +62,46 @@ export class Argument extends Base {
    */
   *validate(defs) {
     yield* this.idlType.validate(defs);
-    const result = idlTypeIncludesDictionary(this.idlType, defs, { useNullableInner: true });
+    const result = idlTypeIncludesDictionary(this.idlType, defs, {
+      useNullableInner: true,
+    });
     if (result) {
       if (this.idlType.nullable) {
         const message = `Dictionary arguments cannot be nullable.`;
-        yield validationError(this.tokens.name, this, "no-nullable-dict-arg", message);
+        yield validationError(
+          this.tokens.name,
+          this,
+          "no-nullable-dict-arg",
+          message
+        );
       } else if (!this.optional) {
-        if (this.parent && !dictionaryIncludesRequiredField(result.dictionary, defs) && isLastRequiredArgument(this)) {
+        if (
+          this.parent &&
+          !dictionaryIncludesRequiredField(result.dictionary, defs) &&
+          isLastRequiredArgument(this)
+        ) {
           const message = `Dictionary argument must be optional if it has no required fields`;
-          yield validationError(this.tokens.name, this, "dict-arg-optional", message, {
-            autofix: autofixDictionaryArgumentOptionality(this)
-          });
+          yield validationError(
+            this.tokens.name,
+            this,
+            "dict-arg-optional",
+            message,
+            {
+              autofix: autofixDictionaryArgumentOptionality(this),
+            }
+          );
         }
       } else if (!this.default) {
         const message = `Optional dictionary arguments must have a default value of \`{}\`.`;
-        yield validationError(this.tokens.name, this, "dict-arg-default", message, {
-          autofix: autofixOptionalDictionaryDefaultValue(this)
-        });
+        yield validationError(
+          this.tokens.name,
+          this,
+          "dict-arg-default",
+          message,
+          {
+            autofix: autofixOptionalDictionaryDefaultValue(this),
+          }
+        );
       }
     }
   }
@@ -80,7 +113,7 @@ export class Argument extends Base {
 function isLastRequiredArgument(arg) {
   const list = arg.parent.arguments || arg.parent.list;
   const index = list.indexOf(arg);
-  const requiredExists = list.slice(index + 1).some(a => !a.optional);
+  const requiredExists = list.slice(index + 1).some((a) => !a.optional);
   return !requiredExists;
 }
 
@@ -90,7 +123,11 @@ function isLastRequiredArgument(arg) {
 function autofixDictionaryArgumentOptionality(arg) {
   return () => {
     const firstToken = getFirstToken(arg.idlType);
-    arg.tokens.optional = { type: "optional", value: "optional", trivia: firstToken.trivia };
+    arg.tokens.optional = {
+      type: "optional",
+      value: "optional",
+      trivia: firstToken.trivia,
+    };
     firstToken.trivia = " ";
     autofixOptionalDictionaryDefaultValue(arg)();
   };

lib/productions/array-base.js

@@ -6,7 +6,7 @@ export class ArrayBase extends Array {
     Object.defineProperties(this, {
       source: { value: source },
       tokens: { value: tokens },
-      parent: { value: null, writable: true }
+      parent: { value: null, writable: true },
     });
   }
 }

lib/productions/attribute.js

@@ -1,16 +1,25 @@
 import { validationError } from "../error.js";
 import { idlTypeIncludesDictionary } from "../validators/helpers.js";
 import { Base } from "./base.js";
-import { type_with_extended_attributes, unescape, autoParenter } from "./helpers.js";
+import {
+  type_with_extended_attributes,
+  unescape,
+  autoParenter,
+} from "./helpers.js";
 
 export class Attribute extends Base {
   /**
    * @param {import("../tokeniser.js").Tokeniser} tokeniser
    */
-  static parse(tokeniser, { special, noInherit = false, readonly = false } = {}) {
+  static parse(
+    tokeniser,
+    { special, noInherit = false, readonly = false } = {}
+  ) {
     const start_position = tokeniser.position;
     const tokens = { special };
-    const ret = autoParenter(new Attribute({ source: tokeniser.source, tokens }));
+    const ret = autoParenter(
+      new Attribute({ source: tokeniser.source, tokens })
+    );
     if (!special && !noInherit) {
       tokens.special = tokeniser.consume("inherit");
     }
@@ -26,9 +35,15 @@ export class Attribute extends Base {
       tokeniser.unconsume(start_position);
       return;
     }
-    ret.idlType = type_with_extended_attributes(tokeniser, "attribute-type") || tokeniser.error("Attribute lacks a type");
-    tokens.name = tokeniser.consume("identifier", "async", "required") || tokeniser.error("Attribute lacks a name");
-    tokens.termination = tokeniser.consume(";") || tokeniser.error("Unterminated attribute, expected `;`");
+    ret.idlType =
+      type_with_extended_attributes(tokeniser, "attribute-type") ||
+      tokeniser.error("Attribute lacks a type");
+    tokens.name =
+      tokeniser.consume("identifier", "async", "required") ||
+      tokeniser.error("Attribute lacks a name");
+    tokens.termination =
+      tokeniser.consume(";") ||
+      tokeniser.error("Unterminated attribute, expected `;`");
     return ret.this;
   }
 
@@ -56,15 +71,26 @@ export class Attribute extends Base {
       case "sequence":
       case "record": {
         const message = `Attributes cannot accept ${this.idlType.generic} types.`;
-        yield validationError(this.tokens.name, this, "attr-invalid-type", message);
+        yield validationError(
+          this.tokens.name,
+          this,
+          "attr-invalid-type",
+          message
+        );
         break;
       }
       default: {
-        const { reference } = idlTypeIncludesDictionary(this.idlType, defs) || {};
+        const { reference } =
+          idlTypeIncludesDictionary(this.idlType, defs) || {};
         if (reference) {
           const targetToken = (this.union ? reference : this).tokens.base;
           const message = "Attributes cannot accept dictionary types.";
-          yield validationError(targetToken, this, "attr-invalid-type", message);
+          yield validationError(
+            targetToken,
+            this,
+            "attr-invalid-type",
+            message
+          );
         }
       }
     }

lib/productions/base.js

@@ -11,7 +11,7 @@ export class Base {
       source: { value: source },
       tokens: { value: tokens, writable: true },
       parent: { value: null, writable: true },
-      this: { value: this } // useful when escaping from proxy
+      this: { value: this }, // useful when escaping from proxy
     });
   }
 

lib/productions/callback-interface.js

@@ -14,14 +14,18 @@ export class CallbackInterface extends Container {
     if (!tokens.base) {
       return;
     }
-    return Container.parse(tokeniser, new CallbackInterface({ source: tokeniser.source, tokens }), {
-      type: "callback interface",
-      inheritable: !partial,
-      allowedMembers: [
-        [Constant.parse],
-        [Operation.parse, { regular: true }]
-      ]
-    });
+    return Container.parse(
+      tokeniser,
+      new CallbackInterface({ source: tokeniser.source, tokens }),
+      {
+        type: "callback interface",
+        inheritable: !partial,
+        allowedMembers: [
+          [Constant.parse],
+          [Operation.parse, { regular: true }],
+        ],
+      }
+    );
   }
 
   get type() {