@mpxjs/webpack-plugin 2.6.115 → 2.7.0-alpha

package/lib/dependencies/DynamicEntryDependency.js

@@ -0,0 +1,171 @@
+const NullDependency = require('webpack/lib/dependencies/NullDependency')
+const makeSerializable = require('webpack/lib/util/makeSerializable')
+const path = require('path')
+const addQuery = require('../utils/add-query')
+const toPosix = require('../utils/to-posix')
+const async = require('async')
+const parseRequest = require('../utils/parse-request')
+const { MPX_CURRENT_CHUNK } = require('../utils/const')
+
+class DynamicEntryDependency extends NullDependency {
+  constructor (request, entryType, outputPath = '', packageRoot = '', relativePath = '', context = '', range) {
+    super()
+    this.request = request
+    this.entryType = entryType
+    this.outputPath = outputPath
+    this.packageRoot = packageRoot
+    this.relativePath = relativePath
+    this.context = context
+    this.range = range
+  }
+
+  get type () {
+    return 'mpx dynamic entry'
+  }
+
+  get key () {
+    const { request, entryType, outputPath, packageRoot, relativePath, context, range } = this
+    return toPosix([request, entryType, outputPath, packageRoot, relativePath, context, ...range].join('|'))
+  }
+
+  addEntry (compilation, callback) {
+    const mpx = compilation.__mpx__
+    let { request, entryType, outputPath, relativePath, context, originEntryNode, publicPath, resolver } = this
+
+    async.waterfall([
+      (callback) => {
+        if (context && resolver) {
+          resolver.resolve({}, context, request, {}, (err, resource) => {
+            callback(err, resource)
+          })
+        } else {
+          callback(null, request)
+        }
+      },
+      (resource, callback) => {
+        if (!outputPath) {
+          const { resourcePath } = parseRequest(resource)
+          outputPath = mpx.getOutputPath(resourcePath, entryType)
+        }
+
+        const { packageRoot, outputPath: filename, alreadyOutputted } = mpx.getPackageInfo({
+          resource,
+          outputPath,
+          resourceType: entryType,
+          warn (e) {
+            compilation.warnings.push(e)
+          },
+          error (e) {
+            compilation.errors.push(e)
+          }
+        })
+
+        let resultPath = publicPath + filename
+        if (relativePath && relativePath !== MPX_CURRENT_CHUNK) {
+          resultPath = toPosix(path.relative(relativePath, resultPath))
+        }
+
+        // export类型的resultPath需要添加.js后缀
+        if (entryType === 'export') resultPath += '.js'
+
+        if (alreadyOutputted) return callback(null, { resultPath })
+
+        // 对于常规js模块不应添加packageRoot避免冗余
+        if (packageRoot && entryType !== 'export') {
+          resource = addQuery(resource, { packageRoot }, true)
+        }
+
+        mpx.addEntry(resource, filename, (err, entryModule) => {
+          if (err) return callback(err)
+          if (entryType === 'export') {
+            mpx.exportModules.add(entryModule)
+          }
+          originEntryNode.addChild(mpx.getEntryNode(entryModule, entryType))
+          return callback(null, {
+            resultPath,
+            entryModule
+          })
+        })
+      }
+    ], callback)
+  }
+
+  mpxAction (module, compilation, callback) {
+    const mpx = compilation.__mpx__
+    const { packageRoot, context } = this
+    this.originEntryNode = mpx.getEntryNode(module)
+    this.publicPath = compilation.outputOptions.publicPath || ''
+    if (context) this.resolver = compilation.resolverFactory.get('normal', module.resolveOptions)
+    // 分包构建在需要在主包构建完成后在finishMake中处理，返回的资源路径先用key来占位，在合成extractedAssets时再进行最终替换
+    if (packageRoot && mpx.currentPackageRoot !== packageRoot) {
+      mpx.subpackagesEntriesMap[packageRoot] = mpx.subpackagesEntriesMap[packageRoot] || []
+      mpx.subpackagesEntriesMap[packageRoot].push(this)
+      callback()
+    } else {
+      this.addEntry(compilation, (err, { resultPath }) => {
+        if (err) return callback(err)
+        this.resultPath = resultPath
+        callback()
+      })
+    }
+  }
+
+  // hash会影响最终的codeGenerateResult是否走缓存，由于该dep中resultPath是动态变更的，需要将其更新到hash中，避免错误使用缓存
+  updateHash (hash, context) {
+    const { resultPath, relativePath } = this
+    if (resultPath) hash.update(resultPath)
+    // relativePath为MPX_CURRENT_CHUNK时，插入随机hash使当前module的codeGeneration cache失效，从而执行dep.apply动态获取当前module所属的chunk路径
+    if (relativePath === MPX_CURRENT_CHUNK) hash.update('' + (+new Date()) + Math.random())
+    super.updateHash(hash, context)
+  }
+
+  serialize (context) {
+    const { write } = context
+    write(this.request)
+    write(this.entryType)
+    write(this.outputPath)
+    write(this.packageRoot)
+    write(this.relativePath)
+    write(this.context)
+    write(this.range)
+    super.serialize(context)
+  }
+
+  deserialize (context) {
+    const { read } = context
+    this.request = read()
+    this.entryType = read()
+    this.outputPath = read()
+    this.packageRoot = read()
+    this.relativePath = read()
+    this.context = read()
+    this.range = read()
+    super.deserialize(context)
+  }
+}
+
+DynamicEntryDependency.Template = class DynamicEntryDependencyTemplate {
+  apply (dep, source, {
+    module,
+    chunkGraph
+  }) {
+    let { resultPath, range, key, outputPath, relativePath, publicPath } = dep
+    if (outputPath === 'custom-tab-bar/index') {
+      // replace with true for custom-tab-bar
+      source.replace(range[0], range[1] - 1, 'true')
+    } else if (resultPath) {
+      if (relativePath === MPX_CURRENT_CHUNK) {
+        relativePath = publicPath + path.dirname(chunkGraph.getModuleChunks(module)[0].name)
+        resultPath = toPosix(path.relative(relativePath, resultPath))
+      }
+      source.replace(range[0], range[1] - 1, JSON.stringify(resultPath))
+    } else {
+      const replaceRange = `mpx_replace_path_${key}`
+      source.replace(range[0], range[1] - 1, JSON.stringify(replaceRange))
+    }
+  }
+}
+
+makeSerializable(DynamicEntryDependency, '@mpxjs/webpack-plugin/lib/dependencies/DynamicEntryDependency')
+
+module.exports = DynamicEntryDependency

package/lib/dependencies/FlagPluginDependency.js

@@ -0,0 +1,24 @@
+const NullDependency = require('webpack/lib/dependencies/NullDependency')
+const makeSerializable = require('webpack/lib/util/makeSerializable')
+
+class FlagPluginDependency extends NullDependency {
+  get type () {
+    return 'mpx flag plugin'
+  }
+
+  mpxAction (module, compilation, callback) {
+    const mpx = compilation.__mpx__
+    mpx.isPluginMode = true
+    mpx.getEntryNode(module, 'plugin')
+    return callback()
+  }
+}
+
+FlagPluginDependency.Template = class FlagPluginDependencyTemplate {
+  apply () {
+  }
+}
+
+makeSerializable(FlagPluginDependency, '@mpxjs/webpack-plugin/lib/dependencies/FlagPluginDependency')
+
+module.exports = FlagPluginDependency

package/lib/dependencies/InjectDependency.js

@@ -0,0 +1,43 @@
+const NullDependency = require('webpack/lib/dependencies/NullDependency')
+const makeSerializable = require('webpack/lib/util/makeSerializable')
+
+class InjectDependency extends NullDependency {
+  constructor (options = {}) {
+    super()
+    this.content = options.content
+    this.index = options.index || 0
+  }
+
+  get type () {
+    return 'mpx inject'
+  }
+
+  updateHash (hash, context) {
+    hash.update(this.content)
+    super.updateHash(hash, context)
+  }
+
+  serialize (context) {
+    const { write } = context
+    write(this.content)
+    write(this.index)
+    super.serialize(context)
+  }
+
+  deserialize (context) {
+    const { read } = context
+    this.content = read()
+    this.index = read()
+    super.deserialize(context)
+  }
+}
+
+InjectDependency.Template = class InjectDependencyTemplate {
+  apply (dep, source) {
+    source.insert(dep.index, '/* mpx inject */ ' + dep.content)
+  }
+}
+
+makeSerializable(InjectDependency, '@mpxjs/webpack-plugin/lib/dependencies/InjectDependency')
+
+module.exports = InjectDependency

package/lib/dependencies/RecordGlobalComponentsDependency.js

@@ -0,0 +1,50 @@
+const NullDependency = require('webpack/lib/dependencies/NullDependency')
+const makeSerializable = require('webpack/lib/util/makeSerializable')
+const addQuery = require('../utils/add-query')
+
+class RecordGlobalComponentsDependency extends NullDependency {
+  constructor (usingComponents, context) {
+    super()
+    this.usingComponents = usingComponents
+    this.context = context
+  }
+
+  get type () {
+    return 'mpx record global components'
+  }
+
+  mpxAction (module, compilation, callback) {
+    const mpx = compilation.__mpx__
+    const { usingComponents, context } = this
+    Object.keys(usingComponents).forEach((key) => {
+      const request = usingComponents[key]
+      mpx.usingComponents[key] = addQuery(request, {
+        context
+      })
+    })
+    return callback()
+  }
+
+  serialize (context) {
+    const { write } = context
+    write(this.usingComponents)
+    write(this.context)
+    super.serialize(context)
+  }
+
+  deserialize (context) {
+    const { read } = context
+    this.usingComponents = read()
+    this.context = read()
+    super.deserialize(context)
+  }
+}
+
+RecordGlobalComponentsDependency.Template = class RecordGlobalComponentsDependencyTemplate {
+  apply () {
+  }
+}
+
+makeSerializable(RecordGlobalComponentsDependency, '@mpxjs/webpack-plugin/lib/dependencies/RecordGlobalComponentsDependency')
+
+module.exports = RecordGlobalComponentsDependency

package/lib/dependencies/RecordIndependentDependency.js

@@ -0,0 +1,44 @@
+const NullDependency = require('webpack/lib/dependencies/NullDependency')
+const makeSerializable = require('webpack/lib/util/makeSerializable')
+
+class RecordIndependentDependency extends NullDependency {
+  constructor (root, request) {
+    super()
+    this.root = root
+    this.request = request
+  }
+
+  get type () {
+    return 'mpx record independent'
+  }
+
+  mpxAction (module, compilation, callback) {
+    const mpx = compilation.__mpx__
+    const { root, request } = this
+    mpx.independentSubpackagesMap[root] = request
+    return callback()
+  }
+
+  serialize (context) {
+    const { write } = context
+    write(this.root)
+    write(this.request)
+    super.serialize(context)
+  }
+
+  deserialize (context) {
+    const { read } = context
+    this.root = read()
+    this.request = read()
+    super.deserialize(context)
+  }
+}
+
+RecordIndependentDependency.Template = class RecordIndependentDependencyTemplate {
+  apply () {
+  }
+}
+
+makeSerializable(RecordIndependentDependency, '@mpxjs/webpack-plugin/lib/dependencies/RecordIndependentDependency')
+
+module.exports = RecordIndependentDependency

package/lib/dependencies/RecordResourceMapDependency.js

@@ -0,0 +1,62 @@
+const NullDependency = require('webpack/lib/dependencies/NullDependency')
+const makeSerializable = require('webpack/lib/util/makeSerializable')
+
+class RecordResourceMapDependency extends NullDependency {
+  constructor (resourcePath, resourceType, outputPath, packageRoot = '') {
+    super()
+    this.resourcePath = resourcePath
+    this.resourceType = resourceType
+    this.outputPath = outputPath
+    this.packageRoot = packageRoot
+  }
+
+  get type () {
+    return 'mpx record resource map'
+  }
+
+  mpxAction (module, compilation, callback) {
+    const mpx = compilation.__mpx__
+    const { resourcePath, resourceType, outputPath, packageRoot } = this
+    mpx.recordResourceMap({
+      resourcePath,
+      resourceType,
+      outputPath,
+      packageRoot,
+      recordOnly: true,
+      warn (e) {
+        compilation.warnings.push(e)
+      },
+      error (e) {
+        compilation.errors.push(e)
+      }
+    })
+    return callback()
+  }
+
+  serialize (context) {
+    const { write } = context
+    write(this.resourcePath)
+    write(this.resourceType)
+    write(this.outputPath)
+    write(this.packageRoot)
+    super.serialize(context)
+  }
+
+  deserialize (context) {
+    const { read } = context
+    this.resourcePath = read()
+    this.resourceType = read()
+    this.outputPath = read()
+    this.packageRoot = read()
+    super.deserialize(context)
+  }
+}
+
+RecordResourceMapDependency.Template = class RecordResourceMapDependencyTemplate {
+  apply () {
+  }
+}
+
+makeSerializable(RecordResourceMapDependency, '@mpxjs/webpack-plugin/lib/dependencies/RecordResourceMapDependency')
+
+module.exports = RecordResourceMapDependency

package/lib/dependencies/RemoveEntryDependency.js

@@ -0,0 +1,40 @@
+const NullDependency = require('webpack/lib/dependencies/NullDependency')
+const makeSerializable = require('webpack/lib/util/makeSerializable')
+
+class RemoveEntryDependency extends NullDependency {
+  constructor (entryName) {
+    super()
+    this.entryName = entryName
+  }
+
+  get type () {
+    return 'mpx remove entry'
+  }
+
+  serialize (context) {
+    const { write } = context
+    write(this.entryName)
+    super.serialize(context)
+  }
+
+  deserialize (context) {
+    const { read } = context
+    this.entryName = read()
+    super.deserialize(context)
+  }
+
+  mpxAction (module, compilation, callback) {
+    const { entryName } = this
+    compilation.entries.delete(entryName)
+    return callback()
+  }
+}
+
+RemoveEntryDependency.Template = class RemoveEntryDependencyTemplate {
+  apply () {
+  }
+}
+
+makeSerializable(RemoveEntryDependency, '@mpxjs/webpack-plugin/lib/dependencies/RemoveEntryDependency')
+
+module.exports = RemoveEntryDependency

package/lib/{dependency → dependencies}/ReplaceDependency.js

@@ -1,4 +1,5 @@
 const NullDependency = require('webpack/lib/dependencies/NullDependency')
+const makeSerializable = require('webpack/lib/util/makeSerializable')
 
 class ReplaceDependency extends NullDependency {
   constructor (replacement, range) {
@@ -11,9 +12,23 @@ class ReplaceDependency extends NullDependency {
     return 'mpx replace'
   }
 
-  updateHash (hash) {
-    super.updateHash(hash)
+  updateHash (hash, context) {
     hash.update(this.replacement)
+    super.updateHash(hash, context)
+  }
+
+  serialize (context) {
+    const { write } = context
+    write(this.replacement)
+    write(this.range)
+    super.serialize(context)
+  }
+
+  deserialize (context) {
+    const { read } = context
+    this.replacement = read()
+    this.range = read()
+    super.deserialize(context)
   }
 }
 
@@ -23,4 +38,6 @@ ReplaceDependency.Template = class ReplaceDependencyTemplate {
   }
 }
 
+makeSerializable(ReplaceDependency, '@mpxjs/webpack-plugin/lib/dependencies/ReplaceDependency')
+
 module.exports = ReplaceDependency

package/lib/dependencies/ResolveDependency.js

@@ -0,0 +1,88 @@
+const NullDependency = require('webpack/lib/dependencies/NullDependency')
+const parseRequest = require('../utils/parse-request')
+const makeSerializable = require('webpack/lib/util/makeSerializable')
+
+class ResolveDependency extends NullDependency {
+  constructor (resource, packageName, issuerResource, range) {
+    super()
+    this.resource = resource
+    this.packageName = packageName
+    this.issuerResource = issuerResource
+    this.range = range
+    this.compilation = null
+  }
+
+  get type () {
+    return 'mpx resolve'
+  }
+
+  mpxAction (module, compilation, callback) {
+    this.compilation = compilation
+    return callback()
+  }
+
+  getResolved () {
+    const { resource, packageName, compilation } = this
+    if (!compilation) return ''
+    const mpx = compilation.__mpx__
+    if (!mpx) return ''
+    const { pagesMap, componentsMap, staticResourcesMap } = mpx
+    const { resourcePath } = parseRequest(resource)
+    const currentComponentsMap = componentsMap[packageName]
+    const mainComponentsMap = componentsMap.main
+    const currentStaticResourcesMap = staticResourcesMap[packageName]
+    const mainStaticResourcesMap = staticResourcesMap.main
+    return pagesMap[resourcePath] || currentComponentsMap[resourcePath] || mainComponentsMap[resourcePath] || currentStaticResourcesMap[resourcePath] || mainStaticResourcesMap[resourcePath] || ''
+  }
+
+  // resolved可能会动态变更，需用此更新hash
+  updateHash (hash, context) {
+    this.resolved = this.getResolved()
+    const { resource, issuerResource, compilation } = this
+    if (this.resolved) {
+      hash.update(this.resolved)
+    } else {
+      compilation.errors.push(new Error(`Path ${resource} is not a page/component/static resource, which is resolved from ${issuerResource}!`))
+    }
+    super.updateHash(hash, context)
+  }
+
+  serialize (context) {
+    const { write } = context
+    write(this.resource)
+    write(this.packageName)
+    write(this.issuerResource)
+    write(this.range)
+    super.serialize(context)
+  }
+
+  deserialize (context) {
+    const { read } = context
+    this.resource = read()
+    this.packageName = read()
+    this.issuerResource = read()
+    this.range = read()
+    super.deserialize(context)
+  }
+}
+
+ResolveDependency.Template = class ResolveDependencyTemplate {
+  apply (dep, source) {
+    const content = this.getContent(dep)
+    source.replace(dep.range[0], dep.range[1] - 1, content)
+  }
+
+  getContent (dep) {
+    const { resolved = '', compilation } = dep
+    const publicPath = compilation.outputOptions.publicPath || ''
+    // for tenon
+    if (dep.compilation.__mpx__.mode === 'tenon') {
+      return `getRelativePath(currentURL, ${JSON.stringify(resolved)}) + '.js'`
+    }
+    return JSON.stringify(publicPath + resolved)
+  }
+}
+
+makeSerializable(ResolveDependency, '@mpxjs/webpack-plugin/lib/dependencies/ResolveDependency')
+
+module.exports = ResolveDependency