[WIP]CSS modules (#422)

* add test

* add css module support with parser hack

* add localIdentName support

* add SSR support with test case

* use vue-template-compiler#dev and remove parse hack

* use vue#2.0.4

Author: YiSiWang

lib/loader.js

@@ -58,7 +58,7 @@ module.exports = function (content) {
   var bubleOptions = hasBuble && options.buble ? '?' + JSON.stringify(options.buble) : ''
   var defaultLoaders = {
     html: templateCompilerPath + '?id=' + moduleId,
-    css: styleLoaderPath + '!css-loader' + (needCssSourceMap ? '?sourceMap' : ''),
+    css: (isServer ? '' : styleLoaderPath + '!') + 'css-loader' + (needCssSourceMap ? '?sourceMap' : ''),
     js: hasBuble ? ('buble-loader' + bubleOptions) : hasBabel ? 'babel-loader' : ''
   }
 
@@ -77,7 +77,7 @@ module.exports = function (content) {
       // disable all configuration loaders
       '!!' +
       // get loader string for pre-processors
-      getLoaderString(type, part, scoped) +
+      getLoaderString(type, part, index, scoped) +
       // select the corresponding part from the vue file
       getSelectorString(type, index || 0) +
       // the url to the actual vuefile
@@ -94,17 +94,42 @@ module.exports = function (content) {
   function getRequireForImportString (type, impt, scoped) {
     return loaderUtils.stringifyRequest(loaderContext,
       '!!' +
-      getLoaderString(type, impt, scoped) +
+      getLoaderString(type, impt, -1, scoped) +
       impt.src
     )
   }
 
-  function getLoaderString (type, part, scoped) {
+  function addCssModulesToLoader (loader, part, index) {
+    if (!part.module) return loader
+    var option = options.cssModules || {}
+    return loader.replace(/((?:^|!)css(?:-loader)?)(\?[^!]*)?/, function (m, $1, $2) {
+      // $1: !css-loader
+      // $2: ?a=b
+      var query = loaderUtils.parseQuery($2)
+      query.modules = true
+      query.importLoaders = true
+      query.localIdentName = option.localIdentName || '[hash:base64]'
+      if (index !== -1) {
+        // Note:
+        //   Class name is generated according to its filename.
+        //   Different <style> tags in the same .vue file may generate same names.
+        //   Append `_[index]` to class name to avoid this.
+        query.localIdentName += '_' + index
+      }
+      return $1 + '?' + JSON.stringify(query)
+    })
+  }
+
+  function getLoaderString (type, part, index, scoped) {
     var lang = part.lang || defaultLang[type]
     var loader = loaders[lang]
     var rewriter = type === 'styles' ? styleRewriter + (scoped ? '&scoped=true!' : '!') : ''
     var injectString = (type === 'script' && query.inject) ? 'inject!' : ''
     if (loader !== undefined) {
+      // add css modules
+      if (type === 'styles') {
+        loader = addCssModulesToLoader(loader, part, index)
+      }
       // inject rewriter before css/html loader for
       // extractTextPlugin use cases
       if (rewriterInjectRE.test(loader)) {
@@ -121,7 +146,8 @@ module.exports = function (content) {
         case 'template':
           return defaultLoaders.html + '!' + templateLoaderPath + '?raw&engine=' + lang + '!'
         case 'styles':
-          return defaultLoaders.css + '!' + rewriter + lang + '!'
+          loader = addCssModulesToLoader(defaultLoaders.css, part, index)
+          return loader + '!' + rewriter + lang + '!'
         case 'script':
           return injectString + lang + '!'
       }
@@ -146,13 +172,42 @@ module.exports = function (content) {
   var hasScoped = parts.styles.some(function (s) { return s.scoped })
   var output = 'var __vue_exports__, __vue_options__\n'
 
+  // css modules
+  output += 'var __vue_styles__ = {}\n'
+  var cssModules = {}
+
   // add requires for styles
-  if (!isServer && parts.styles.length) {
+  if (parts.styles.length) {
     output += '\n/* styles */\n'
     parts.styles.forEach(function (style, i) {
-      output += style.src
+      var moduleName = (style.module === true) ? '$style' : style.module
+
+      // require style
+      if (isServer && !moduleName) return
+      var requireString = style.src
         ? getRequireForImport('styles', style, style.scoped)
         : getRequire('styles', style, i, style.scoped)
+
+      // setCssModule
+      if (moduleName) {
+        if (moduleName in cssModules) {
+          loaderContext.emitError('CSS module name "' + moduleName + '" is not unique!')
+          output += requireString
+        } else {
+          cssModules[moduleName] = true
+
+          // `style-loader` exposes the name-to-hash map directly
+          // `css-loader` exposes it in `.locals`
+          // We drop `style-loader` in SSR, and add `.locals` here.
+          if (isServer) {
+            requireString += '.locals'
+          }
+
+          output += '__vue_styles__["' + moduleName + '"] = ' + requireString + '\n'
+        }
+      } else {
+        output += requireString
+      }
     })
   }
 
@@ -205,6 +260,16 @@ module.exports = function (content) {
     exports += '__vue_options__._scopeId = "' + moduleId + '"\n'
   }
 
+  if (Object.keys(cssModules).length) {
+    // inject style modules as computed properties
+    exports +=
+      'if (!__vue_options__.computed) __vue_options__.computed = {}\n' +
+      'Object.keys(__vue_styles__).forEach(function (key) {\n' +
+        'var module = __vue_styles__[key]\n' +
+        '__vue_options__.computed[key] = function () { return module }\n' +
+      '})\n'
+  }
+
   if (!query.inject) {
     output += exports
     // hot reload

package.json

@@ -40,7 +40,7 @@
     "source-map": "^0.5.6",
     "vue-hot-reload-api": "^2.0.1",
     "vue-style-loader": "^1.0.0",
-    "vue-template-compiler": "^2.0.0-rc.3",
+    "vue-template-compiler": "^2.0.4",
     "vue-template-es2015-compiler": "^1.0.0"
   },
   "peerDependencies": {
@@ -72,7 +72,7 @@
     "stylus": "^0.54.5",
     "stylus-loader": "^2.0.0",
     "sugarss": "^0.1.3",
-    "vue": "^2.0.0-rc.4",
+    "vue": "^2.0.4",
     "webpack": "^1.12.2"
   }
 }

test/fixtures/css-modules.vue

@@ -0,0 +1,20 @@
+<style module="style">
+.red {
+  color: red;
+}
+@keyframes fade {
+  from { opacity: 1; } to { opacity: 0; }
+}
+.animate {
+  animation: fade 1s;
+}
+</style>
+
+<style scoped lang="stylus" module>
+.red
+  color: red
+</style>
+
+<script>
+module.exports = {}
+</script>

test/test.js

@@ -377,4 +377,74 @@ describe('vue-loader', function () {
       done()
     })
   })
+
+  it('css-modules', function (done) {
+    function testWithIdent (localIdentName, regexToMatch, cb) {
+      test({
+        entry: './test/fixtures/css-modules.vue',
+        vue: {
+          cssModules: {
+            localIdentName: localIdentName
+          }
+        }
+      }, function (window) {
+        var module = window.vueModule
+
+        // get local class name
+        var className = module.computed.style().red
+        expect(className).to.match(regexToMatch)
+
+        // class name in style
+        var style = [].slice.call(window.document.querySelectorAll('style')).map(function (style) {
+          return style.textContent
+        }).join('\n')
+        expect(style).to.contain('.' + className + ' {\n  color: red;\n}')
+
+        // animation name
+        var match = style.match(/@keyframes\s+(\S+)\s+{/)
+        expect(match).to.have.length(2)
+        var animationName = match[1]
+        expect(animationName).to.not.equal('fade')
+        expect(style).to.contain('animation: ' + animationName + ' 1s;')
+
+        // default module + pre-processor + scoped
+        var anotherClassName = module.computed.$style().red
+        expect(anotherClassName).to.match(regexToMatch).and.not.equal(className)
+        var id = 'data-v-' + genId(require.resolve('./fixtures/css-modules.vue'))
+        expect(style).to.contain('.' + anotherClassName + '[' + id + ']')
+
+        cb()
+      })
+    }
+    // default localIdentName
+    testWithIdent(undefined, /^_\w{22}/, function () {
+      // specified localIdentName
+      var ident = '[path][name]---[local]---[hash:base64:5]'
+      var regex = /^test-fixtures-css-modules---red---\w{5}/
+      testWithIdent(ident, regex, done)
+    })
+  })
+
+  it('css-modules in SSR', function (done) {
+    bundle({
+      entry: './test/fixtures/css-modules.vue',
+      target: 'node',
+      output: Object.assign({}, globalConfig.output, {
+        libraryTarget: 'commonjs2'
+      })
+    }, function (code) {
+      // http://stackoverflow.com/questions/17581830/load-node-js-module-from-string-in-memory
+      function requireFromString(src, filename) {
+        var Module = module.constructor;
+        var m = new Module();
+        m._compile(src, filename);
+        return m.exports;
+      }
+
+      var output = requireFromString(code, './test.build.js')
+      expect(output.computed.style().red).to.exist
+
+      done()
+    })
+  })
 })