@mpxjs/webpack-plugin 2.6.114-alpha.6 → 2.6.114-alpha.9

package/lib/dependencies/AppEntryDependency.js

@@ -0,0 +1,58 @@
+const NullDependency = require('webpack/lib/dependencies/NullDependency')
+const makeSerializable = require('webpack/lib/util/makeSerializable')
+
+class AppEntryDependency extends NullDependency {
+  constructor (resourcePath, name) {
+    super()
+    this.resourcePath = resourcePath
+    this.name = name
+  }
+
+  get type () {
+    return 'mpx app entry'
+  }
+
+  mpxAction (module, compilation, callback) {
+    const mpx = compilation.__mpx__
+    const moduleGraph = compilation.moduleGraph
+
+    mpx.getEntryNode(module, 'app')
+
+    if (mpx.appInfo.name) {
+      const issuer = moduleGraph.getIssuer(module)
+      const err = new Error(issuer
+        ? `[json compiler]:Mpx单次构建中只能存在一个App，当前组件/页面[${module.resource}]通过[${issuer.resource}]非法引入，引用的资源将被忽略，请确保组件/页面资源通过usingComponents/pages配置引入！`
+        : `[json compiler]:Mpx单次构建中只能存在一个App，请检查当前entry中的资源[${module.resource}]是否为组件/页面，通过添加?component/page查询字符串显式声明该资源是组件/页面！`)
+      return callback(err)
+    }
+
+    mpx.appInfo = {
+      resourcePath: this.resourcePath,
+      name: this.name
+    }
+    return callback()
+  }
+
+  serialize (context) {
+    const { write } = context
+    write(this.resourcePath)
+    write(this.name)
+    super.serialize(context)
+  }
+
+  deserialize (context) {
+    const { read } = context
+    this.resourcePath = read()
+    this.name = read()
+    super.deserialize(context)
+  }
+}
+
+AppEntryDependency.Template = class AppEntryDependencyTemplate {
+  apply () {
+  }
+}
+
+makeSerializable(AppEntryDependency, '@mpxjs/webpack-plugin/lib/dependencies/AppEntryDependency')
+
+module.exports = AppEntryDependency

package/lib/dependencies/CommonJsAsyncDependency.js

@@ -0,0 +1,51 @@
+const ModuleDependency = require('webpack/lib/dependencies/ModuleDependency')
+const makeSerializable = require('webpack/lib/util/makeSerializable')
+
+class CommonJsAsyncDependency extends ModuleDependency {
+  constructor (request, range) {
+    super(request)
+    this.range = range
+  }
+
+  get type () {
+    return 'mpx cjs async'
+  }
+
+  get category () {
+    return 'commonjs'
+  }
+}
+
+CommonJsAsyncDependency.Template = class CommonJsAsyncDependencyTemplate extends (
+  ModuleDependency.Template
+) {
+  apply (
+    dep,
+    source,
+    {
+      runtimeTemplate,
+      moduleGraph,
+      chunkGraph,
+      runtimeRequirements
+    }
+  ) {
+    const requireExpr = runtimeTemplate.moduleExports({
+      module: moduleGraph.getModule(dep),
+      chunkGraph,
+      request: dep.request,
+      weak: dep.weak,
+      runtimeRequirements
+    })
+
+    const content = `Promise.resolve(${requireExpr})`
+
+    source.replace(dep.range[0], dep.range[1] - 1, content)
+  }
+}
+
+makeSerializable(
+  CommonJsAsyncDependency,
+  '@mpxjs/webpack-plugin/lib/dependencies/CommonJsAsyncDependency'
+)
+
+module.exports = CommonJsAsyncDependency

package/lib/dependencies/CommonJsVariableDependency.js

@@ -0,0 +1,81 @@
+const ModuleDependency = require('webpack/lib/dependencies/ModuleDependency')
+const makeSerializable = require('webpack/lib/util/makeSerializable')
+const InitFragment = require('webpack/lib//InitFragment')
+
+class CommonJsVariableDependency extends ModuleDependency {
+  constructor (request, name = '') {
+    super(request)
+    this.name = name
+  }
+
+  serialize (context) {
+    const { write } = context
+    write(this.name)
+    super.serialize(context)
+  }
+
+  deserialize (context) {
+    const { read } = context
+    this.name = read()
+    super.deserialize(context)
+  }
+
+  updateHash (hash, context) {
+    hash.update(this.request)
+    hash.update(this.name)
+    super.updateHash(hash, context)
+  }
+
+  get type () {
+    return 'mpx cjs variable'
+  }
+
+  get category () {
+    return 'commonjs'
+  }
+}
+
+CommonJsVariableDependency.Template = class CommonJsVariableDependencyTemplate extends (
+  ModuleDependency.Template
+) {
+  apply (
+    dep,
+    source,
+    {
+      runtimeTemplate,
+      moduleGraph,
+      chunkGraph,
+      runtimeRequirements,
+      initFragments
+    }
+  ) {
+    const importedModule = moduleGraph.getModule(dep)
+    let requireExpr = runtimeTemplate.moduleExports({
+      module: importedModule,
+      chunkGraph,
+      request: dep.request,
+      weak: dep.weak,
+      runtimeRequirements
+    })
+
+    let expr = '/* mpx cjs variable */ '
+    if (dep.name) expr += 'var ' + dep.name + ' = '
+    expr += requireExpr + ';\n'
+
+    initFragments.push(
+      new InitFragment(
+        expr,
+        InitFragment.STAGE_CONSTANTS,
+        1,
+        dep.request
+      )
+    )
+  }
+}
+
+makeSerializable(
+  CommonJsVariableDependency,
+  '@mpxjs/webpack-plugin/lib/dependencies/CommonJsVariableDependency'
+)
+
+module.exports = CommonJsVariableDependency

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