switch to conpack

package.json

@@ -4,7 +4,7 @@
   "version": "0.0.0",
   "scripts": {
     "precommit": "npm test",
-    "test": "npm run lint && lerna run test",
+    "test": "npm run lint && jest",
     "lint": "xo"
   },
   "main": "index.js",
@@ -44,11 +44,16 @@
   "devDependencies": {
     "eslint-config-rem": "^4.0.0",
     "husky": "^0.14.3",
+    "jest": "^22.1.4",
     "lerna": "^2.0.0",
     "xo": "^0.18.2"
   },
   "dependencies": {},
   "workspaces": [
     "packages/*"
-  ]
+  ],
+  "jest": {
+    "testEnvironment": "node",
+    "testPathIgnorePatterns": ["/node_modules/", "/examples?/"]
+  }
 }

packages/babel-preset-poi/package.json

@@ -6,7 +6,7 @@
     "index.js"
   ],
   "scripts": {
-    "test": "ava"
+    "test": "echo fine"
   },
   "license": "MIT",
   "dependencies": {
@@ -23,7 +23,6 @@
     "babel-runtime": "^6.26.0"
   },
   "devDependencies": {
-    "ava": "^0.24.0",
     "babel-core": "^6.26.0"
   }
 }

packages/babel-preset-poi/test/__snapshots__/test.js.snap

@@ -0,0 +1,26 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`class properties: class properties 1`] = `
+"\\"use strict\\";
+
+let Foo = class Foo {
+  constructor() {
+    this.state = 1;
+  }
+
+};"
+`;
+
+exports[`decorators legacy: decorators legacy 1`] = `
+"\\"use strict\\";
+
+var _class;
+
+let Foo = bound(_class = class Foo {}) || _class;"
+`;
+
+exports[`object reset spread: object reset spread 1`] = `
+"\\"use strict\\";
+
+const a = Object.assign({}, foo);"
+`;

packages/babel-preset-poi/test/test.js

@@ -1,12 +1,11 @@
-import test from 'ava'
-import * as babel from 'babel-core'
+const babel = require('babel-core')
 
 function snapshot({ title, input }) {
-  test(title, t => {
+  test(title, () => {
     const { code } = babel.transform(input, {
       presets: [require.resolve('..')]
     })
-    t.snapshot(code, title)
+    expect(code).toMatchSnapshot(title)
   })
 }
 

packages/poi-preset-babel-minify/index.js

@@ -6,8 +6,7 @@ module.exports = (pluginOptions, overrides) => {
 
       // do not use if `minimize` is off
       if (config.plugins.has('minimize')) {
-        config.plugin('minimize')
-          .use(BabelMinifyPlugin, [pluginOptions, overrides])
+        config.plugins.update('minimize', BabelMinifyPlugin, [pluginOptions, overrides])
       }
     })
   }

packages/poi-preset-buble/lib/index.js

@@ -22,43 +22,40 @@ module.exports = ({
       }, bubleOptions)
 
       for (const rule of ['js', 'es']) {
-        const thisRule = config.module.rule(rule)
+        const thisRule = config.rules.get(rule)
         // Remove babel-loader first
-        thisRule.uses
-          .delete('babel-loader')
-          .end()
+        thisRule.loaders.remove('babel-loader')
 
         // Maybe add nodent-loader
         if (asyncAwait) {
-          thisRule
-          .use('nodent')
-            .loader(require.resolve('./nodent-loader'))
+          thisRule.loaders.add('nodent-loader', {
+            loader: require.resolve('./nodent-loader')
+          })
         }
 
         // Add buble-loader
-        thisRule
-        .use('buble-loader')
-          .loader(require.resolve('./buble-loader'))
-          .options(bubleOptions)
+        thisRule.loaders.add('buble-loader', {
+          loader: require.resolve('./buble-loader'),
+          options: bubleOptions
+        })
       }
 
-      config.module.rule('vue')
-        .use('vue-loader')
-        .tap(vueOptions => {
-          vueOptions.loaders.js = {
-            loader: require.resolve('./buble-loader'),
-            options: bubleOptions
-          }
-          if (asyncAwait) {
-            vueOptions.loaders.js = [
-              {
-                loader: require.resolve('./nodent-loader')
-              },
-              vueOptions.loaders.js
-            ]
-          }
-          return vueOptions
-        })
+      const vueRule = config.rules.get('vue')
+      vueRule.loaders.update('vue-loader', vueOptions => {
+        vueOptions.loaders.js = {
+          loader: require.resolve('./buble-loader'),
+          options: bubleOptions
+        }
+        if (asyncAwait) {
+          vueOptions.loaders.js = [
+            {
+              loader: require.resolve('./nodent-loader')
+            },
+            vueOptions.loaders.js
+          ]
+        }
+        return vueOptions
+      })
     })
   }
 }

packages/poi-preset-bundle-report/index.js

@@ -10,8 +10,7 @@ module.exports = pluginOptions => {
     poi.extendWebpack('production', config => {
       if (poi.argv.bundleReport) {
         config
-          .plugin('bundle-report')
-          .use(BundleAnalyzerPlugin, [pluginOptions])
+          .plugins.add('bundle-report', BundleAnalyzerPlugin, [pluginOptions])
       }
     })
   }

packages/poi-preset-coffee/index.js

@@ -10,13 +10,11 @@ module.exports = ({ loaderOptions } = {}) => {
     poi.extendWebpack(config => {
       let babelOptions
 
-      if (config.module.rule('js').uses.has('babel-loader')) {
+      const jsRule = config.rules.get('js')
+      if (jsRule.loaders.has('babel-loader')) {
         babelOptions = Object.assign(
           {},
-          config.module.rule('js')
-            .use('babel-loader')
-            .store
-            .get('options')
+          jsRule.loaders.get('babel-loader').options.options
         )
         // Delete unnecessary loader-specific options
         delete babelOptions.cacheDirectory
@@ -28,21 +26,21 @@ module.exports = ({ loaderOptions } = {}) => {
         transpile: babelOptions
       }, loaderOptions)
 
-      config.module.rule('coffee')
-        .test(/\.coffee$/)
-        .use('coffee-loader')
-          .loader('better-coffee-loader')
-          .options(coffeeOptions)
+      config.rules.add('coffee', {
+        test: /\.coffee$/
+      }).loaders.add('coffee-loader', {
+        loader: 'better-coffee-loader',
+        options: coffeeOptions
+      })
 
-      config.module.rule('vue')
-        .use('vue-loader')
-          .tap(vueOptions => {
-            vueOptions.loaders.coffee = vueOptions.loaders.coffeescript = [{
-              loader: 'better-coffee-loader',
-              options: coffeeOptions
-            }]
-            return vueOptions
-          })
+      config.rules.get('vue')
+        .loaders.update('vue-loader', vueOptions => {
+          vueOptions.loaders.coffee = vueOptions.loaders.coffeescript = [{
+            loader: 'better-coffee-loader',
+            options: coffeeOptions
+          }]
+          return vueOptions
+        })
     })
   }
 }

packages/poi-preset-elm/index.js

@@ -11,21 +11,23 @@ module.exports = (options = {}) => {
     }, options.loaderOptions)
 
     poi.extendWebpack(config => {
-      config.module
-        .rule('elm')
-          .test(/\.elm$/)
-          .exclude
-            .add(/elm-stuff/)
-            .add(/node_modules/)
-            .end()
-          .use('elm-hot')
-            .loader('elm-hot-loader')
-            .end()
-          .use('elm-webpack')
-            .loader('elm-webpack-loader')
-            .options(loaderOptions)
-            .end()
-          .end()
+      const elmRule = config.rules
+        .add('elm', {
+          test: /\.elm$/,
+          exclude: [
+            /elm-stuff/,
+            /node_modules/
+          ]
+        })
+
+      elmRule.loaders.add('elm-hot-loader', {
+        loader: 'elm-hot-loader'
+      })
+
+      elmRule.loaders.add('elm-webpack', {
+        loader: 'elm-webpack-loader',
+        options: loaderOptions
+      })
     })
   }
 }

packages/poi-preset-eslint/index.js

@@ -20,15 +20,15 @@ module.exports = function ({
 } = {}) {
   return poi => {
     poi.extendWebpack(mode, config => {
-      config.module.rule('eslint')
-        .test(/\.(js|jsx|vue)$/)
-        .exclude
-          .add(/node_modules/)
-          .end()
-        .pre()
-        .use('eslint-loader')
-          .loader('eslint-loader')
-          .options(loaderOptions)
+      const eslintRule = config.rules.add('eslint', {
+        test: /\.(js|jsx|vue)$/,
+        exclude: [/node_modules/],
+        enforce: 'pre'
+      })
+      eslintRule.loaders.add('eslint-loader', {
+        loader: 'eslint-loader',
+        options: loaderOptions
+      })
     })
   }
 }

packages/poi-preset-karma/index.js

@@ -28,33 +28,32 @@ module.exports = (options = {}) => {
     poi.extendWebpack('test', config => {
       const coverage = inferValue('coverage')
 
-      isTypeScript = config.module.rules.has('typescript')
+      isTypeScript = config.rules.has('typescript')
 
       if (coverage) {
         /* for general usage */
-        config.module.rule('istanbul-instrumenter-loader')
-          .test(/\.(jsx?)$/)
-          .exclude
-            .add(/(node_modules|\.test\.jsx?)/)
-            .end()
-          .pre()
-          .use('istanbul-instrumenter-loader')
-            .loader('istanbul-instrumenter-loader')
-            .options({
-              esModules: true
-            })
+        const istanbulinstrumenterRule = config.rules.add('istanbul-instrumenter', {
+          test: /\.(jsx?)$/,
+          exclude: [/(node_modules|\.test\.jsx?)/],
+          enforce: 'pre'
+        })
+        istanbulinstrumenterRule.loaders.add('istanbul-instrumenter-loader', {
+          loader: 'istanbul-instrumenter-loader',
+          options: {
+            esModules: true
+          }
+        })
 
         /* for vue (assumes vue-loader) */
-        config.module.rule('vue')
-          .use('vue-loader')
-          .tap(vueOptions => {
-            const instrumenterLoader = 'istanbul-instrumenter-loader?esModules=true'
-            vueOptions.preLoaders = (vueOptions.preLoaders || {})
-            vueOptions.preLoaders.js = typeof vueOptions.preLoaders.js === 'string' ?
-              `${vueOptions.preLoaders.js}!${instrumenterLoader}` :
-              instrumenterLoader
-            return vueOptions
-          })
+        const vueRule = config.rules.get('vue')
+        vueRule.loaders.update('vue-loader', vueOptions => {
+          const instrumenterLoader = 'istanbul-instrumenter-loader?esModules=true'
+          vueOptions.preLoaders = (vueOptions.preLoaders || {})
+          vueOptions.preLoaders.js = typeof vueOptions.preLoaders.js === 'string' ?
+            `${vueOptions.preLoaders.js}!${instrumenterLoader}` :
+            instrumenterLoader
+          return vueOptions
+        })
       }
     })