webpacker-jets 3.2.100

data/package/config_types/__tests__/config_object.js

@@ -0,0 +1,43 @@
+/* global test expect */
+
+const ConfigObject = require('../config_object')
+
+test('new', () => {
+  const object = new ConfigObject()
+  expect(object).toBeInstanceOf(ConfigObject)
+  expect(object).toBeInstanceOf(Object)
+})
+
+test('set', () => {
+  const object = new ConfigObject()
+  expect(object.set('key', 'value')).toEqual({ key: 'value' })
+})
+
+test('get', () => {
+  const object = new ConfigObject()
+  object.set('key', 'value')
+  object.set('key1', 'value1')
+  expect(object.get('key')).toEqual('value')
+})
+
+test('delete', () => {
+  const object = new ConfigObject()
+  object.set('key', { key1: 'value' })
+  expect(object.delete('key.key1')).toEqual({ key: {} })
+  expect(object.delete('key')).toEqual({})
+})
+
+test('toObject', () => {
+  const object = new ConfigObject()
+  object.set('key', 'value')
+  object.set('key1', 'value1')
+  expect(object.toObject()).toEqual({ key: 'value', key1: 'value1' })
+})
+
+test('merge', () => {
+  const object = new ConfigObject()
+  object.set('foo', {})
+  expect(object.merge({ key: 'foo', value: 'bar' })).toEqual(
+    { foo: {}, key: 'foo', value: 'bar' }
+  )
+})

data/package/config_types/config_list.js

@@ -0,0 +1,85 @@
+/**
+  * @class
+  * @extends { Array }
+*/
+class ConfigList extends Array {
+  static get [Symbol.species]() { return Array }
+
+  get(key) {
+    const index = this.getIndex(key, true)
+    return this[index].value
+  }
+
+  /**
+    * @deprecated after the 3.0.2 release and will be removed in the next major release
+  */
+  set(key, value) {
+    /* eslint no-console: 0 */
+    console.warn('set is deprecated! Use append instead')
+    return this.append(key, value)
+  }
+
+  append(key, value) {
+    return this.add({ key, value })
+  }
+
+  prepend(key, value) {
+    return this.add({ key, value }, 'prepend')
+  }
+
+  insert(key, value, pos = {}) {
+    if (!(pos.before || pos.after)) return this.append(key, value)
+
+    const currentIndex = this.getIndex(key)
+    if (currentIndex >= 0) this.splice(currentIndex, 1)
+
+    let newIndex = this.getIndex(pos.before || pos.after)
+    if (pos.after) newIndex += 1
+
+    this.splice(newIndex, 0, { key, value })
+    return this
+  }
+
+  delete(key) {
+    const index = this.getIndex(key, true)
+    this.splice(index, 1)
+    return this
+  }
+
+  getIndex(key, shouldThrow = false) {
+    const index = this.findIndex(entry =>
+      (
+        entry === key ||
+        entry.key === key ||
+        (entry.constructor && entry.constructor.name === key)
+      ))
+
+    if (shouldThrow && index < 0) throw new Error(`Item ${key} not found`)
+    return index
+  }
+
+  add({ key, value }, strategy = 'append') {
+    const index = this.getIndex(key)
+    if (index >= 0) this.delete(key)
+
+    switch (strategy) {
+      case 'prepend':
+        this.unshift({ key, value })
+        break
+      default:
+        this.push({ key, value })
+    }
+
+    return this
+  }
+
+  values() {
+    return this.map(item => item.value)
+  }
+
+  keys() {
+    return this.map(item => item.key)
+  }
+}
+
+module.exports = ConfigList

data/package/config_types/config_object.js

@@ -0,0 +1,55 @@
+const objectify = require('../utils/objectify')
+const deepAssign = require('../utils/deep_assign')
+const deepMerge = require('../utils/deep_merge')
+const { isStrPath, prettyPrint } = require('../utils/helpers')
+
+/**
+  * @class
+  * @extends { Object }
+*/
+class ConfigObject extends Object {
+  constructor(props = {}) {
+    super()
+    this.merge(props)
+  }
+
+  get(key) {
+    return isStrPath(key) ? objectify(key, this) : this[key]
+  }
+
+  set(key, value) {
+    Object.assign(this, deepAssign(this, key, value))
+    return this
+  }
+
+  delete(key) {
+    let obj = this
+    let propKey = key
+
+    if (isStrPath(key)) {
+      const keys = key.split('.')
+      propKey = keys.pop()
+      const parentObjPath = keys.join('.')
+      obj = objectify(parentObjPath, this)
+    }
+
+    if (!obj) throw new Error(`Prop not found: ${key} in ${prettyPrint(obj)}`)
+    delete obj[propKey]
+
+    return this
+  }
+
+  toObject() {
+    const object = {}
+    /* eslint no-return-assign: 0 */
+    Object.keys(this).forEach(key => (object[key] = this[key]))
+    return object
+  }
+
+  merge(config) {
+    Object.assign(this, deepMerge(this, config))
+    return this
+  }
+}
+
+module.exports = ConfigObject

data/package/config_types/index.js

@@ -0,0 +1,7 @@
+const ConfigObject = require('./config_object')
+const ConfigList = require('./config_list')
+
+module.exports = {
+  ConfigObject,
+  ConfigList
+}

data/package/environment.js

@@ -0,0 +1,116 @@
+/* eslint global-require: 0 */
+/* eslint import/no-dynamic-require: 0 */
+
+const {
+  basename, dirname, join, relative, resolve
+} = require('path')
+const { sync } = require('glob')
+const extname = require('path-complete-extname')
+
+const webpack = require('webpack')
+const ExtractTextPlugin = require('extract-text-webpack-plugin')
+const ManifestPlugin = require('webpack-manifest-plugin')
+const CaseSensitivePathsPlugin = require('case-sensitive-paths-webpack-plugin')
+
+const { ConfigList, ConfigObject } = require('./config_types')
+const rules = require('./rules')
+const config = require('./config')
+
+const getLoaderList = () => {
+  const result = new ConfigList()
+  Object.keys(rules).forEach(key => result.append(key, rules[key]))
+  return result
+}
+
+const getPluginList = () => {
+  const result = new ConfigList()
+  result.append('Environment', new webpack.EnvironmentPlugin(JSON.parse(JSON.stringify(process.env))))
+  result.append('CaseSensitivePaths', new CaseSensitivePathsPlugin())
+  result.append('ExtractText', new ExtractTextPlugin('[name]-[contenthash].css'))
+  result.append('Manifest', new ManifestPlugin({ publicPath: config.publicPath, writeToFileEmit: true }))
+  return result
+}
+
+const getExtensionsGlob = () => {
+  const { extensions } = config
+  if (!extensions.length) {
+    throw new Error('You must configure at least one extension to compile in webpacker.yml')
+  }
+  return extensions.length === 1 ? `**/${extensions[0]}` : `**/*{${extensions.join(',')}}`
+}
+
+const getEntryObject = () => {
+  const result = new ConfigObject()
+  const glob = getExtensionsGlob()
+  const rootPath = join(config.source_path, config.source_entry_path)
+  const paths = sync(join(rootPath, glob))
+  paths.forEach((path) => {
+    const namespace = relative(join(rootPath), dirname(path))
+    const name = join(namespace, basename(path, extname(path)))
+    result.set(name, resolve(path))
+  })
+  return result
+}
+
+const getModulePaths = () => {
+  const result = new ConfigList()
+  result.append('source', resolve(config.source_path))
+  if (config.resolved_paths) {
+    config.resolved_paths.forEach(path => result.append(path, resolve(path)))
+  }
+  result.append('node_modules', 'node_modules')
+  return result
+}
+
+const getBaseConfig = () =>
+  new ConfigObject({
+    output: {
+      filename: '[name]-[chunkhash].js',
+      chunkFilename: '[name]-[chunkhash].chunk.js',
+      path: config.outputPath,
+      publicPath: config.publicPath
+    },
+
+    resolve: {
+      extensions: config.extensions
+    },
+
+    resolveLoader: {
+      modules: ['node_modules']
+    },
+
+    node: {
+      dgram: 'empty',
+      fs: 'empty',
+      net: 'empty',
+      tls: 'empty',
+      child_process: 'empty'
+    }
+  })
+
+module.exports = class Environment {
+  constructor() {
+    this.loaders = getLoaderList()
+    this.plugins = getPluginList()
+    this.config = getBaseConfig()
+    this.entry = getEntryObject()
+    this.resolvedModules = getModulePaths()
+  }
+
+  toWebpackConfig() {
+    return this.config.merge({
+      entry: this.entry.toObject(),
+
+      module: {
+        strictExportPresence: true,
+        rules: this.loaders.values()
+      },
+
+      plugins: this.plugins.values(),
+
+      resolve: {
+        modules: this.resolvedModules.values()
+      }
+    })
+  }
+}

data/package/environments/development.js

@@ -0,0 +1,46 @@
+const webpack = require('webpack')
+const Environment = require('../environment')
+const { dev_server: devServer, outputPath: contentBase, publicPath } = require('../config')
+
+module.exports = class extends Environment {
+  constructor() {
+    super()
+
+    if (devServer.hmr) {
+      this.plugins.append('HotModuleReplacement', new webpack.HotModuleReplacementPlugin())
+      this.plugins.append('NamedModules', new webpack.NamedModulesPlugin())
+      this.config.output.filename = '[name]-[hash].js'
+    }
+
+    this.config.merge({
+      devtool: 'cheap-module-source-map',
+      output: {
+        pathinfo: true
+      },
+      devServer: {
+        clientLogLevel: 'none',
+        compress: devServer.compress,
+        quiet: devServer.quiet,
+        disableHostCheck: devServer.disable_host_check,
+        host: devServer.host,
+        port: devServer.port,
+        https: devServer.https,
+        hot: devServer.hmr,
+        contentBase,
+        inline: devServer.inline,
+        useLocalIp: devServer.use_local_ip,
+        public: devServer.public,
+        publicPath,
+        historyApiFallback: {
+          disableDotRule: true
+        },
+        headers: devServer.headers,
+        overlay: devServer.overlay,
+        stats: {
+          errorDetails: true
+        },
+        watchOptions: devServer.watch_options
+      }
+    })
+  }
+}

data/package/environments/production.js

@@ -0,0 +1,37 @@
+const webpack = require('webpack')
+const CompressionPlugin = require('compression-webpack-plugin')
+const Environment = require('../environment')
+
+module.exports = class extends Environment {
+  constructor() {
+    super()
+
+    this.plugins.append('ModuleConcatenation', new webpack.optimize.ModuleConcatenationPlugin())
+
+    this.plugins.append('UglifyJs', new webpack.optimize.UglifyJsPlugin({
+      sourceMap: true,
+      mangle: {
+        safari10: true
+      },
+      compress: {
+        warnings: false,
+        comparisons: false
+      },
+      output: {
+        comments: false,
+        ascii_only: true
+      }
+    }))
+
+    this.plugins.append('Compression', new CompressionPlugin({
+      asset: '[path].gz[query]',
+      algorithm: 'gzip',
+      test: /\.(js|css|html|json|ico|svg|eot|otf|ttf)$/
+    }))
+
+    this.config.merge({
+      devtool: 'nosources-source-map',
+      stats: 'normal'
+    })
+  }
+}

data/package/environments/test.js

@@ -0,0 +1,3 @@
+const Environment = require('../environment')
+
+module.exports = class extends Environment {}

data/package/index.js

@@ -0,0 +1,20 @@
+/* eslint global-require: 0 */
+/* eslint import/no-dynamic-require: 0 */
+
+const { resolve } = require('path')
+const { existsSync } = require('fs')
+const Environment = require('./environment')
+const config = require('./config')
+const loaders = require('./rules')
+
+const createEnvironment = () => {
+  const path = resolve(__dirname, 'environments', `${process.env.NODE_ENV}.js`)
+  const constructor = existsSync(path) ? require(path) : Environment
+  return new constructor()
+}
+
+const environment = createEnvironment()
+
+module.exports = {
+  environment, config, loaders, Environment
+}

data/package/rules/babel.js

@@ -0,0 +1,13 @@
+const { join } = require('path')
+const { cache_path } = require('../config')
+
+module.exports = {
+  test: /\.(js|jsx)?(\.erb)?$/,
+  exclude: /node_modules/,
+  use: [{
+    loader: 'babel-loader',
+    options: {
+      cacheDirectory: join(cache_path, 'babel-loader')
+    }
+  }]
+}

data/package/rules/css.js

@@ -0,0 +1,39 @@
+const ExtractTextPlugin = require('extract-text-webpack-plugin')
+const path = require('path')
+const { dev_server: devServer } = require('../config')
+
+const postcssConfigPath = path.resolve(process.cwd(), '.postcssrc.yml')
+const isProduction = process.env.NODE_ENV === 'production'
+const inDevServer = process.argv.find(v => v.includes('webpack-dev-server'))
+const isHMR = inDevServer && (devServer && devServer.hmr)
+const extractCSS = !(isHMR) || isProduction
+
+const styleLoader = {
+  loader: 'style-loader',
+  options: {
+    hmr: isHMR,
+    sourceMap: true
+  }
+}
+
+const extractOptions = {
+  fallback: styleLoader,
+  use: [
+    { loader: 'css-loader', options: { minimize: isProduction, sourceMap: true, importLoaders: 2 } },
+    { loader: 'postcss-loader', options: { sourceMap: true, config: { path: postcssConfigPath } } }
+  ]
+}
+
+// For production extract styles to a separate bundle
+const extractCSSLoader = {
+  test: /\.(css)$/i,
+  use: ExtractTextPlugin.extract(extractOptions)
+}
+
+// For hot-reloading use regular loaders
+const inlineCSSLoader = {
+  test: /\.(css)$/i,
+  use: [styleLoader].concat(extractOptions.use)
+}
+
+module.exports = extractCSS ? extractCSSLoader : inlineCSSLoader