@mpxjs/webpack-plugin 2.6.114-alpha.8 → 2.6.115

package/lib/dependencies/DynamicEntryDependency.js

@@ -1,171 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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/dependencies/ResolveDependency.js

@@ -1,88 +0,0 @@
-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

package/lib/independent-loader.js

@@ -1,52 +0,0 @@
-const parseComponent = require('./parser')
-const createHelpers = require('./helpers')
-const CommonJsVariableDependency = require('./dependencies/CommonJsVariableDependency')
-const path = require('path')
-const normalize = require('./utils/normalize')
-
-module.exports = function (content) {
-  this.cacheable()
-  const mpx = this.getMpx()
-  if (!mpx) {
-    return content
-  }
-
-  const mode = mpx.mode
-  const env = mpx.env
-  const i18n = mpx.i18n
-  const filePath = this.resourcePath
-  const extname = path.extname(filePath)
-  if (extname === '.mpx') {
-    const parts = parseComponent(content, {
-      filePath,
-      needMap: this.sourceMap,
-      mode,
-      env
-    })
-    const {
-      getRequire
-    } = createHelpers(this)
-
-    if (parts.script) {
-      content = getRequire('script', parts.script)
-    } else {
-      content = ''
-    }
-  }
-
-  let output = 'global.isIndependent = true\n'
-  // 注入i18n
-  if (i18n) {
-    const i18nWxsPath = normalize.lib('runtime/i18n.wxs')
-    const i18nWxsLoaderPath = normalize.lib('wxs/i18n-loader.js')
-    const i18nWxsRequest = i18nWxsLoaderPath + '!' + i18nWxsPath
-    this._module.addDependency(new CommonJsVariableDependency(i18nWxsRequest))
-    // 避免该模块被concatenate导致注入的i18n没有最先执行
-    this._module.buildInfo.moduleConcatenationBailout = 'i18n'
-  }
-  output += content
-  output += '\n'
-  output += 'delete global.isIndependent\n'
-
-  return output
-}