@mpxjs/webpack-plugin 2.6.115 → 2.7.0-alpha

package/lib/tenon/processTemplate.js

@@ -0,0 +1,133 @@
+const templateCompiler = require('../template-compiler/compiler')
+const genComponentTag = require('../utils/gen-component-tag')
+const addQuery = require('../utils/add-query')
+const path = require('path')
+const parseRequest = require('../utils/parse-request')
+// const getMainCompilation = require('../utils/get-main-compilation')
+
+// function calculateRootEleChild (arr) {
+//   if (!arr) {
+//     return 0
+//   }
+//   return arr.reduce((total, item) => {
+//     if (item.type === 1) {
+//       if (item.tag === 'template') {
+//         total += calculateRootEleChild(item.children)
+//       } else {
+//         total += 1
+//       }
+//     }
+//     return total
+//   }, 0)
+// }
+
+module.exports = function (template, options, callback) {
+  const mode = options.mode
+  const srcMode = options.srcMode
+  const defs = options.defs
+  const moduleId = options.moduleId
+  const loaderContext = options.loaderContext
+  const ctorType = options.ctorType
+  const resourcePath = parseRequest(loaderContext.resource).resourcePath
+  const builtInComponentsMap = {}
+  // const compilation = loaderContext._compilation
+  // const mainCompilation = getMainCompilation(compilation)
+  // const mpx = mainCompilation.__mpx__
+  // const wxsContentMap = mpx.wxsContentMap
+  let wxsModuleMap, genericsInfo
+  let output = '/* template */\n'
+
+  if (ctorType === 'app') {
+    template = {
+      tag: 'template',
+      content: '<div class="app">this is app</div>'
+    }
+    // builtInComponentsMap['mpx-keep-alive'] = {
+    //   resource: addQuery('@mpxjs/webpack-plugin/lib/runtime/components/web/mpx-keep-alive.vue', { component: true })
+    // }
+  }
+
+  if (template) {
+    // 由于远端src template资源引用的相对路径可能发生变化，暂时不支持。
+    if (template.src) {
+      return callback(new Error('[mpx loader][' + loaderContext.resource + ']: ' + 'template content must be inline in .mpx files!'))
+    }
+    if (template.lang) {
+      return callback(new Error('[mpx loader][' + loaderContext.resource + ']: ' + 'template lang is not supported in trans web mode temporarily, we will support it in the future!'))
+    }
+
+    output += genComponentTag(template, (template) => {
+      if (ctorType === 'app') {
+        return template.content
+      }
+      if (template.content) {
+        const templateSrcMode = template.mode || srcMode
+        const parsed = templateCompiler.parse(template.content, {
+          warn: (msg) => {
+            loaderContext.emitWarning(
+              new Error('[template compiler][' + loaderContext.resource + ']: ' + msg)
+            )
+          },
+          error: (msg) => {
+            loaderContext.emitError(
+              new Error('[template compiler][' + loaderContext.resource + ']: ' + msg)
+            )
+          },
+          usingComponents: options.usingComponents,
+          hasComment: options.hasComment,
+          isNative: options.isNative,
+          basename: path.basename(resourcePath),
+          isComponent: ctorType === 'component',
+          mode,
+          srcMode: templateSrcMode,
+          defs,
+          decodeHTMLText: options.decodeHTMLText,
+          // externalClasses: options.externalClasses,
+          hasScoped: false,
+          moduleId,
+          filePath: loaderContext.resourcePath,
+          i18n: null,
+          checkUsingComponents: options.checkUsingComponents,
+          // web模式下全局组件不会被合入usingComponents中，故globalComponents可以传空
+          globalComponents: [],
+          // web模式下实现抽象组件
+          componentGenerics: options.componentGenerics
+        })
+        // if (parsed.meta.wxsModuleMap) {
+        //   wxsModuleMap = parsed.meta.wxsModuleMap
+        // }
+        // if (parsed.meta.wxsContentMap) {
+        //   for (let module in parsed.meta.wxsContentMap) {
+        //     wxsContentMap[`${resourcePath}~${module}`] = parsed.meta.wxsContentMap[module]
+        //   }
+        // }
+        if (parsed.meta.builtInComponentsMap) {
+          Object.keys(parsed.meta.builtInComponentsMap).forEach((name) => {
+            builtInComponentsMap[name] = {
+              resource: addQuery(parsed.meta.builtInComponentsMap[name], { component: true })
+            }
+          })
+        }
+        // if (parsed.meta.genericsInfo) {
+        //   genericsInfo = parsed.meta.genericsInfo
+        // }
+        // 输出H5有多个root element时, 使用div标签包裹
+        // if (parsed.root.tag === 'temp-node') {
+        //   const childLen = calculateRootEleChild(parsed.root.children)
+        //   if (childLen >= 2) {
+        //     parsed.root.tag = 'div'
+        //   }
+        // }
+        return templateCompiler.serialize(parsed.root)
+      }
+    })
+    output += '\n\n'
+  }
+
+  callback(null, {
+    output,
+    builtInComponentsMap,
+    genericsInfo,
+    wxsModuleMap
+  })
+}

package/lib/url-loader.js

@@ -1,51 +1,33 @@
 const loaderUtils = require('loader-utils')
 const mime = require('mime')
+const parseRequest = require('./utils/parse-request')
 const getOptions = loaderUtils.getOptions
-const parseQuery = loaderUtils.parseQuery
 
 function isStyleRequest (request) {
-  let elements = request.replace(/^-?!+/, '').replace(/!!+/g, '!').split('!')
-  elements.pop()
-  for (let i = 0; i < elements.length; i++) {
-    let element = elements[i]
-    let queryString = '?'
-    let loaderString = element
-    let idx = element.indexOf('?')
-    if (idx >= 0) {
-      queryString = element.substr(idx)
-      loaderString = element.substr(0, idx)
-    }
-    if (/css-loader/.test(loaderString)) {
-      return true
-    }
-    if (/content-loader/.test(loaderString)) {
-      let query = parseQuery(queryString)
-      if (query.type === 'styles') {
-        return true
-      }
-    }
-  }
+  const { loaderString, queryObj } = parseRequest(request)
+  if (queryObj.type === 'styles') return true
+  if (/(css-loader|wxss\/loader)/.test(loaderString)) return true
   return false
 }
 
 module.exports = function (src) {
   let transBase64 = false
   const options = Object.assign({}, getOptions(this))
-  const filePath = this.resourcePath
-  const mimetype = options.mimetype || mime.getType(filePath)
-  const issuer = this._module.issuer
+  const { resourcePath, queryObj } = parseRequest(this.resource)
+  const mimetype = options.mimetype || mime.getType(resourcePath)
+  const moduleGraph = this._compilation.moduleGraph
+  const issuer = moduleGraph.getIssuer(this._module)
   const publicPathScope = options.publicPathScope === 'all' ? 'all' : 'styleOnly'
-  const queryOption = parseQuery(this.resourceQuery || '?')
   const limit = options.limit
-  const useLocal = !limit || src.length < limit || queryOption.useLocal
-  const isStyle = (issuer && issuer.request && isStyleRequest(issuer.request)) || queryOption.isStyle
+  const useLocal = !limit || src.length < limit || queryObj.useLocal
+  const isStyle = (issuer && issuer.request && isStyleRequest(issuer.request)) || queryObj.isStyle
 
   if (isStyle) {
     if (options.publicPath) {
       if (useLocal) {
         transBase64 = true
       }
-      if (queryOption.fallback) {
+      if (queryObj.fallback) {
         transBase64 = false
       }
     } else {

package/lib/utils/add-query.js

@@ -3,7 +3,7 @@ const stringifyQuery = require('./stringify-query')
 const type = require('./type')
 
 // 默认为非强行覆盖原query，如需强行覆盖传递force为true
-module.exports = function (request, data = {}, force, removeKeys) {
+module.exports = function addQuery (request, data = {}, force, removeKeys) {
   const { rawResourcePath: resourcePath, loaderString, queryObj: queryObjRaw } = parseRequest(request)
   const queryObj = Object.assign({}, queryObjRaw)
   if (force) {

package/lib/utils/const.js

@@ -0,0 +1,10 @@
+module.exports = {
+  MPX_PROCESSED_FLAG: 'mpx_processed',
+  MPX_DISABLE_EXTRACTOR_CACHE: 'mpx_disable_extractor_cache',
+  DEFAULT_RESULT_SOURCE: '',
+  RESOLVE_IGNORED_ERR: new Error('Resolve ignored!'),
+  JSON_JS_EXT: '.json.js',
+  MPX_ROOT_VIEW: 'mpx-root-view', // 根节点类名
+  MPX_APP_MODULE_ID: 'mpx-app-scope', // app文件moduleId
+  MPX_CURRENT_CHUNK: 'mpx_current_chunk'
+}

package/lib/utils/emit-file.js

@@ -0,0 +1,10 @@
+const { RawSource } = require('webpack').sources
+
+module.exports = (module, name, content, sourceMap, assetInfo) => {
+  if (!module.buildInfo.assets) {
+    module.buildInfo.assets = Object.create(null)
+    module.buildInfo.assetsInfo = new Map()
+  }
+  module.buildInfo.assets[name] = new RawSource(content)
+  module.buildInfo.assetsInfo.set(name, assetInfo)
+}

package/lib/utils/eval-json-js.js

@@ -0,0 +1,31 @@
+const path = require('path')
+
+module.exports = function evalJSONJS (source, filename, loaderContext) {
+  if (!loaderContext._compiler) return {}
+  const fs = loaderContext._compiler.inputFileSystem
+  const defs = loaderContext.getMpx().defs
+  const defKeys = Object.keys(defs)
+  const defValues = defKeys.map((key) => {
+    return defs[key]
+  })
+  const dirname = path.dirname(filename)
+  // eslint-disable-next-line no-new-func
+  const func = new Function('module', 'exports', 'require', '__filename', '__dirname', ...defKeys, source)
+  const module = {
+    exports: {}
+  }
+  // 此处采用readFileSync+evalJSONJS而不直接使用require获取依赖内容有两个原因：
+  // 1. 支持依赖中正常访问defs变量
+  // 2. 避免对应的依赖文件被作为buildDependencies
+  func(module, module.exports, function (request) {
+    if (request.startsWith('.')) {
+      request = path.join(dirname, request)
+    }
+    const filename = require.resolve(request)
+    loaderContext.addDependency(filename)
+    const source = fs.readFileSync(filename).toString('utf-8')
+    return evalJSONJS(source, filename, loaderContext)
+  }, filename, dirname, ...defValues)
+
+  return module.exports
+}

package/lib/utils/get-entry-name.js

@@ -0,0 +1,13 @@
+module.exports = function (loaderContext) {
+  if (!loaderContext._compilation) return ''
+  const moduleGraph = loaderContext._compilation.moduleGraph
+  let entryName = ''
+  for (const [name, { dependencies }] of loaderContext._compilation.entries) {
+    const entryModule = moduleGraph.getModule(dependencies[0])
+    if (entryModule.resource === loaderContext.resource) {
+      entryName = name
+      break
+    }
+  }
+  return entryName
+}

package/lib/utils/get-json-content.js

@@ -0,0 +1,42 @@
+const parseRequest = require('./parse-request')
+const evalJSONJS = require('./eval-json-js')
+const resolve = require('./resolve')
+const async = require('async')
+const { JSON_JS_EXT } = require('./const')
+
+module.exports = function getJSONContent (json, loaderContext, callback) {
+  if (!loaderContext._compiler) return callback(null, '{}')
+  const fs = loaderContext._compiler.inputFileSystem
+  async.waterfall([
+    (callback) => {
+      if (json.src) {
+        resolve(loaderContext.context, json.src, loaderContext, (err, result) => {
+          if (err) return callback(err)
+          const { rawResourcePath: resourcePath } = parseRequest(result)
+          fs.readFile(resourcePath, (err, content) => {
+            if (err) return callback(err)
+            callback(null, {
+              content: content.toString('utf-8'),
+              useJSONJS: json.useJSONJS || resourcePath.endsWith(JSON_JS_EXT),
+              filename: resourcePath
+
+            })
+          })
+        })
+      } else {
+        callback(null, {
+          content: json.content,
+          useJSONJS: json.useJSONJS,
+          filename: loaderContext.resourcePath
+        })
+      }
+    },
+    ({ content, useJSONJS, filename }, callback) => {
+      if (!content) return callback(null, '{}')
+      if (useJSONJS) {
+        content = JSON.stringify(evalJSONJS(content, filename, loaderContext))
+      }
+      callback(null, content)
+    }
+  ], callback)
+}

package/lib/utils/get-relative-path.js

@@ -0,0 +1,25 @@
+function getRelativePath (source, target) {
+  // make sure source and target are absolute path
+  /^\//.test(source) || (source = '/' + source);
+  /^\//.test(target) || (target = '/' + target)
+
+  source = source && source.replace(/\/[^/]*$/, '') // get dirname
+  // check if source or target is root path
+  let sourceArr = source.split('/').filter((item, index) => index !== 0 && !!item)
+  let targetArr = target.split('/').filter((item, index) => index !== 0 && !!item)
+  let i = 0
+  while (sourceArr[i] === targetArr[i] && i < sourceArr.length && i < targetArr.length) {
+    i++
+  }
+  let relativePath = ''
+  for (let j = 0; j < sourceArr.length - i; j++) {
+    relativePath += '../'
+  }
+  relativePath += targetArr.slice(i).join('/')
+  if (relativePath[0] !== '.') relativePath = './' + relativePath
+  return relativePath
+}
+
+module.exports = {
+  getRelativePath
+}

package/lib/utils/is-url-request.js

@@ -1,7 +1,7 @@
 const isUrlRequestRaw = require('loader-utils').isUrlRequest
 const tagRE = /\{\{((?:.|\n|\r)+?)\}\}(?!})/
 
-module.exports = function isUrlRequest (url, root) {
+module.exports = function isUrlRequest (url, root, externals) {
   // 对于非字符串或空字符串url直接返回false
   if (!url || typeof url !== 'string') return false
   // 对于@开头且后续字符串为合法标识符的情况也返回false，识别为theme变量
@@ -9,5 +9,14 @@ module.exports = function isUrlRequest (url, root) {
   if (/^.+:\/\//.test(url)) return false
   // 对于url中存在Mustache插值的情况也返回false
   if (tagRE.test(url)) return false
+  // url存在于externals中也返回false
+  if (externals && externals.some((external) => {
+    if (typeof external === 'string') {
+      return external === url
+    } else if (external instanceof RegExp) {
+      return external.test(url)
+    }
+    return false
+  })) return false
   return isUrlRequestRaw(url, root)
 }

package/lib/utils/match-condition.js

@@ -45,4 +45,7 @@ const matchCondition = (resourcePath, condition = {}) => {
   return matched
 }
 
-module.exports = matchCondition
+module.exports = {
+  matchCondition,
+  normalizeCondition
+}

package/lib/utils/normalize.js

@@ -1,16 +1,5 @@
-const fs = require('fs')
-const path = require('path')
+// const path = require('path')
 
-exports.lib = file => path.resolve(__dirname, '../', file)
-
-exports.dep = dep => {
-  if (
-    fs.existsSync(path.resolve(__dirname, '../../node_modules', dep))
-  ) {
-    // npm 2 or npm linked
-    return '@mpxjs/webpack-plugin/node_modules/' + dep
-  } else {
-    // npm 3
-    return dep
-  }
-}
+// exports.lib = file => path.resolve(__dirname, '../', file)
+// support npm link debug
+exports.lib = file => '@mpxjs/webpack-plugin/lib/' + file

package/lib/utils/parse-request.js

@@ -4,7 +4,7 @@ const path = require('path')
 
 function genQueryObj (result) {
   // 避免外部修改queryObj影响缓存
-  result.queryObj = parseQuery(result.resourceQuery)
+  result.queryObj = parseQuery(result.resourceQuery || '?')
   return result
 }
 
@@ -16,13 +16,13 @@ module.exports = function parseRequest (request) {
   let resource = elements.pop()
   let loaderString = elements.join('!')
   let resourcePath = resource
-  let resourceQuery = '?'
+  let resourceQuery = ''
   const queryIndex = resource.indexOf('?')
   if (queryIndex >= 0) {
     resourcePath = resource.slice(0, queryIndex)
     resourceQuery = resource.slice(queryIndex)
   }
-  const queryObj = parseQuery(resourceQuery)
+  const queryObj = parseQuery(resourceQuery || '?')
   const rawResourcePath = resourcePath
   if (queryObj.resourcePath) {
     resourcePath = queryObj.resourcePath

package/lib/utils/resolve.js

@@ -0,0 +1,13 @@
+const parseRequest = require('./parse-request')
+const { RESOLVE_IGNORED_ERR } = require('./const')
+
+// todo 提供不记录dependency的resolve方法，非必要的情况下不记录dependency，提升缓存利用率
+module.exports = (context, request, loaderContext, callback) => {
+  const { queryObj } = parseRequest(request)
+  context = queryObj.context || context
+  return loaderContext.resolve(context, request, (err, resource, info) => {
+    if (err) return callback(err)
+    if (resource === false) return callback(RESOLVE_IGNORED_ERR)
+    callback(null, resource, info)
+  })
+}

package/lib/utils/set.js

@@ -0,0 +1,47 @@
+module.exports = {
+  every (set, fn) {
+    for (const item of set) {
+      if (!fn(item)) return false
+    }
+    return true
+  },
+  has (set, fn) {
+    for (const item of set) {
+      if (fn(item)) return true
+    }
+    return false
+  },
+  map (set, fn) {
+    const result = new Set()
+    set.forEach((item) => {
+      result.add(fn(item))
+    })
+    return result
+  },
+  filter (set, fn) {
+    const result = new Set()
+    set.forEach((item) => {
+      if (fn(item)) {
+        result.add(item)
+      }
+    })
+    return result
+  },
+  concat (setA, setB) {
+    const result = new Set()
+    setA.forEach((item) => {
+      result.add(item)
+    })
+    setB.forEach((item) => {
+      result.add(item)
+    })
+    return result
+  },
+  mapToArr (set, fn) {
+    const result = []
+    set.forEach((item) => {
+      result.push(fn(item))
+    })
+    return result
+  }
+}

package/lib/utils/stringify-loaders-resource.js

@@ -0,0 +1,25 @@
+const loaderToIdent = data => {
+  if (!data.options) {
+    return data.loader
+  }
+  if (typeof data.options === 'string') {
+    return data.loader + '?' + data.options
+  }
+  if (typeof data.options !== 'object') {
+    throw new Error('loader options must be string or object')
+  }
+  if (data.ident) {
+    return data.loader + '??' + data.ident
+  }
+  return data.loader + '?' + JSON.stringify(data.options)
+}
+
+const stringifyLoadersAndResource = (loaders, resource) => {
+  let str = ''
+  for (const loader of loaders) {
+    str += loaderToIdent(loader) + '!'
+  }
+  return str + resource
+}
+
+module.exports = stringifyLoadersAndResource

package/lib/utils/stringify-query.js

@@ -16,6 +16,10 @@ function stringifyQuery (obj, useJSON) {
       return
     }
 
+    if (val === true) {
+      return key
+    }
+
     if (Array.isArray(val)) {
       const key2 = `${key}[]`
       const result = []