tiny-lite-sys 0.0.1

data/webpacker-5.4.4/package/environments/base.js

@@ -0,0 +1,176 @@
+/* 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 MiniCssExtractPlugin = require('mini-css-extract-plugin')
+const WebpackAssetsManifest = require('webpack-assets-manifest')
+const CaseSensitivePathsPlugin = require('case-sensitive-paths-webpack-plugin')
+const PnpWebpackPlugin = require('pnp-webpack-plugin')
+
+const { isNotObject, prettyPrint } = require('../utils/helpers')
+const deepMerge = require('../utils/deep_merge')
+
+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(process.env)
+  )
+  result.append('CaseSensitivePaths', new CaseSensitivePathsPlugin())
+  result.append(
+    'MiniCssExtract',
+    new MiniCssExtractPlugin({
+      filename: 'css/[name]-[contenthash:8].css',
+      chunkFilename: 'css/[name]-[contenthash:8].chunk.css'
+    })
+  )
+  result.append(
+    'Manifest',
+    new WebpackAssetsManifest({
+      entrypoints: true,
+      writeToDisk: true,
+      publicPath: config.publicPathWithoutCDN
+    })
+  )
+  return result
+}
+
+const getExtensionsGlob = () => {
+  const { extensions } = config
+  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)))
+    let assetPaths = resolve(path)
+
+    // Allows for multiple filetypes per entry (https://webpack.js.org/guides/entry-advanced/)
+    // Transforms the config object value to an array with all values under the same name
+    let previousPaths = result.get(name)
+    if (previousPaths) {
+      previousPaths = Array.isArray(previousPaths) ? previousPaths : [previousPaths]
+      previousPaths.push(assetPaths)
+      assetPaths = previousPaths
+    }
+
+    result.set(name, assetPaths)
+  })
+  return result
+}
+
+const getModulePaths = () => {
+  const result = new ConfigList()
+  result.append('source', resolve(config.source_path))
+  if (config.additional_paths) {
+    config.additional_paths.forEach((path) => result.append(path, resolve(path)))
+  }
+  result.append('node_modules', 'node_modules')
+  return result
+}
+
+const getBaseConfig = () => new ConfigObject({
+  mode: 'production',
+  output: {
+    filename: 'js/[name]-[contenthash].js',
+    chunkFilename: 'js/[name]-[contenthash].chunk.js',
+    hotUpdateChunkFilename: 'js/[id]-[hash].hot-update.js',
+    path: config.outputPath,
+    publicPath: config.publicPath
+  },
+
+  resolve: {
+    extensions: config.extensions,
+    plugins: [PnpWebpackPlugin]
+  },
+
+  resolveLoader: {
+    modules: ['node_modules'],
+    plugins: [PnpWebpackPlugin.moduleLoader(module)]
+  },
+
+  node: {
+    dgram: 'empty',
+    fs: 'empty',
+    net: 'empty',
+    tls: 'empty',
+    child_process: 'empty'
+  }
+})
+
+module.exports = class Base {
+  constructor() {
+    this.loaders = getLoaderList()
+    this.plugins = getPluginList()
+    this.config = getBaseConfig()
+    this.entry = getEntryObject()
+    this.resolvedModules = getModulePaths()
+  }
+
+  splitChunks(callback = null) {
+    let appConfig = {}
+    const defaultConfig = {
+      optimization: {
+        // Split vendor and common chunks
+        // https://twitter.com/wSokra/status/969633336732905474
+        splitChunks: {
+          chunks: 'all',
+          name: true
+        },
+        // Separate runtime chunk to enable long term caching
+        // https://twitter.com/wSokra/status/969679223278505985
+        runtimeChunk: true
+      }
+    }
+
+    if (callback) {
+      appConfig = callback(defaultConfig)
+      if (isNotObject(appConfig)) {
+        throw new Error(`
+          ${prettyPrint(appConfig)} is not a valid splitChunks configuration.
+          See https://webpack.js.org/plugins/split-chunks-plugin/#configuration
+        `)
+      }
+    }
+
+    return this.config.merge(deepMerge(defaultConfig, appConfig))
+  }
+
+  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/webpacker-5.4.4/package/environments/development.js

@@ -0,0 +1,53 @@
+const webpack = require('webpack')
+const Base = require('./base')
+const devServer = require('../dev_server')
+const { outputPath: contentBase, publicPath } = require('../config')
+
+module.exports = class extends Base {
+  constructor() {
+    super()
+
+    this.config.merge({
+      mode: 'development',
+      devtool: 'cheap-module-source-map'
+    })
+
+    if (process.env.WEBPACK_DEV_SERVER
+        && process.env.WEBPACK_DEV_SERVER !== 'undefined') {
+      if (devServer.hmr) {
+        this.plugins.append('HotModuleReplacement', new webpack.HotModuleReplacementPlugin())
+        this.config.output.filename = '[name]-[hash].js'
+      }
+
+      this.config.merge({
+        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: {
+            entrypoints: false,
+            errorDetails: true,
+            modules: false,
+            moduleTrace: false
+          },
+          watchOptions: devServer.watch_options
+        }
+      })
+    }
+  }
+}

data/webpacker-5.4.4/package/environments/production.js

@@ -0,0 +1,77 @@
+const TerserPlugin = require('terser-webpack-plugin')
+const CompressionPlugin = require('compression-webpack-plugin')
+const OptimizeCSSAssetsPlugin = require('optimize-css-assets-webpack-plugin')
+const safePostCssParser = require('postcss-safe-parser')
+const Base = require('./base')
+
+module.exports = class extends Base {
+  constructor() {
+    super()
+
+    this.plugins.append(
+      'Compression',
+      new CompressionPlugin({
+        filename: '[path].gz[query]',
+        algorithm: 'gzip',
+        test: /\.(js|css|html|json|ico|svg|eot|otf|ttf|map)$/
+      })
+    )
+
+    if ('brotli' in process.versions) {
+      this.plugins.append(
+        'Compression Brotli',
+        new CompressionPlugin({
+          filename: '[path].br[query]',
+          algorithm: 'brotliCompress',
+          test: /\.(js|css|html|json|ico|svg|eot|otf|ttf|map)$/
+        })
+      )
+    }
+
+    this.plugins.append(
+      'OptimizeCSSAssets',
+      new OptimizeCSSAssetsPlugin({
+        parser: safePostCssParser,
+        map: {
+          inline: false,
+          annotation: true
+        }
+      })
+    )
+
+    this.config.merge({
+      devtool: 'source-map',
+      stats: 'normal',
+      bail: true,
+      optimization: {
+        minimizer: [
+          new TerserPlugin({
+            parallel: Number.parseInt(process.env.WEBPACKER_PARALLEL, 10) || true,
+            cache: true,
+            sourceMap: true,
+            terserOptions: {
+              parse: {
+                // Let terser parse ecma 8 code but always output
+                // ES5 compliant code for older browsers
+                ecma: 8
+              },
+              compress: {
+                ecma: 5,
+                warnings: false,
+                comparisons: false
+              },
+              mangle: {
+                safari10: true
+              },
+              output: {
+                ecma: 5,
+                comments: false,
+                ascii_only: true
+              }
+            }
+          })
+        ]
+      }
+    })
+  }
+}

data/webpacker-5.4.4/package/environments/test.js

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

data/webpacker-5.4.4/package/index.js

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

data/webpacker-5.4.4/package/rules/babel.js

@@ -0,0 +1,28 @@
+const { resolve } = require('path')
+const { realpathSync } = require('fs')
+const { source_path: sourcePath, additional_paths: additionalPaths } = require('../config')
+const { nodeEnv } = require('../env')
+
+// Process application Javascript code with Babel.
+// Uses application .babelrc to apply any transformations
+module.exports = {
+  test: /\.(js|jsx|mjs|ts|tsx)?(\.erb)?$/,
+  include: [sourcePath, ...additionalPaths].map((p) => {
+    try {
+      return realpathSync(p)
+    } catch (e) {
+      return resolve(p)
+    }
+  }),
+  exclude: /node_modules/,
+  use: [
+    {
+      loader: 'babel-loader',
+      options: {
+        cacheDirectory: true,
+        cacheCompression: nodeEnv === 'production',
+        compact: nodeEnv === 'production'
+      }
+    }
+  ]
+}

data/webpacker-5.4.4/package/rules/css.js

@@ -0,0 +1,3 @@
+const getStyleRule = require('../utils/get_style_rule')
+
+module.exports = getStyleRule(/\.(css)$/i)

data/webpacker-5.4.4/package/rules/file.js

@@ -0,0 +1,21 @@
+const { join, normalize } = require('path')
+const { source_path: sourcePath, static_assets_extensions: fileExtensions } = require('../config')
+
+module.exports = {
+  test: new RegExp(`(${fileExtensions.join('|')})$`, 'i'),
+  use: [
+    {
+      loader: 'file-loader',
+      options: {
+        name(file) {
+          if (file.includes(normalize(sourcePath))) {
+            return 'media/[path][name]-[hash].[ext]'
+          }
+          return 'media/[folder]/[name]-[hash:8].[ext]'
+        },
+        esModule: false,
+        context: join(sourcePath)
+      }
+    }
+  ]
+}

data/webpacker-5.4.4/package/rules/index.js

@@ -0,0 +1,20 @@
+const babel = require('./babel')
+const file = require('./file')
+const css = require('./css')
+const sass = require('./sass')
+const moduleCss = require('./module.css')
+const moduleSass = require('./module.sass')
+const nodeModules = require('./node_modules')
+
+// Webpack loaders are processed in reverse order
+// https://webpack.js.org/concepts/loaders/#loader-features
+// Lastly, process static files using file loader
+module.exports = {
+  file,
+  css,
+  sass,
+  moduleCss,
+  moduleSass,
+  nodeModules,
+  babel
+}

data/webpacker-5.4.4/package/rules/module.css.js

@@ -0,0 +1,3 @@
+const getStyleRule = require('../utils/get_style_rule')
+
+module.exports = getStyleRule(/\.(css)$/i, true)

data/webpacker-5.4.4/package/rules/module.sass.js

@@ -0,0 +1,8 @@
+const getStyleRule = require('../utils/get_style_rule')
+
+module.exports = getStyleRule(/\.(scss|sass)$/i, true, [
+  {
+    loader: 'sass-loader',
+    options: { sourceMap: true }
+  }
+])

data/webpacker-5.4.4/package/rules/node_modules.js

@@ -0,0 +1,22 @@
+const { nodeEnv } = require('../env')
+
+// Compile standard ES features for JS in node_modules with Babel.
+//   Regex details for exclude: https://regex101.com/r/SKPnnv/1
+module.exports = {
+  test: /\.(js|mjs)$/,
+  include: /node_modules/,
+  exclude: /(?:@?babel(?:\/|\\{1,2}|-).+)|regenerator-runtime|core-js|^webpack$|^webpack-assets-manifest$|^webpack-cli$|^webpack-sources$|^@rails\/webpacker$/,
+  use: [
+    {
+      loader: 'babel-loader',
+      options: {
+        babelrc: false,
+        presets: [['@babel/preset-env', { modules: false }]],
+        cacheDirectory: true,
+        cacheCompression: nodeEnv === 'production',
+        compact: false,
+        sourceMaps: false
+      }
+    }
+  ]
+}

data/webpacker-5.4.4/package/rules/sass.js

@@ -0,0 +1,17 @@
+/* eslint global-require: 0 */
+
+const getStyleRule = require('../utils/get_style_rule')
+const { additional_paths: includePaths } = require('../config')
+
+module.exports = getStyleRule(/\.(scss|sass)(\.erb)?$/i, false, [
+  {
+    loader: 'sass-loader',
+    options: {
+      sourceMap: true,
+      implementation: require('sass'),
+      sassOptions: {
+        includePaths
+      }
+    }
+  }
+])

data/webpacker-5.4.4/package/utils/__tests__/deep_assign.js

@@ -0,0 +1,32 @@
+/* global test expect */
+
+const deepAssign = require('../deep_assign')
+
+describe('deepAssign()', () => {
+  test('deeply assigns nested properties', () => {
+    const object = { foo: { bar: { } } }
+    const path = 'foo.bar'
+    const value = { x: 1, y: 2 }
+    const expectation = { foo: { bar: { x: 1, y: 2 } } }
+    expect(deepAssign(object, path, value)).toEqual(expectation)
+  })
+
+  test('allows assignment of a literal false', () => {
+    const object = { foo: { bar: { } } }
+    const path = 'foo.bar'
+    const value = false
+    const expectation = { foo: { bar: false } }
+    expect(deepAssign(object, path, value)).toEqual(expectation)
+  })
+
+  test('does not allow assignment of other falsy values', () => {
+    const object = { foo: { bar: { } } }
+    const path = 'foo.bar'
+    const values = [undefined, null, 0, '']
+
+    values.forEach(value => {
+      const expectation = new Error(`Value can't be ${value}`)
+      expect(() => deepAssign(object, path, value)).toThrow(expectation)
+    })
+  })
+})

data/webpacker-5.4.4/package/utils/__tests__/deep_merge.js

@@ -0,0 +1,10 @@
+/* global test expect */
+
+const deepMerge = require('../deep_merge')
+
+test('deep merge objects together', () => {
+  const object1 = { foo: { bar: [1, 2, 3], z: 1 }, x: 0 }
+  const object2 = { foo: { bar: ['x', 'y'] }, x: 1, y: 2 }
+  const expectation = { foo: { bar: [1, 2, 3, 'x', 'y'], z: 1 }, x: 1, y: 2 }
+  expect(deepMerge(object1, object2)).toEqual(expectation)
+})

data/webpacker-5.4.4/package/utils/__tests__/get_style_rule.js

@@ -0,0 +1,65 @@
+const { chdirTestApp, chdirCwd } = require('../helpers')
+
+chdirTestApp()
+
+const getStyleRule = require('../get_style_rule')
+
+describe('getStyleRule', () => {
+  afterAll(chdirCwd)
+
+  test('excludes modules by default', () => {
+    const cssRule = getStyleRule(/\.(css)$/i)
+    const expectation = {
+      test: /\.(css)$/i,
+      exclude: /\.module\.[a-z]+$/
+    }
+
+    expect(cssRule).toMatchObject(expectation)
+  })
+
+  test('includes modules if set to true', () => {
+    const cssRule = getStyleRule(/\.(scss)$/i, true)
+    const expectation = {
+      test: /\.(scss)$/i,
+      include: /\.module\.[a-z]+$/
+    }
+
+    expect(cssRule).toMatchObject(expectation)
+  })
+
+  test('adds extra preprocessors if supplied', () => {
+    const expectation = [{ foo: 'bar' }]
+    const cssRule = getStyleRule(/\.(css)$/i, true, expectation)
+
+    expect(cssRule.use).toMatchObject(expect.arrayContaining(expectation))
+  })
+
+  test('adds mini-css-extract-plugin when extract_css is true', () => {
+    const MiniCssExtractPlugin = require('mini-css-extract-plugin')
+    const expectation = [MiniCssExtractPlugin.loader]
+
+    require('../../config').extract_css = true
+    const cssRule = getStyleRule(/\.(css)$/i)
+
+    expect(cssRule.use).toMatchObject(expect.arrayContaining(expectation))
+  })
+
+  test('adds style-loader when extract_css is true', () => {
+    const expectation = [{loader: 'style-loader'}]
+
+    require('../../config').extract_css = false
+    const cssRule = getStyleRule(/\.(css)$/i)
+
+    expect(cssRule.use).toMatchObject(expect.objectContaining(expectation))
+  })
+
+  test(`doesn't add mini-css-extract-plugin when extract_css is false`, () => {
+    const MiniCssExtractPlugin = require('mini-css-extract-plugin')
+    const expectation = [MiniCssExtractPlugin.loader]
+
+    require('../../config').extract_css = false
+    const cssRule = getStyleRule(/\.(css)$/i)
+
+    expect(cssRule.use).toMatchObject(expect.not.arrayContaining(expectation))
+  })
+})

data/webpacker-5.4.4/package/utils/__tests__/objectify.js

@@ -0,0 +1,9 @@
+/* global test expect */
+
+const objectify = require('../objectify')
+
+test('Get object from a string path', () => {
+  const object = { foo: { bar: { x: 1 } } }
+  expect(objectify('foo.bar', object)).toEqual({ x: 1 })
+  expect(objectify('some.bar', object)).toEqual(undefined)
+})

data/webpacker-5.4.4/package/utils/deep_assign.js

@@ -0,0 +1,22 @@
+const { canMerge, prettyPrint } = require('./helpers')
+const deepMerge = require('./deep_merge')
+
+const deepAssign = (obj, path, value) => {
+  if (!value && value !== false) throw new Error(`Value can't be ${value}`)
+
+  const keys = path.split('.')
+  const key = keys.pop()
+
+  const objRef = keys.reduce((acc, currentValue) => {
+    /* eslint no-param-reassign: 0 */
+    if (!acc[currentValue]) acc[currentValue] = {}
+    return acc[currentValue]
+  }, obj)
+
+  if (!objRef) throw new Error(`Prop not found: ${path} in ${prettyPrint(obj)}`)
+
+  objRef[key] = canMerge(value) ? deepMerge(objRef[key], value) : value
+  return obj
+}
+
+module.exports = deepAssign

data/webpacker-5.4.4/package/utils/deep_merge.js

@@ -0,0 +1,22 @@
+const {
+  isObject, isArray, isEqual, isEmpty
+} = require('./helpers')
+
+const deepMerge = (target, source) => {
+  if (isEmpty(target)) return source
+  if (isEmpty(source)) return target
+  if (isEqual(target, source)) return source
+  if (isArray(target) && isArray(source)) return [...new Set([...target, ...source])]
+  if (!(isObject(target) && isObject(source))) return source
+
+  return [...Object.keys(target), ...Object.keys(source)].reduce(
+    (result, key) => ({
+
+      ...result,
+      [key]: deepMerge(target[key], source[key])
+    }),
+    {}
+  )
+}
+
+module.exports = deepMerge

data/webpacker-5.4.4/package/utils/get_style_rule.js

@@ -0,0 +1,45 @@
+const MiniCssExtractPlugin = require('mini-css-extract-plugin')
+const { resolve } = require('path')
+const config = require('../config')
+
+const styleLoader = {
+  loader: 'style-loader'
+}
+
+const getStyleRule = (test, modules = false, preprocessors = []) => {
+  const use = [
+    {
+      loader: 'css-loader',
+      options: {
+        sourceMap: true,
+        importLoaders: 2,
+        modules: modules ? {
+          localIdentName: '[name]__[local]___[hash:base64:5]'
+        } : false
+      }
+    },
+    {
+      loader: 'postcss-loader',
+      options: {
+        config: { path: resolve() },
+        sourceMap: true
+      }
+    },
+    ...preprocessors
+  ]
+
+  const options = modules ? { include: /\.module\.[a-z]+$/ } : { exclude: /\.module\.[a-z]+$/ }
+
+  if (config.extract_css) {
+    use.unshift(MiniCssExtractPlugin.loader)
+  } else {
+    use.unshift(styleLoader)
+  }
+
+  // sideEffects - See https://github.com/webpack/webpack/issues/6571
+  return {
+    test, use, sideEffects: !modules, ...options
+  }
+}
+
+module.exports = getStyleRule