expeditaea 1.0.0

package/packages/webpack/src/utils/style-loader.js

@@ -0,0 +1,157 @@
+import path from 'path'
+import ExtractCssChunksPlugin from 'extract-css-chunks-webpack-plugin'
+
+import { wrapArray } from '@nuxt/utils'
+
+import PostcssConfig from './postcss'
+import PostcssV8Config from './postcss-v8'
+
+export default class StyleLoader {
+  constructor (buildContext, { isServer, perfLoader, resolveModule }) {
+    this.buildContext = buildContext
+    this.isServer = isServer
+    this.perfLoader = perfLoader
+    this.resolveModule = resolveModule
+
+    const { postcss: postcssOptions } = buildContext.options.build
+    if (postcssOptions) {
+      const postcss = require(resolveModule('postcss'))
+      // postcss >= v8
+      if (!postcss.vendor) {
+        this.postcssConfig = new PostcssV8Config(buildContext)
+      } else {
+        this.postcssConfig = new PostcssConfig(buildContext)
+      }
+    }
+  }
+
+  get extractCSS () {
+    return this.buildContext.buildOptions.extractCSS
+  }
+
+  get exportOnlyLocals () {
+    return Boolean(this.isServer && this.extractCSS)
+  }
+
+  isUrlResolvingEnabled (url, resourcePath) {
+    // Ignore absolute URLs, it will be handled by serve-static.
+    return !url.startsWith('/')
+  }
+
+  normalize (loaders) {
+    loaders = wrapArray(loaders)
+    return loaders.map(loader => (typeof loader === 'string' ? { loader } : loader))
+  }
+
+  styleResource (ext) {
+    const { buildOptions: { styleResources }, options: { rootDir } } = this.buildContext
+    const extResource = styleResources[ext]
+    // style-resources-loader
+    // https://github.com/yenshih/style-resources-loader
+    if (!extResource) {
+      return
+    }
+    const patterns = wrapArray(extResource).map(p => path.resolve(rootDir, p))
+
+    return {
+      loader: this.resolveModule('style-resources-loader'),
+      options: Object.assign(
+        { patterns },
+        styleResources.options || {}
+      )
+    }
+  }
+
+  postcss () {
+    // postcss-loader
+    // https://github.com/postcss/postcss-loader
+    if (!this.postcssConfig) {
+      return
+    }
+
+    const config = this.postcssConfig.config()
+
+    if (!config) {
+      return
+    }
+
+    return {
+      loader: this.resolveModule('postcss-loader'),
+      options: Object.assign({ sourceMap: this.buildContext.buildOptions.cssSourceMap }, config)
+    }
+  }
+
+  css (options) {
+    const cssLoader = { loader: this.resolveModule('css-loader'), options }
+
+    if (!options.url) {
+      options.url = this.isUrlResolvingEnabled
+    }
+
+    if (this.exportOnlyLocals) {
+      options.modules = {
+        ...options.modules,
+        exportOnlyLocals: true
+      }
+      return [cssLoader]
+    }
+
+    return [this.styleLoader(), cssLoader]
+  }
+
+  cssModules (options) {
+    return this.css(options)
+  }
+
+  extract () {
+    if (this.extractCSS) {
+      const isDev = this.buildContext.options.dev
+      return {
+        loader: ExtractCssChunksPlugin.loader,
+        options: {
+          // TODO: https://github.com/faceyspacey/extract-css-chunks-webpack-plugin/issues/132
+          // https://github.com/faceyspacey/extract-css-chunks-webpack-plugin/issues/161#issuecomment-500162574
+          reloadAll: isDev,
+          hmr: isDev
+        }
+      }
+    }
+  }
+
+  styleLoader () {
+    return this.extract() || {
+      loader: this.resolveModule('vue-style-loader'),
+      options: this.buildContext.buildOptions.loaders.vueStyle
+    }
+  }
+
+  apply (ext, loaders = []) {
+    const { css, cssModules } = this.buildContext.buildOptions.loaders
+
+    const customLoaders = [].concat(
+      this.postcss(),
+      this.normalize(loaders),
+      this.styleResource(ext)
+    ).filter(Boolean)
+
+    css.importLoaders = cssModules.importLoaders = customLoaders.length
+
+    return [
+      // This matches <style module>
+      {
+        resourceQuery: /module/,
+        use: this.perfLoader.css().concat(
+          this.cssModules(cssModules),
+          customLoaders
+        )
+      },
+      // This matches plain <style> or <style scoped>
+      {
+        use: this.perfLoader.css().concat(
+          this.css(css),
+          customLoaders
+        )
+      }
+    ]
+  }
+}

package/packages/webpack/test/index.test.js

@@ -0,0 +1,23 @@
+import WebpackBaseConfig from '../src/config/base'
+
+describe('webpack: babel', () => {
+  const getConfigWithPlugins = plugins =>
+    new WebpackBaseConfig({
+      buildContext: {
+        options: {
+          dev: false
+        },
+        buildOptions: {
+          babel: {
+            plugins
+          }
+        }
+      }
+    })
+  test('should allow defining plugins with an array', () => {
+    expect(getConfigWithPlugins(['myPlugin']).getBabelOptions().plugins).toEqual(['myPlugin'])
+  })
+  test('should allow defining plugins with a function', () => {
+    expect(getConfigWithPlugins(({ isDev }) => [`myPlugin-${isDev}`]).getBabelOptions().plugins).toEqual(['myPlugin-false'])
+  })
+})

package/renovate.json

@@ -0,0 +1,27 @@
+{
+  "extends": [
+    "@nuxtjs"
+  ],
+  "baseBranches": [
+    "dev"
+  ],
+  "ignoreDeps": [
+    "core-js",
+    "postcss",
+    "postcss-import",
+    "postcss-loader",
+    "postcss-url",
+    "css-loader",
+    "sass-loader",
+    "npm",
+    "html-webpack-plugin",
+    "terser-webpack-plugin",
+    "@types/webpack-dev-middleware",
+    "@types/terser-webpack-plugin",
+    "@types/webpack-bundle-analyzer",
+    "wrap-ansi"
+  ],
+  "lockFileMaintenance": {
+    "enabled": true
+  }
+}

package/scripts/builtins.js

@@ -0,0 +1,22 @@
+/*
+** Core logic from https://github.com/sindresorhus/builtin-modules
+** Many thanks to @sindresorhus
+*/
+import Module from 'module'
+
+const blacklist = [
+  'sys'
+]
+
+export const builtins = Module.builtinModules
+  .filter(x => !/^_|^(internal|v8|node-inspect)\/|\//.test(x) && !blacklist.includes(x))
+  .sort()
+
+let builtinsObj = null
+
+const convertToObj = () => builtins.reduce((obj, builtin) => {
+  obj[builtin] = true
+  return obj
+}, (builtinsObj = {}))
+
+export const builtinsMap = () => builtinsObj || convertToObj()

package/scripts/changelog.js

@@ -0,0 +1,154 @@
+import consola from 'consola'
+import execa from 'execa'
+import { uniq, sortBy, groupBy } from 'lodash'
+import { writeFile } from 'fs-extra'
+
+const types = {
+  fix: { title: '🐛 Bug Fixes' },
+  feat: { title: '🚀 Features' },
+  refactor: { title: '💅 Refactors' },
+  perf: { title: '🔥 Performance' },
+  examples: { title: '📝 Examples' },
+  chore: { title: '🏡 Chore' },
+  test: { title: '👓 Tests' },
+  types: { title: '🇹 Types' }
+}
+
+const knownAuthors = [
+  'chopin',
+  'parsa',
+  'clark',
+  'galvez',
+  'lichter',
+  'molotkov',
+  'marrec',
+  'pim',
+  'daniel roe',
+  'danielroe'
+]
+
+const isKnownAuthor = name => Boolean(knownAuthors.find(n => name.toLowerCase().includes(n)))
+
+const allowedTypes = Object.keys(types)
+
+async function main () {
+  // Get last git tag
+  const lastGitTag = await getLastGitTag()
+
+  // Get current branch
+  const currentGitBranch = await getCurrentGitBranch()
+
+  // Get all commits from last release to current branch
+  consola.log(`${currentGitBranch}...${lastGitTag}`)
+  let commits = await getGitDiff(currentGitBranch, lastGitTag)
+
+  // Parse commits as conventional commits
+  commits = parseCommits(commits)
+
+  // Filter commits
+  commits = commits.filter(c =>
+    allowedTypes.includes(c.type) &&
+    c.scope !== 'deps'
+  )
+
+  // Generate markdown
+  const markdown = generateMarkDown(commits)
+
+  process.stdout.write('\n\n' + markdown + '\n\n')
+  await writeFile('CHANGELOG.md', markdown, 'utf-8')
+}
+
+function execCommand (cmd, args) {
+  return execa(cmd, args).then(r => r.stdout)
+}
+
+async function getLastGitTag () {
+  const r = await execCommand('git', ['--no-pager', 'tag', '-l', '--sort=taggerdate']).then(r => r.split('\n'))
+  return r[r.length - 1]
+}
+
+async function getCurrentGitBranch () {
+  const r = await execCommand('git', ['rev-parse', '--abbrev-ref', 'HEAD'])
+  return r
+}
+
+async function getGitDiff (from, to) {
+  // # https://git-scm.com/docs/pretty-formats
+  const r = await execCommand('git', ['--no-pager', 'log', `${from}...${to}`, '--pretty=%s|%h|%an|%ae'])
+  return r.split('\n').map((line) => {
+    const [message, commit, authorName, authorEmail] = line.split('|')
+
+    return { message, commit, authorName, authorEmail }
+  })
+}
+
+function parseCommits (commits) {
+  return commits.filter(c => c.message.includes(':')).map((commit) => {
+    let [type, ...message] = commit.message.split(':')
+    message = message.join(':')
+
+    // Extract references from message
+    message = message.replace(/\((fixes) #\d+\)/g, '')
+    const references = []
+    const referencesRegex = /#[0-9]+/g
+    let m
+    while (m = referencesRegex.exec(message)) { // eslint-disable-line no-cond-assign
+      references.push(m[0])
+    }
+
+    // Remove references and normalize
+    message = message.replace(referencesRegex, '').replace(/\(\)/g, '').trim()
+
+    // Extract scope from type
+    let scope = type.match(/\((.*)\)/)
+    if (scope) {
+      scope = scope[1]
+    }
+    if (!scope) {
+      scope = 'general'
+    }
+    type = type.split('(')[0]
+
+    return {
+      ...commit,
+      message,
+      type,
+      scope,
+      references
+    }
+  })
+}
+
+function generateMarkDown (commits) {
+  const typeGroups = groupBy(commits, 'type')
+
+  let markdown = ''
+
+  for (const type of allowedTypes) {
+    const group = typeGroups[type]
+    if (!group || !group.length) {
+      continue
+    }
+
+    const { title } = types[type]
+    markdown += '\n\n' + '### ' + title + '\n\n'
+
+    const scopeGroups = groupBy(group, 'scope')
+    for (const scopeName in scopeGroups) {
+      markdown += '- `' + scopeName + '`' + '\n'
+      for (const commit of scopeGroups[scopeName]) {
+        markdown += '  - ' + commit.references.join(', ') + (commit.references.length ? ' ' : '') + commit.message.replace(/^(.)/, v => v.toUpperCase()) + '\n'
+      }
+    }
+  }
+
+  const authors = sortBy(uniq(commits.map(commit => commit.authorName).filter(an => !isKnownAuthor(an))))
+  if (authors.length) {
+    markdown += '\n\n' + '### ' + '💖 Thanks to' + '\n\n'
+    markdown += authors.map(name => '- ' + name).join('\n')
+  }
+
+  return markdown.trim()
+}
+
+main().catch(consola.error)

package/scripts/dev.js

@@ -0,0 +1,39 @@
+import path from 'path'
+import fs from 'fs-extra'
+import consola from 'consola'
+
+import Package from './package.js'
+
+const useCjs = [
+  '@nuxt/cli'
+]
+
+const stub = {
+  es: 'export * from \'../src/index\'',
+  cjs: `const _require = typeof jest === 'undefined' ? require('jiti')(__dirname) : require
+  global.__NUXT_DEV__ = true
+  module.exports = _require('../src/index')
+`
+}
+
+async function main () {
+  // Read package at current directory
+  const rootPackage = new Package()
+  const workspacePackages = await rootPackage.getWorkspacePackages()
+
+  // Create a dev-only entrypoint to the src
+  for (const pkg of workspacePackages) {
+    if (!pkg.pkg.main || !pkg.options.build) {
+      continue
+    }
+    consola.info(pkg.pkg.main)
+    const distMain = pkg.resolvePath(pkg.pkg.main)
+    await fs.mkdirp(path.dirname(distMain))
+    await fs.writeFile(distMain, useCjs.includes(pkg.pkg.name) ? stub.cjs : stub.es)
+  }
+}
+
+main().catch((error) => {
+  consola.error(error)
+  process.exit(1)
+})

package/scripts/link.js

@@ -0,0 +1,28 @@
+import path from 'path'
+import consola from 'consola'
+import execa from 'execa'
+import fs from 'fs-extra'
+import _glob from 'glob'
+import pify from 'pify'
+
+const glob = pify(_glob) // TODO: use globby
+
+async function main () {
+  const packageDirs = await glob('+(packages|distributions)/*')
+
+  const packages = packageDirs.map(pkgDir => ({
+    dir: pkgDir,
+    pkg: fs.readJSONSync(path.join(pkgDir, 'package.json'))
+  }))
+
+  const packageNames = packages.map(p => p.pkg.name).join(' ')
+
+  consola.info(`Linking ${packages.length} packages...`)
+
+  await Promise.all(packages.map(pkg => execa('yarn', ['link'], { cwd: pkg.dir })))
+
+  consola.log(`Link: \nyarn link ${packageNames}\n`)
+  consola.log(`Unlink: \nyarn unlink ${packageNames}\n`)
+}
+
+main().catch(consola.error)