Tweak code style

Author: TrySound

package.json

@@ -21,7 +21,7 @@
   "lint-staged": {
     "*.js": [
       "eslint",
-      "prettier --single-quote --no-semi --write",
+      "prettier --write",
       "git add"
     ]
   },

src/index.js

@@ -1,208 +1,208 @@
 /* eslint-env node */
-import postcss from 'postcss'
-import Tokenizer from 'css-selector-tokenizer'
+import postcss from "postcss";
+import Tokenizer from "css-selector-tokenizer";
 
 function normalizeNodeArray(nodes) {
-  var array = []
+  var array = [];
   nodes.forEach(function(x) {
     if (Array.isArray(x)) {
       normalizeNodeArray(x).forEach(function(item) {
-        array.push(item)
-      })
+        array.push(item);
+      });
     } else if (x) {
-      array.push(x)
+      array.push(x);
     }
-  })
-  if (array.length > 0 && array[array.length - 1].type === 'spacing') {
-    array.pop()
+  });
+  if (array.length > 0 && array[array.length - 1].type === "spacing") {
+    array.pop();
   }
-  return array
+  return array;
 }
 
 function localizeNode(node, context) {
-  if (context.ignoreNextSpacing && node.type !== 'spacing') {
-    throw new Error('Missing whitespace after :' + context.ignoreNextSpacing)
+  if (context.ignoreNextSpacing && node.type !== "spacing") {
+    throw new Error("Missing whitespace after :" + context.ignoreNextSpacing);
   }
-  if (context.enforceNoSpacing && node.type === 'spacing') {
-    throw new Error('Missing whitespace before :' + context.enforceNoSpacing)
+  if (context.enforceNoSpacing && node.type === "spacing") {
+    throw new Error("Missing whitespace before :" + context.enforceNoSpacing);
   }
 
-  var newNodes
+  var newNodes;
   switch (node.type) {
-    case 'selectors':
-      var resultingGlobal
-      context.hasPureGlobals = false
+    case "selectors":
+      var resultingGlobal;
+      context.hasPureGlobals = false;
       newNodes = node.nodes.map(function(n) {
         var nContext = {
           global: context.global,
           lastWasSpacing: true,
           hasLocals: false,
           explicit: false
-        }
-        n = localizeNode(n, nContext)
-        if (typeof resultingGlobal === 'undefined') {
-          resultingGlobal = nContext.global
+        };
+        n = localizeNode(n, nContext);
+        if (typeof resultingGlobal === "undefined") {
+          resultingGlobal = nContext.global;
         } else if (resultingGlobal !== nContext.global) {
           throw new Error(
             'Inconsistent rule global/local result in rule "' +
               Tokenizer.stringify(node) +
               '" (multiple selectors must result in the same mode for the rule)'
-          )
+          );
         }
         if (!nContext.hasLocals) {
-          context.hasPureGlobals = true
+          context.hasPureGlobals = true;
         }
-        return n
-      })
-      context.global = resultingGlobal
-      node = Object.create(node)
-      node.nodes = normalizeNodeArray(newNodes)
-      break
+        return n;
+      });
+      context.global = resultingGlobal;
+      node = Object.create(node);
+      node.nodes = normalizeNodeArray(newNodes);
+      break;
 
-    case 'selector':
+    case "selector":
       newNodes = node.nodes.map(function(n) {
-        return localizeNode(n, context)
-      })
-      node = Object.create(node)
-      node.nodes = normalizeNodeArray(newNodes)
-      break
+        return localizeNode(n, context);
+      });
+      node = Object.create(node);
+      node.nodes = normalizeNodeArray(newNodes);
+      break;
 
-    case 'spacing':
+    case "spacing":
       if (context.ignoreNextSpacing) {
-        context.ignoreNextSpacing = false
-        context.lastWasSpacing = false
-        context.enforceNoSpacing = false
-        return null
+        context.ignoreNextSpacing = false;
+        context.lastWasSpacing = false;
+        context.enforceNoSpacing = false;
+        return null;
       }
-      context.lastWasSpacing = true
-      return node
+      context.lastWasSpacing = true;
+      return node;
 
-    case 'pseudo-class':
-      if (node.name === 'local' || node.name === 'global') {
+    case "pseudo-class":
+      if (node.name === "local" || node.name === "global") {
         if (context.inside) {
           throw new Error(
-            'A :' +
+            "A :" +
               node.name +
-              ' is not allowed inside of a :' +
+              " is not allowed inside of a :" +
               context.inside +
-              '(...)'
-          )
+              "(...)"
+          );
         }
-        context.ignoreNextSpacing = context.lastWasSpacing ? node.name : false
-        context.enforceNoSpacing = context.lastWasSpacing ? false : node.name
-        context.global = node.name === 'global'
-        context.explicit = true
-        return null
+        context.ignoreNextSpacing = context.lastWasSpacing ? node.name : false;
+        context.enforceNoSpacing = context.lastWasSpacing ? false : node.name;
+        context.global = node.name === "global";
+        context.explicit = true;
+        return null;
       }
-      break
+      break;
 
-    case 'nested-pseudo-class':
-      var subContext
-      if (node.name === 'local' || node.name === 'global') {
+    case "nested-pseudo-class":
+      var subContext;
+      if (node.name === "local" || node.name === "global") {
         if (context.inside) {
           throw new Error(
-            'A :' +
+            "A :" +
               node.name +
-              '(...) is not allowed inside of a :' +
+              "(...) is not allowed inside of a :" +
               context.inside +
-              '(...)'
-          )
+              "(...)"
+          );
         }
         subContext = {
-          global: node.name === 'global',
+          global: node.name === "global",
           inside: node.name,
           hasLocals: false,
           explicit: true
-        }
+        };
         node = node.nodes.map(function(n) {
-          return localizeNode(n, subContext)
-        })
+          return localizeNode(n, subContext);
+        });
         // don't leak spacing
-        node[0].before = undefined
-        node[node.length - 1].after = undefined
+        node[0].before = undefined;
+        node[node.length - 1].after = undefined;
       } else {
         subContext = {
           global: context.global,
           inside: context.inside,
           lastWasSpacing: true,
           hasLocals: false,
           explicit: context.explicit
-        }
+        };
         newNodes = node.nodes.map(function(n) {
-          return localizeNode(n, subContext)
-        })
-        node = Object.create(node)
-        node.nodes = normalizeNodeArray(newNodes)
+          return localizeNode(n, subContext);
+        });
+        node = Object.create(node);
+        node.nodes = normalizeNodeArray(newNodes);
       }
       if (subContext.hasLocals) {
-        context.hasLocals = true
+        context.hasLocals = true;
       }
-      break
+      break;
 
-    case 'id':
-    case 'class':
+    case "id":
+    case "class":
       if (!context.global) {
         node = {
-          type: 'nested-pseudo-class',
-          name: 'local',
+          type: "nested-pseudo-class",
+          name: "local",
           nodes: [node]
-        }
-        context.hasLocals = true
+        };
+        context.hasLocals = true;
       }
-      break
+      break;
   }
 
   // reset context
-  context.lastWasSpacing = false
-  context.ignoreNextSpacing = false
-  context.enforceNoSpacing = false
-  return node
+  context.lastWasSpacing = false;
+  context.ignoreNextSpacing = false;
+  context.enforceNoSpacing = false;
+  return node;
 }
 
 module.exports = postcss.plugin(
-  'postcss-modules-local-by-default',
+  "postcss-modules-local-by-default",
   (options = {}) => css => {
     if (
       options.mode &&
-      options.mode !== 'global' &&
-      options.mode !== 'local' &&
-      options.mode !== 'pure'
+      options.mode !== "global" &&
+      options.mode !== "local" &&
+      options.mode !== "pure"
     ) {
       throw Error(
         'options.mode must be either "global", "local" or "pure" (default "local")'
-      )
+      );
     }
-    var pureMode = options.mode === 'pure'
-    var globalMode = options.mode === 'global'
+    var pureMode = options.mode === "pure";
+    var globalMode = options.mode === "global";
     css.walkRules(function(rule) {
       if (
-        rule.parent.type === 'atrule' &&
+        rule.parent.type === "atrule" &&
         /keyframes$/.test(rule.parent.name)
       ) {
         // ignore keyframe rules
-        return
+        return;
       }
-      var selector = Tokenizer.parse(rule.selector)
+      var selector = Tokenizer.parse(rule.selector);
       var context = {
         options: options,
         global: globalMode,
         hasPureGlobals: false
-      }
-      var newSelector
+      };
+      var newSelector;
       try {
-        newSelector = localizeNode(selector, context)
+        newSelector = localizeNode(selector, context);
       } catch (e) {
-        throw rule.error(e.message)
+        throw rule.error(e.message);
       }
       if (pureMode && context.hasPureGlobals) {
         throw rule.error(
           'Selector "' +
             Tokenizer.stringify(selector) +
             '" is not pure ' +
-            '(pure selectors must contain at least one local class or id)'
-        )
+            "(pure selectors must contain at least one local class or id)"
+        );
       }
-      rule.selector = Tokenizer.stringify(newSelector)
-    })
+      rule.selector = Tokenizer.stringify(newSelector);
+    });
   }
-)
+);