@mpxjs/webpack-plugin 2.6.114-alpha.4 → 2.6.114-alpha.7

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 = []

package/lib/web/processJSON.js

@@ -6,28 +6,30 @@ const parseRequest = require('../utils/parse-request')
 const toPosix = require('../utils/to-posix')
 const addQuery = require('../utils/add-query')
 const parseComponent = require('../parser')
-const readJsonForSrc = require('../utils/read-json-for-src')
-const isUrlRequest = require('../utils/is-url-request')
+const getJSONContent = require('../utils/get-json-content')
+const resolve = require('../utils/resolve')
+const createJSONHelper = require('../json-compiler/helper')
+const { RESOLVE_IGNORED_ERR } = require('../utils/const')
+const RecordResourceMapDependency = require('../dependencies/RecordResourceMapDependency')
 
-module.exports = function (json, options, rawCallback) {
-  const mode = options.mode
-  const env = options.env
-  const defs = options.defs
-  const loaderContext = options.loaderContext
-  const resolveMode = options.resolveMode
-  const pagesMap = options.pagesMap
-  const componentsMap = options.componentsMap
-  const pagesEntryMap = options.pagesEntryMap
-  const projectRoot = options.projectRoot
-  const pathHash = options.pathHash
+module.exports = function (json, {
+  loaderContext,
+  pagesMap,
+  componentsMap
+}, rawCallback) {
   const localPagesMap = {}
   const localComponentsMap = {}
-  const buildInfo = loaderContext._module.buildInfo
-
   let output = '/* json */\n'
   let jsonObj = {}
   let tabBarMap
   let tabBarStr
+  const mpx = loaderContext.getMpx()
+  const {
+    mode,
+    env,
+    projectRoot
+  } = mpx
+
   const context = loaderContext.context
 
   const emitWarning = (msg) => {
@@ -37,13 +39,31 @@ module.exports = function (json, options, rawCallback) {
   }
 
   const emitError = (msg) => {
-    this.emitError(
-      new Error('[json compiler][' + this.resource + ']: ' + msg)
+    loaderContext.emitError(
+      new Error('[json compiler][' + loaderContext.resource + ']: ' + msg)
     )
   }
 
   const stringifyRequest = r => loaderUtils.stringifyRequest(loaderContext, r)
 
+  const {
+    isUrlRequest,
+    urlToRequest,
+    processPage,
+    processComponent
+  } = createJSONHelper({
+    loaderContext,
+    emitWarning,
+    emitError,
+    customGetDynamicEntry (resource, type, outputPath, packageRoot) {
+      return {
+        resource,
+        outputPath: toPosix(path.join(packageRoot, outputPath)),
+        packageRoot
+      }
+    }
+  })
+
   const callback = (err) => {
     return rawCallback(err, {
       output,
@@ -67,12 +87,6 @@ module.exports = function (json, options, rawCallback) {
 
   const fs = loaderContext._compiler.inputFileSystem
 
-  const resolve = (context, request, callback) => {
-    const { queryObj } = parseRequest(request)
-    context = queryObj.context || context
-    return loaderContext.resolve(context, request, callback)
-  }
-
   const defaultTabbar = {
     borderStyle: 'black',
     position: 'bottom',
@@ -90,7 +104,7 @@ module.exports = function (json, options, rawCallback) {
       tabBarStr = JSON.stringify(tabBar)
       tabBarStr = tabBarStr.replace(/"(iconPath|selectedIconPath)":"([^"]+)"/g, function (matched, $1, $2) {
         if (isUrlRequest($2, projectRoot)) {
-          return `"${$1}":require(${stringifyRequest(loaderUtils.urlToRequest($2, projectRoot))})`
+          return `"${$1}":require(${stringifyRequest(urlToRequest($2, projectRoot))})`
         }
         return matched
       })
@@ -100,45 +114,37 @@ module.exports = function (json, options, rawCallback) {
 
   const processPackages = (packages, context, callback) => {
     if (packages) {
-      async.forEach(packages, (packagePath, callback) => {
-        const parsed = parseRequest(packagePath)
-        const queryObj = parsed.queryObj
-        // readFile无法处理query
-        packagePath = parsed.resourcePath
+      async.each(packages, (packagePath, callback) => {
+        const { queryObj } = parseRequest(packagePath)
         async.waterfall([
           (callback) => {
-            resolve(context, packagePath, (err, result) => {
-              callback(err, result)
+            resolve(context, packagePath, loaderContext, (err, result) => {
+              if (err) return callback(err)
+              const { rawResourcePath } = parseRequest(result)
+              callback(err, rawResourcePath)
             })
           },
           (result, callback) => {
-            loaderContext.addDependency(result)
             fs.readFile(result, (err, content) => {
               if (err) return callback(err)
               callback(err, result, content.toString('utf-8'))
             })
           },
           (result, content, callback) => {
-            const filePath = result
-            const extName = path.extname(filePath)
-            if (extName === '.mpx' || extName === '.vue') {
+            const extName = path.extname(result)
+            if (extName === '.mpx') {
               const parts = parseComponent(content, {
-                filePath,
+                filePath: result,
                 needMap: loaderContext.sourceMap,
                 mode,
-                defs,
                 env
               })
-              const json = parts.json || {}
-              if (json.content) {
-                content = json.content
-              } else if (json.src) {
-                return readJsonForSrc(json.src, loaderContext, (content) => {
-                  callback(null, result, content)
-                })
-              }
+              getJSONContent(parts.json || {}, loaderContext, (err, content) => {
+                callback(err, result, content)
+              })
+            } else {
+              callback(null, result, content)
             }
-            callback(null, result, content)
           },
           (result, content, callback) => {
             try {
@@ -159,12 +165,17 @@ module.exports = function (json, options, rawCallback) {
                   pages: content.pages,
                   ...queryObj
                 }
+
+                if (content.plugins) {
+                  subPackage.plugins = content.plugins
+                }
+
                 processSelfQueue.push((callback) => {
                   processSubPackage(subPackage, context, callback)
                 })
               } else {
                 processSelfQueue.push((callback) => {
-                  processPages(content.pages, '', '', context, callback)
+                  processPages(content.pages, context, '', callback)
                 })
               }
             }
@@ -179,77 +190,40 @@ module.exports = function (json, options, rawCallback) {
               callback()
             }
           }
-        ], callback)
+        ], (err) => {
+          callback(err === RESOLVE_IGNORED_ERR ? null : err)
+        })
       }, callback)
     } else {
       callback()
     }
   }
 
-  const getPageName = (resourcePath, ext) => {
-    const baseName = path.basename(resourcePath, ext)
-    return path.join('pages', baseName + pathHash(resourcePath), baseName)
-  }
+  const pageKeySet = new Set()
 
-  const processPages = (pages, srcRoot = '', tarRoot = '', context, callback) => {
+  const processPages = (pages, context, tarRoot = '', callback) => {
     if (pages) {
-      context = path.join(context, srcRoot)
-      async.forEach(pages, (page, callback) => {
-        let aliasPath = ''
-        if (typeof page !== 'string') {
-          aliasPath = page.path
-          page = page.src
-        }
-        if (!isUrlRequest(page, projectRoot)) return callback()
-        if (resolveMode === 'native') {
-          page = loaderUtils.urlToRequest(page, projectRoot)
-        }
-        resolve(context, page, (err, resource) => {
-          if (err) return callback(err)
+      async.each(pages, (page, callback) => {
+        processPage(page, context, tarRoot, (err, { resource, outputPath } = {}, { isFirst, key } = {}) => {
+          if (err) return callback(err === RESOLVE_IGNORED_ERR ? null : err)
+          if (pageKeySet.has(key)) return callback()
+          pageKeySet.add(key)
           const { resourcePath, queryObj } = parseRequest(resource)
-          const ext = path.extname(resourcePath)
-          // 获取pageName
-          let pageName
-          if (aliasPath) {
-            pageName = toPosix(path.join(tarRoot, aliasPath))
-            // 判断 key 存在重复情况直接报错
-            for (let key in pagesMap) {
-              if (pagesMap[key] === pageName && key !== resourcePath) {
-                emitError(`Current page [${resourcePath}] registers a conflict page path [${pageName}] with existed page [${key}], which is not allowed, please rename it!`)
-                return callback()
-              }
-            }
-          } else {
-            const relative = path.relative(context, resourcePath)
-            if (/^\./.test(relative)) {
-              // 如果当前page不存在于context中，对其进行重命名
-              pageName = toPosix(path.join(tarRoot, getPageName(resourcePath, ext)))
-              emitWarning(`Current page [${resourcePath}] is not in current pages directory [${context}], the page path will be replaced with [${pageName}], use ?resolve to get the page path and navigate to it!`)
-            } else {
-              pageName = toPosix(path.join(tarRoot, /^(.*?)(\.[^.]*)?$/.exec(relative)[1]))
-              // 如果当前page与已有page存在命名冲突，也进行重命名
-              for (let key in pagesMap) {
-                // 此处引入pagesEntryMap确保相同entry下路由路径重复注册才报错，不同entry下的路由路径重复则无影响
-                if (pagesMap[key] === pageName && key !== resourcePath && pagesEntryMap[key] === loaderContext.resourcePath) {
-                  const pageNameRaw = pageName
-                  pageName = toPosix(path.join(tarRoot, getPageName(resourcePath, ext)))
-                  emitWarning(`Current page [${resourcePath}] is registered with a conflict page path [${pageNameRaw}] which is already existed in system, the page path will be replaced with [${pageName}], use ?resolve to get the page path and navigate to it!`)
-                  break
-                }
-              }
+          if (localPagesMap[outputPath]) {
+            const { resourcePath: oldResourcePath } = parseRequest(localPagesMap[outputPath].resource)
+            if (oldResourcePath !== resourcePath) {
+              const oldOutputPath = outputPath
+              outputPath = mpx.getOutputPath(resourcePath, 'page', { conflictPath: outputPath })
+              emitWarning(new Error(`Current page [${resourcePath}] is registered with a conflict outputPath [${oldOutputPath}] which is already existed in system, will be renamed with [${outputPath}], use ?resolve to get the real outputPath!`))
             }
           }
-          if (pagesMap[resourcePath]) {
-            emitWarning(`Current page [${resourcePath}] which is imported from [${loaderContext.resourcePath}] has been registered in pagesMap already, it will be ignored, please check it and remove the redundant page declaration!`)
-            return callback()
-          }
-          buildInfo.pagesMap = buildInfo.pagesMap || {}
-          buildInfo.pagesMap[resourcePath] = pagesMap[resourcePath] = pageName
-          pagesEntryMap[resourcePath] = loaderContext.resourcePath
-          localPagesMap[pageName] = {
-            resource: addQuery(resource, { page: true }),
-            async: tarRoot || queryObj.async,
-            isFirst: queryObj.isFirst
+
+          pagesMap[resourcePath] = outputPath
+          loaderContext._module && loaderContext._module.addPresentationalDependency(new RecordResourceMapDependency(resourcePath, 'page', outputPath))
+          localPagesMap[outputPath] = {
+            resource: addQuery(resource, { isPage: true }),
+            async: queryObj.async || tarRoot,
+            isFirst
           }
           callback()
         })
@@ -261,10 +235,15 @@ module.exports = function (json, options, rawCallback) {
 
   const processSubPackage = (subPackage, context, callback) => {
     if (subPackage) {
+      if (typeof subPackage.root === 'string' && subPackage.root.startsWith('.')) {
+        emitError(`Current subpackage root [${subPackage.root}] is not allow starts with '.'`)
+        return callback()
+      }
       let tarRoot = subPackage.tarRoot || subPackage.root || ''
       let srcRoot = subPackage.srcRoot || subPackage.root || ''
       if (!tarRoot) return callback()
-      processPages(subPackage.pages, srcRoot, tarRoot, context, callback)
+      context = path.join(context, srcRoot)
+      processPages(subPackage.pages, context, tarRoot, callback)
     } else {
       callback()
     }
@@ -272,7 +251,7 @@ module.exports = function (json, options, rawCallback) {
 
   const processSubPackages = (subPackages, context, callback) => {
     if (subPackages) {
-      async.forEach(subPackages, (subPackage, callback) => {
+      async.each(subPackages, (subPackage, callback) => {
         processSubPackage(subPackage, context, callback)
       }, callback)
     } else {
@@ -282,48 +261,37 @@ module.exports = function (json, options, rawCallback) {
 
   const processComponents = (components, context, callback) => {
     if (components) {
-      async.forEachOf(components, (component, name, callback) => {
-        processComponent(component, name, context, callback)
+      async.eachOf(components, (component, name, callback) => {
+        processComponent(component, context, {}, (err, { resource, outputPath } = {}) => {
+          if (err === RESOLVE_IGNORED_ERR) {
+            return callback()
+          }
+          const { resourcePath, queryObj } = parseRequest(resource)
+          componentsMap[resourcePath] = outputPath
+          loaderContext._module && loaderContext._module.addPresentationalDependency(new RecordResourceMapDependency(resourcePath, 'component', outputPath))
+          localComponentsMap[name] = {
+            resource: addQuery(resource, {
+              isComponent: true,
+              outputPath
+            }),
+            async: queryObj.async
+          }
+          callback()
+        })
       }, callback)
     } else {
       callback()
     }
   }
 
-  const processComponent = (component, name, context, callback) => {
-    if (!isUrlRequest(component, projectRoot)) return callback()
-
-    if (resolveMode === 'native') {
-      component = loaderUtils.urlToRequest(component, projectRoot)
-    }
-
-    resolve(context, component, (err, resource) => {
-      if (err) return callback(err)
-      const { resourcePath, queryObj } = parseRequest(resource)
-      const parsed = path.parse(resourcePath)
-      const componentId = parsed.name + pathHash(resourcePath)
-
-      buildInfo.packageName = 'main'
-      buildInfo.componentsMap = buildInfo.componentsMap || {}
-      buildInfo.componentsMap[resourcePath] = componentsMap[resourcePath] = componentId
-
-      localComponentsMap[name] = {
-        resource: addQuery(resource, { component: true, componentId }),
-        async: queryObj.async
-      }
-      callback()
-    })
-  }
-
   const processGenerics = (generics, context, callback) => {
     if (generics) {
-      async.forEachOf(generics, (generic, name, callback) => {
-        if (generic.default) {
-          processComponent(generic.default, `${name}default`, context, callback)
-        } else {
-          callback()
-        }
-      }, callback)
+      const genericsComponents = {}
+      Object.keys(generics).forEach((name) => {
+        const generic = generics[name]
+        if (generic.default) genericsComponents[`${name}default`] = generic.default
+      })
+      processComponents(genericsComponents, context, callback)
     } else {
       callback()
     }
@@ -331,6 +299,7 @@ module.exports = function (json, options, rawCallback) {
 
   async.parallel([
     (callback) => {
+      // 添加首页标识
       if (jsonObj.pages && jsonObj.pages[0]) {
         if (typeof jsonObj.pages[0] !== 'string') {
           jsonObj.pages[0].src = addQuery(jsonObj.pages[0].src, { isFirst: true })
@@ -338,7 +307,7 @@ module.exports = function (json, options, rawCallback) {
           jsonObj.pages[0] = addQuery(jsonObj.pages[0], { isFirst: true })
         }
       }
-      processPages(jsonObj.pages, '', '', context, callback)
+      processPages(jsonObj.pages, context, '', callback)
     },
     (callback) => {
       processComponents(jsonObj.usingComponents, context, callback)