Remove path replacements

Author: TrySound

package.json

@@ -14,10 +14,20 @@
   },
   "lint-staged": {
     "*.js": [
-      "prettier --single-quote --no-semi --write",
+      "prettier --write",
+      "eslint",
       "git add"
     ]
   },
+  "eslintConfig": {
+    "parserOptions": {
+      "sourceType": "module"
+    },
+    "env": {
+      "es6": true
+    },
+    "extends": "eslint:recommended"
+  },
   "babel": {
     "presets": [
       [
@@ -48,15 +58,16 @@
   "devDependencies": {
     "babel-cli": "^6.5.2",
     "babel-jest": "^20.0.3",
-    "babel-preset-env": "^1.5.0",
-    "husky": "^0.13.3",
-    "jest": "^20.0.3",
-    "lint-staged": "^3.4.2",
-    "prettier": "^1.3.1",
+    "babel-preset-env": "^1.5.2",
+    "eslint": "^4.0.0",
+    "husky": "^0.13.4",
+    "jest": "^20.0.4",
+    "lint-staged": "^3.6.1",
+    "prettier": "^1.4.4",
     "strip-indent": "^2.0.0"
   },
   "dependencies": {
-    "icss-utils": "^2.0.0",
-    "postcss": "^6.0.1"
+    "icss-utils": "^3.0.1",
+    "postcss": "^6.0.2"
   }
 }

src/index.js

@@ -1,90 +1,88 @@
-import postcss from 'postcss'
+/* eslint-env node */
+import postcss from "postcss";
 import {
   replaceSymbols,
   replaceValueSymbols,
   extractICSS,
   createICSSRules
-} from 'icss-utils'
+} from "icss-utils";
 
-const matchImports = /^(.+?|\([\s\S]+?\))\s+from\s+("[^"]*"|'[^']*'|[\w-]+)$/
-const matchValueDefinition = /(?:\s+|^)([\w-]+):?\s+(.+?)\s*$/g
-const matchImport = /^([\w-]+)(?:\s+as\s+([\w-]+))?/
+const plugin = "postcss-modules-values";
+
+const matchImports = /^(.+?|\([\s\S]+?\))\s+from\s+("[^"]*"|'[^']*'|[\w-]+)$/;
+const matchValueDefinition = /(?:\s+|^)([\w-]+):?\s+(.+?)\s*$/g;
+const matchImport = /^([\w-]+)(?:\s+as\s+([\w-]+))?/;
 
 // 'i' prefix to prevent postcss parsing "_" as css hook
 const getAliasName = (name, index) =>
-  `i__value_${name.replace(/\W/g, '_')}_${index}`
+  `__value__${name.replace(/\W/g, "_")}__${index}`;
 
-module.exports = postcss.plugin('postcss-modules-values', () => (
-  css,
-  result
-) => {
-  const { icssImports, icssExports } = extractICSS(css)
-  let importIndex = 0
+module.exports = postcss.plugin(plugin, () => (css, result) => {
+  const { icssImports, icssExports } = extractICSS(css);
+  let importIndex = 0;
   const createImportedName = (path, name) => {
-    const importedName = getAliasName(name, importIndex)
+    const importedName = getAliasName(name, importIndex);
     if (icssImports[path] && icssImports[path][importedName]) {
-      importIndex += 1
-      return createImportedName(path, name)
+      importIndex += 1;
+      return createImportedName(path, name);
     }
-    importIndex += 1
-    return importedName
-  }
+    importIndex += 1;
+    return importedName;
+  };
 
   const addDefinition = atRule => {
-    let matches
+    let matches;
     while ((matches = matchValueDefinition.exec(atRule.params))) {
-      let [, key, value] = matches
+      let [, key, value] = matches;
       // Add to the definitions, knowing that values can refer to each other
-      icssExports[key] = replaceValueSymbols(value, icssExports)
-      atRule.remove()
+      icssExports[key] = replaceValueSymbols(value, icssExports);
+      atRule.remove();
     }
-  }
+  };
 
   const addImport = atRule => {
-    let matches = matchImports.exec(atRule.params)
+    let matches = matchImports.exec(atRule.params);
     if (matches) {
-      let [, aliasesString, path] = matches
-      // We can use constants for path names
-      if (icssExports[path]) path = icssExports[path]
+      const aliasesString = matches[1];
+      let path = matches[2];
+      path = path[0] === "'" || path[0] === '"' ? path.slice(1, -1) : path;
       let aliases = aliasesString
-        .replace(/^\(\s*([\s\S]+)\s*\)$/, '$1')
+        .replace(/^\(\s*([\s\S]+)\s*\)$/, "$1")
         .split(/\s*,\s*/)
         .map(alias => {
-          let tokens = matchImport.exec(alias)
+          let tokens = matchImport.exec(alias);
           if (tokens) {
-            let [, theirName, myName = theirName] = tokens
-            let importedName = createImportedName(path, myName)
-            icssExports[myName] = importedName
-            return { theirName, importedName }
+            let [, theirName, myName = theirName] = tokens;
+            let importedName = createImportedName(path, myName);
+            icssExports[myName] = importedName;
+            return { theirName, importedName };
           } else {
-            throw new Error(`@import statement "${alias}" is invalid!`)
+            throw new Error(`@import statement "${alias}" is invalid!`);
           }
         })
         .reduce((acc, { theirName, importedName }) => {
-          acc[importedName] = theirName
-          return acc
-        }, {})
-      icssImports[path] = Object.assign({}, icssImports[path], aliases)
-      atRule.remove()
+          acc[importedName] = theirName;
+          return acc;
+        }, {});
+      icssImports[path] = Object.assign({}, icssImports[path], aliases);
+      atRule.remove();
     }
-  }
+  };
 
   /* Look at all the @value statements and treat them as locals or as imports */
-  css.walkAtRules('value', atRule => {
+  css.walkAtRules("value", atRule => {
     if (matchImports.exec(atRule.params)) {
-      addImport(atRule)
+      addImport(atRule);
     } else {
-      if (atRule.params.indexOf('@value') !== -1) {
-        result.warn('Invalid value definition: ' + atRule.params)
+      if (atRule.params.indexOf("@value") !== -1) {
+        result.warn("Invalid value definition: " + atRule.params);
       }
 
-      addDefinition(atRule)
+      addDefinition(atRule);
     }
-  })
-
-  if (Object.keys(icssExports).length === 0) return
+  });
 
-  replaceSymbols(css, icssExports)
+  replaceSymbols(css, icssExports);
 
-  css.prepend(createICSSRules(icssImports, icssExports))
-})
+  css.prepend(createICSSRules(icssImports, icssExports));
+});