@mpxjs/webpack-plugin 2.7.53 → 2.7.55

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpxjs/webpack-plugin",
-  "version": "2.7.53",
+  "version": "2.7.55",
   "description": "mpx compile core",
   "keywords": [
     "mpx"
@@ -80,5 +80,5 @@
   "engines": {
     "node": ">=14.14.0"
   },
-  "gitHead": "33d25192ef4411be890f1af07a8b6d11557403e4"
+  "gitHead": "988b3f83c36ba5280ee7d050fc8b610ae4f3ad86"
 }

package/lib/wxss/compile-exports.js

@@ -1,52 +0,0 @@
-var camelCase = require('lodash.camelcase')
-
-function dashesCamelCase (str) {
-  return str.replace(/-+(\w)/g, function (match, firstLetter) {
-    return firstLetter.toUpperCase()
-  })
-}
-
-module.exports = function compileExports (result, importItemMatcher, camelCaseKeys) {
-  if (!Object.keys(result.exports).length) {
-    return ''
-  }
-
-  var exportJs = Object.keys(result.exports).reduce(function (res, key) {
-    var valueAsString = JSON.stringify(result.exports[key])
-    valueAsString = valueAsString.replace(result.importItemRegExpG, importItemMatcher)
-
-    function addEntry (k) {
-      res.push('\t' + JSON.stringify(k) + ': ' + valueAsString)
-    }
-
-    var targetKey
-    switch (camelCaseKeys) {
-      case true:
-        addEntry(key)
-        targetKey = camelCase(key)
-        if (targetKey !== key) {
-          addEntry(targetKey)
-        }
-        break
-      case 'dashes':
-        addEntry(key)
-        targetKey = dashesCamelCase(key)
-        if (targetKey !== key) {
-          addEntry(targetKey)
-        }
-        break
-      case 'only':
-        addEntry(camelCase(key))
-        break
-      case 'dashesOnly':
-        addEntry(dashesCamelCase(key))
-        break
-      default:
-        addEntry(key)
-        break
-    }
-    return res
-  }, []).join(',\n')
-
-  return '{\n' + exportJs + '\n}'
-}

package/lib/wxss/createResolver.js

@@ -1,36 +0,0 @@
-module.exports = function createResolver (alias) {
-  if (typeof alias !== 'object' || Array.isArray(alias)) {
-    return function (url) {
-      return url
-    }
-  }
-
-  alias = Object.keys(alias).map(function (key) {
-    var onlyModule = false
-    var obj = alias[key]
-    if (/\$$/.test(key)) {
-      onlyModule = true
-      key = key.substr(0, key.length - 1)
-    }
-    if (typeof obj === 'string') {
-      obj = {
-        alias: obj
-      }
-    }
-    obj = Object.assign({
-      name: key,
-      onlyModule: onlyModule
-    }, obj)
-    return obj
-  })
-
-  return function (url) {
-    alias.forEach(function (obj) {
-      var name = obj.name
-      if (url === name || (!obj.onlyModule && url.startsWith(name + '/'))) {
-        url = obj.alias + url.substr(name.length)
-      }
-    })
-    return url
-  }
-}

package/lib/wxss/css-base.js

@@ -1,79 +0,0 @@
-/*
-  MIT License http://www.opensource.org/licenses/mit-license.php
-  Author Tobias Koppers @sokra
-  Modified by @hiyuki
-*/
-// css base code, injected by the css-loader
-module.exports = function (useSourceMap) {
-  var list = []
-
-  // return the list of modules as css string
-  list.toString = function toString () {
-    return this.map(function (item) {
-      var content = cssWithMappingToString(item, useSourceMap)
-      if (item[2]) {
-        return '@media ' + item[2] + '{' + content + '}'
-      } else {
-        return content
-      }
-    }).join('')
-  }
-
-  // import a list of modules into the list
-  list.i = function (modules, mediaQuery) {
-    if (typeof modules === 'string') {
-      modules = [[null, modules, '']]
-    }
-    var alreadyImportedModules = {}
-    for (var i = 0; i < this.length; i++) {
-      var id = this[i][0]
-      if (typeof id === 'number') {
-        alreadyImportedModules[id] = true
-      }
-    }
-    for (i = 0; i < modules.length; i++) {
-      var item = modules[i]
-      // skip already imported module
-      // this implementation is not 100% perfect for weird media query combinations
-      //  when a module is imported multiple times with different media queries.
-      //  I hope this will never occur (Hey this way we have smaller bundles)
-      if (typeof item[0] !== 'number' || !alreadyImportedModules[item[0]]) {
-        if (mediaQuery && !item[2]) {
-          item[2] = mediaQuery
-        } else if (mediaQuery) {
-          item[2] = '(' + item[2] + ') and (' + mediaQuery + ')'
-        }
-        list.push(item)
-      }
-    }
-  }
-  return list
-}
-
-function cssWithMappingToString (item, useSourceMap) {
-  var content = item[1] || ''
-  var cssMapping = item[3]
-  if (!cssMapping) {
-    return content
-  }
-
-  if (useSourceMap && typeof btoa === 'function') {
-    var sourceMapping = toComment(cssMapping)
-    var sourceURLs = cssMapping.sources.map(function (source) {
-      return '/*# sourceURL=' + cssMapping.sourceRoot + source + ' */'
-    })
-
-    return [content].concat(sourceURLs).concat([sourceMapping]).join('\n')
-  }
-
-  return [content].join('\n')
-}
-
-// Adapted from convert-source-map (MIT)
-function toComment (sourceMap) {
-  // eslint-disable-next-line no-undef
-  var base64 = btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap))))
-  var data = 'sourceMappingURL=data:application/json;charset=utf-8;base64,' + base64
-
-  return '/*# ' + data + ' */'
-}

package/lib/wxss/getLocalIdent.js

@@ -1,24 +0,0 @@
-/*
-  MIT License http://www.opensource.org/licenses/mit-license.php
-  Author Tobias Koppers @sokra
-  Modified by @hiyuki
-*/
-var loaderUtils = require('loader-utils')
-var path = require('path')
-
-module.exports = function getLocalIdent (loaderContext, localIdentName, localName, options) {
-  if (!options.context) {
-    if (loaderContext.rootContext) {
-      options.context = loaderContext.rootContext
-    } else if (loaderContext.options && typeof loaderContext.options.context === 'string') {
-      options.context = loaderContext.options.context
-    } else {
-      options.context = loaderContext.context
-    }
-  }
-  var request = path.relative(options.context, loaderContext.resourcePath)
-  options.content = options.hashPrefix + request + '+' + localName
-  localIdentName = localIdentName.replace(/\[local\]/gi, localName)
-  var hash = loaderUtils.interpolateName(loaderContext, localIdentName, options)
-  return hash.replace(new RegExp('[^a-zA-Z0-9\\-_\u00A0-\uFFFF]', 'g'), '-').replace(/^((-?[0-9])|--)/, '_$1')
-}

package/lib/wxss/localsLoader.js

@@ -1,44 +0,0 @@
-/*
-  MIT License http://www.opensource.org/licenses/mit-license.php
-  Author Tobias Koppers @sokra
-  Modified by @hiyuki
-*/
-var loaderUtils = require('loader-utils')
-var processCss = require('./processCss')
-var compileExports = require('./compile-exports')
-var createResolver = require('./createResolver')
-
-module.exports = function (content) {
-  if (this.cacheable) this.cacheable()
-  var callback = this.async()
-  var query = loaderUtils.getOptions(this) || {}
-  var moduleMode = query.modules || query.module
-  var camelCaseKeys = query.camelCase || query.camelcase
-  var resolve = createResolver(query.alias)
-
-  processCss(content, null, {
-    mode: moduleMode ? 'local' : 'global',
-    query: query,
-    minimize: this.minimize,
-    loaderContext: this,
-    resolve: resolve
-  }, function (err, result) {
-    if (err) return callback(err)
-
-    function importItemMatcher (item) {
-      var match = result.importItemRegExp.exec(item)
-      var idx = +match[1]
-      var importItem = result.importItems[idx]
-      var importUrl = importItem.url
-      return '" + require(' + loaderUtils.stringifyRequest(this, importUrl) + ')' +
-        '[' + JSON.stringify(importItem.export) + '] + "'
-    }
-
-    var exportJs = compileExports(result, importItemMatcher.bind(this), camelCaseKeys)
-    if (exportJs) {
-      exportJs = 'module.exports = ' + exportJs + ';'
-    }
-
-    callback(null, exportJs)
-  }.bind(this))
-}

package/lib/wxss/processCss.js

@@ -1,271 +0,0 @@
-/*
-  MIT License http://www.opensource.org/licenses/mit-license.php
-  Author Tobias Koppers @sokra
-  Modified by @hiyuki
-*/
-const formatCodeFrame = require('@babel/code-frame')
-const Tokenizer = require('css-selector-tokenizer')
-const postcss = require('postcss')
-const loaderUtils = require('loader-utils')
-const assign = require('object-assign')
-const getLocalIdent = require('./getLocalIdent')
-
-const icssUtils = require('icss-utils')
-const localByDefault = require('postcss-modules-local-by-default')
-const extractImports = require('postcss-modules-extract-imports')
-const modulesScope = require('postcss-modules-scope')
-const modulesValues = require('postcss-modules-values')
-const valueParser = require('postcss-value-parser')
-const isUrlRequest = require('../utils/is-url-request')
-// css-loader-parser
-
-const parserPlugin = function (options) {
-  return {
-    postcssPlugin: 'css-loader-parser',
-    Once (css) {
-      const imports = {}
-      let exports = {}
-      const importItems = []
-      const urlItems = []
-
-      function replaceImportsInString (str) {
-        if (options.import) {
-          const tokens = valueParser(str)
-          tokens.walk(function (node) {
-            if (node.type !== 'word') {
-              return
-            }
-            const token = node.value
-            const importIndex = imports['$' + token]
-            if (typeof importIndex === 'number') {
-              node.value = '___CSS_LOADER_IMPORT___' + importIndex + '___'
-            }
-          })
-          return tokens.toString()
-        }
-        return str
-      }
-
-      if (options.import) {
-        css.walkAtRules(/^import$/i, function (rule) {
-          const values = Tokenizer.parseValues(rule.params)
-          let url = values.nodes[0].nodes[0]
-          if (url && url.type === 'url') {
-            url = url.url
-          } else if (url && url.type === 'string') {
-            url = url.value
-          } else throw rule.error('Unexpected format ' + rule.params)
-          if (!url.replace(/\s/g, '').length) {
-            return
-          }
-          values.nodes[0].nodes.shift()
-          const mediaQuery = Tokenizer.stringifyValues(values)
-
-          if (isUrlRequest(url, options.root)) {
-            url = loaderUtils.urlToRequest(url, options.root)
-          }
-
-          importItems.push({
-            url: url,
-            mediaQuery: mediaQuery
-          })
-          rule.remove()
-        })
-      }
-
-      const icss = icssUtils.extractICSS(css)
-      exports = icss.icssExports
-      Object.keys(icss.icssImports).forEach(function (key) {
-        const url = loaderUtils.parseString(key)
-        Object.keys(icss.icssImports[key]).forEach(function (prop) {
-          imports['$' + prop] = importItems.length
-          importItems.push({
-            url: url,
-            export: icss.icssImports[key][prop]
-          })
-        })
-      })
-
-      Object.keys(exports).forEach(function (exportName) {
-        exports[exportName] = replaceImportsInString(exports[exportName])
-      })
-
-      function isAlias (url) {
-        // Handle alias starting by / and root disabled
-        return url !== options.resolve(url)
-      }
-
-      function processNode (item) {
-        switch (item.type) {
-          case 'value':
-            item.nodes.forEach(processNode)
-            break
-          case 'nested-item':
-            item.nodes.forEach(processNode)
-            break
-          case 'item':
-            const importIndex = imports['$' + item.name]
-            if (typeof importIndex === 'number') {
-              item.name = '___CSS_LOADER_IMPORT___' + importIndex + '___'
-            }
-            break
-          case 'url':
-            if (options.url && item.url.replace(/\s/g, '').length && !/^#/.test(item.url) && (isAlias(item.url) || isUrlRequest(item.url, options.root))) {
-              // Strip quotes, they will be re-added if the module needs them
-              item.stringType = ''
-              delete item.innerSpacingBefore
-              delete item.innerSpacingAfter
-              const url = item.url
-              item.url = '___CSS_LOADER_URL___' + urlItems.length + '___'
-              urlItems.push({
-                url: url
-              })
-            }
-            break
-        }
-      }
-
-      css.walkDecls(function (decl) {
-        const values = Tokenizer.parseValues(decl.value)
-        values.nodes.forEach(function (value) {
-          value.nodes.forEach(processNode)
-        })
-        decl.value = Tokenizer.stringifyValues(values)
-      })
-      css.walkAtRules(function (atrule) {
-        if (typeof atrule.params === 'string') {
-          atrule.params = replaceImportsInString(atrule.params)
-        }
-      })
-
-      options.importItems = importItems
-      options.urlItems = urlItems
-      options.exports = exports
-    }
-  }
-}
-
-module.exports = function processCss (inputSource, inputMap, options, callback) {
-  const query = options.query
-  const root = query.root && query.root.length > 0 ? query.root.replace(/\/$/, '') : query.root
-  const context = query.context
-  const localIdentName = query.localIdentName || '[hash:base64]'
-  const localIdentRegExp = query.localIdentRegExp
-  const forceMinimize = query.minimize
-  const minimize = typeof forceMinimize !== 'undefined' ? !!forceMinimize : options.minimize
-
-  const customGetLocalIdent = query.getLocalIdent || getLocalIdent
-
-  const parserOptions = {
-    root: root,
-    mode: options.mode,
-    url: query.url !== false,
-    import: query.import !== false,
-    resolve: options.resolve
-  }
-
-  const pipeline = postcss([
-    modulesValues,
-    localByDefault({
-      mode: options.mode,
-      rewriteUrl: function (global, url) {
-        if (parserOptions.url) {
-          url = url.trim()
-
-          if (!url.replace(/\s/g, '').length || !isUrlRequest(url, root)) {
-            return url
-          }
-          if (global) {
-            return loaderUtils.urlToRequest(url, root)
-          }
-        }
-        return url
-      }
-    }),
-    extractImports(),
-    modulesScope({
-      generateScopedName: function generateScopedName (exportName) {
-        return customGetLocalIdent(options.loaderContext, localIdentName, exportName, {
-          regExp: localIdentRegExp,
-          hashPrefix: query.hashPrefix || '',
-          context: context
-        })
-      }
-    }),
-    parserPlugin(parserOptions)
-  ])
-
-  if (minimize) {
-    const cssnano = require('cssnano')
-    const minimizeOptions = assign({}, query.minimize);
-    ['zindex', 'normalizeUrl', 'discardUnused', 'mergeIdents', 'reduceIdents', 'autoprefixer', 'svgo'].forEach(function (name) {
-      if (typeof minimizeOptions[name] === 'undefined') {
-        minimizeOptions[name] = false
-      }
-    })
-    pipeline.use(cssnano(minimizeOptions))
-  }
-
-  pipeline.process(inputSource, {
-    // we need a prefix to avoid path rewriting of PostCSS
-    from: '/css-loader!' + options.from,
-    to: options.to,
-    map: options.sourceMap ? {
-      prev: inputMap,
-      sourcesContent: true,
-      inline: false,
-      annotation: false
-    } : null
-  }).then(function (result) {
-    callback(null, {
-      source: result.css,
-      map: result.map && result.map.toJSON(),
-      exports: parserOptions.exports,
-      importItems: parserOptions.importItems,
-      importItemRegExpG: /___CSS_LOADER_IMPORT___([0-9]+)___/g,
-      importItemRegExp: /___CSS_LOADER_IMPORT___([0-9]+)___/,
-      urlItems: parserOptions.urlItems,
-      urlItemRegExpG: /___CSS_LOADER_URL___([0-9]+)___/g,
-      urlItemRegExp: /___CSS_LOADER_URL___([0-9]+)___/
-    })
-  }).catch(function (err) {
-    if (err.name === 'CssSyntaxError') {
-      const wrappedError = new CSSLoaderError(
-        'Syntax Error',
-        err.reason,
-        err.line != null && err.column != null
-          ? { line: err.line, column: err.column }
-          : null,
-        err.input.source
-      )
-      callback(wrappedError)
-    } else {
-      callback(err)
-    }
-  })
-}
-
-function formatMessage (message, loc, source) {
-  let formatted = message
-  if (loc) {
-    formatted = formatted +
-      ' (' + loc.line + ':' + loc.column + ')'
-  }
-  if (loc && source) {
-    formatted = formatted +
-      '\n\n' + formatCodeFrame(source, loc.line, loc.column) + '\n'
-  }
-  return formatted
-}
-
-function CSSLoaderError (name, message, loc, source, error) {
-  Error.call(this)
-  Error.captureStackTrace(this, CSSLoaderError)
-  this.name = name
-  this.error = error
-  this.message = formatMessage(message, loc, source)
-  this.message = formatMessage(message, loc, source)
-}
-
-CSSLoaderError.prototype = Object.create(Error.prototype)
-CSSLoaderError.prototype.constructor = CSSLoaderError

package/lib/wxss/url/escape.js

@@ -1,16 +0,0 @@
-module.exports = function escape (url) {
-  if (typeof url !== 'string') {
-    return url
-  }
-  // If url is already wrapped in quotes, remove them
-  if (/^['"].*['"]$/.test(url)) {
-    url = url.slice(1, -1)
-  }
-  // Should url be wrapped?
-  // See https://drafts.csswg.org/css-values-3/#urls
-  if (/["'() \t\n]/.test(url)) {
-    return '"' + url.replace(/"/g, '\\"').replace(/\n/g, '\\n') + '"'
-  }
-
-  return url
-}