@tarojs/service 3.6.22-nightly.0 → 3.6.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tarojs/service",
-  "version": "3.6.22-nightly.0",
+  "version": "3.6.22",
   "description": "Taro Service",
   "main": "index.js",
   "types": "types/index.d.ts",
@@ -11,8 +11,7 @@
   "files": [
     "index.js",
     "dist",
-    "types",
-    "src"
+    "types"
   ],
   "keywords": [
     "taro"
@@ -30,9 +29,9 @@
     "tapable": "^1.1.3",
     "webpack-merge": "^4.2.2",
     "ora": "^5.0.0",
-    "@tarojs/helper": "3.6.22-nightly.0",
-    "@tarojs/taro": "3.6.22-nightly.0",
-    "@tarojs/shared": "3.6.22-nightly.0"
+    "@tarojs/helper": "3.6.22",
+    "@tarojs/taro": "3.6.22",
+    "@tarojs/shared": "3.6.22"
   },
   "devDependencies": {
     "webpack": "5.78.0"

package/src/Config.ts

@@ -1,125 +0,0 @@
-import {
-  createSwcRegister,
-  ENTRY,
-  fs,
-  getModuleDefaultExport,
-  getUserHomeDir,
-  OUTPUT_DIR,
-  resolveScriptPath,
-  SOURCE_DIR,
-  TARO_GLOBAL_CONFIG_DIR,
-  TARO_GLOBAL_CONFIG_FILE
-} from '@tarojs/helper'
-import * as ora from 'ora'
-import * as path from 'path'
-import * as merge from 'webpack-merge'
-
-import {
-  CONFIG_DIR_NAME,
-  DEFAULT_CONFIG_FILE
-} from './utils/constants'
-
-import type { IProjectConfig } from '@tarojs/taro/types/compile'
-
-interface IConfigOptions {
-  appPath: string
-  disableGlobalConfig?: boolean
-}
-
-export default class Config {
-  appPath: string
-  configPath: string
-  initialConfig: IProjectConfig
-  initialGlobalConfig: IProjectConfig
-  isInitSuccess: boolean
-  disableGlobalConfig: boolean
-
-  constructor (opts: IConfigOptions) {
-    this.appPath = opts.appPath
-    this.disableGlobalConfig = !!opts?.disableGlobalConfig
-  }
-
-  async init (configEnv: {
-    mode: string
-    command: string
-  }) {
-    this.initialConfig = {}
-    this.initialGlobalConfig = {}
-    this.isInitSuccess = false
-    this.configPath = resolveScriptPath(path.join(this.appPath, CONFIG_DIR_NAME, DEFAULT_CONFIG_FILE))
-    if (!fs.existsSync(this.configPath)) {
-      if(this.disableGlobalConfig) return
-      this.initGlobalConfig()
-    } else {
-      createSwcRegister({
-        only: [
-          filePath => filePath.indexOf(path.join(this.appPath, CONFIG_DIR_NAME)) >= 0
-        ]
-      })
-      try {
-        const userExport = getModuleDefaultExport(require(this.configPath))
-        this.initialConfig = typeof userExport === 'function' ? await userExport(merge, configEnv) : userExport
-        this.isInitSuccess = true
-      } catch (err) {
-        console.log(err)
-      }
-    }
-  }
-
-  initGlobalConfig () {
-    const homedir = getUserHomeDir()
-    if(!homedir) return  console.error('获取不到用户 home 路径')
-    const globalPluginConfigPath = path.join(getUserHomeDir(), TARO_GLOBAL_CONFIG_DIR, TARO_GLOBAL_CONFIG_FILE)
-    const spinner = ora(`开始获取 taro 全局配置文件： ${globalPluginConfigPath}`).start()
-    if (!fs.existsSync(globalPluginConfigPath)) return spinner.warn(`获取 taro 全局配置文件失败，不存在全局配置文件：${globalPluginConfigPath}`)
-    try {
-      this.initialGlobalConfig = fs.readJSONSync(globalPluginConfigPath) || {}
-      spinner.succeed('获取 taro 全局配置成功')
-    }catch(e){
-      spinner.stop()
-      console.warn(`获取全局配置失败，如果需要启用全局插件请查看配置文件: ${globalPluginConfigPath} `)
-    }
-  }
-
-  getConfigWithNamed (platform, configName) {
-    const initialConfig = this.initialConfig
-    const sourceDirName = initialConfig.sourceRoot || SOURCE_DIR
-    const outputDirName = initialConfig.outputRoot || OUTPUT_DIR
-    const sourceDir = path.join(this.appPath, sourceDirName)
-    const entryName = ENTRY
-    const entryFilePath = resolveScriptPath(path.join(sourceDir, entryName))
-
-    const entry = {
-      [entryName]: [entryFilePath]
-    }
-
-    return {
-      entry,
-      alias: initialConfig.alias || {},
-      copy: initialConfig.copy,
-      sourceRoot: sourceDirName,
-      outputRoot: outputDirName,
-      platform,
-      framework: initialConfig.framework,
-      compiler: initialConfig.compiler,
-      cache: initialConfig.cache,
-      logger: initialConfig.logger,
-      baseLevel: initialConfig.baseLevel,
-      csso: initialConfig.csso,
-      sass: initialConfig.sass,
-      uglify: initialConfig.uglify,
-      plugins: initialConfig.plugins,
-      projectName: initialConfig.projectName,
-      env: initialConfig.env,
-      defineConstants: initialConfig.defineConstants,
-      designWidth: initialConfig.designWidth,
-      deviceRatio: initialConfig.deviceRatio,
-      projectConfigName: initialConfig.projectConfigName,
-      jsMinimizer: initialConfig.jsMinimizer,
-      cssMinimizer: initialConfig.cssMinimizer,
-      terser: initialConfig.terser,
-      esbuild: initialConfig.esbuild,
-      ...initialConfig[configName]
-    }
-  }
-}

package/src/Kernel.ts

@@ -1,385 +0,0 @@
-import * as helper from '@tarojs/helper'
-import { getPlatformType } from '@tarojs/shared'
-import { EventEmitter } from 'events'
-import { merge } from 'lodash'
-import * as path from 'path'
-import { AsyncSeriesWaterfallHook } from 'tapable'
-
-import Plugin from './Plugin'
-import { convertPluginsToObject, mergePlugins, printHelpLog, resolvePresetsOrPlugins } from './utils'
-import {
-  IS_ADD_HOOK,
-  IS_EVENT_HOOK,
-  IS_MODIFY_HOOK,
-  PluginType
-} from './utils/constants'
-
-import type { IProjectConfig, PluginItem } from '@tarojs/taro/types/compile'
-import type Config from './Config'
-import type {
-  Func,
-  ICommand,
-  IHook,
-  IPaths,
-  IPlatform,
-  IPlugin,
-  IPluginsObject,
-  IPreset
-} from './utils/types'
-
-interface IKernelOptions {
-  appPath: string
-  config: Config
-  presets?: PluginItem[]
-  plugins?: PluginItem[]
-}
-
-export default class Kernel extends EventEmitter {
-  appPath: string
-  isWatch: boolean
-  isProduction: boolean
-  optsPresets: PluginItem[] | void
-  optsPlugins: PluginItem[] | void
-  plugins: Map<string, IPlugin>
-  paths: IPaths
-  extraPlugins: IPluginsObject
-  globalExtraPlugins: IPluginsObject
-  config: Config
-  initialConfig: IProjectConfig
-  initialGlobalConfig: IProjectConfig
-  hooks: Map<string, IHook[]>
-  methods: Map<string, Func[]>
-  cliCommands: string []
-  cliCommandsPath: string
-  commands: Map<string, ICommand>
-  platforms: Map<string, IPlatform>
-  helper: any
-  runOpts: any
-  debugger: any
-
-  constructor (options: IKernelOptions) {
-    super()
-    this.debugger = process.env.DEBUG === 'Taro:Kernel' ? helper.createDebug('Taro:Kernel') : function () {}
-    this.appPath = options.appPath || process.cwd()
-    this.optsPresets = options.presets
-    this.optsPlugins = options.plugins
-    this.config = options.config
-    this.hooks = new Map()
-    this.methods = new Map()
-    this.commands = new Map()
-    this.platforms = new Map()
-    this.initHelper()
-    this.initConfig()
-    this.initPaths()
-  }
-
-  initConfig () {
-    this.initialConfig = this.config.initialConfig
-    this.initialGlobalConfig = this.config.initialGlobalConfig
-    this.debugger('initConfig', this.initialConfig)
-  }
-
-  initPaths () {
-    this.paths = {
-      appPath: this.appPath,
-      nodeModulesPath: helper.recursiveFindNodeModules(path.join(this.appPath, helper.NODE_MODULES))
-    } as IPaths
-    if (this.config.isInitSuccess) {
-      Object.assign(this.paths, {
-        configPath: this.config.configPath,
-        sourcePath: path.join(this.appPath, this.initialConfig.sourceRoot as string),
-        outputPath: path.resolve(this.appPath, this.initialConfig.outputRoot as string)
-      })
-    }
-    this.debugger(`initPaths:${JSON.stringify(this.paths, null, 2)}`)
-  }
-
-  initHelper () {
-    this.helper = helper
-    this.debugger('initHelper')
-  }
-
-  initPresetsAndPlugins () {
-    const initialConfig = this.initialConfig
-    const initialGlobalConfig = this.initialGlobalConfig
-    const cliAndProjectConfigPresets = mergePlugins(this.optsPresets || [], initialConfig.presets || [])()
-    const cliAndProjectPlugins = mergePlugins(this.optsPlugins || [], initialConfig.plugins || [])()
-    const globalPlugins = convertPluginsToObject(initialGlobalConfig.plugins || [])()
-    const globalPresets = convertPluginsToObject(initialGlobalConfig.presets || [])()
-    this.debugger('initPresetsAndPlugins', cliAndProjectConfigPresets, cliAndProjectPlugins)
-    this.debugger('globalPresetsAndPlugins', globalPlugins, globalPresets)
-    process.env.NODE_ENV !== 'test' &&
-    helper.createSwcRegister({
-      only: [
-        ...Object.keys(cliAndProjectConfigPresets),
-        ...Object.keys(cliAndProjectPlugins),
-        ...Object.keys(globalPresets),
-        ...Object.keys(globalPlugins)
-      ]
-    })
-    this.plugins = new Map()
-    this.extraPlugins = {}
-    this.globalExtraPlugins = {}
-    this.resolvePresets(cliAndProjectConfigPresets, globalPresets)
-    this.resolvePlugins(cliAndProjectPlugins, globalPlugins)
-  }
-
-  resolvePresets (cliAndProjectPresets: IPluginsObject, globalPresets: IPluginsObject) {
-    const resolvedCliAndProjectPresets = resolvePresetsOrPlugins(this.appPath, cliAndProjectPresets, PluginType.Preset)
-    while (resolvedCliAndProjectPresets.length) {
-      this.initPreset(resolvedCliAndProjectPresets.shift()!)
-    }
-
-    const globalConfigRootPath = path.join(helper.getUserHomeDir(), helper.TARO_GLOBAL_CONFIG_DIR)
-    const resolvedGlobalPresets = resolvePresetsOrPlugins(globalConfigRootPath , globalPresets, PluginType.Plugin, true)
-    while (resolvedGlobalPresets.length) {
-      this.initPreset(resolvedGlobalPresets.shift()!, true)
-    }
-  }
-
-  resolvePlugins (cliAndProjectPlugins: IPluginsObject, globalPlugins: IPluginsObject) {
-    cliAndProjectPlugins = merge(this.extraPlugins, cliAndProjectPlugins)
-    const resolvedCliAndProjectPlugins = resolvePresetsOrPlugins(this.appPath, cliAndProjectPlugins, PluginType.Plugin)
-
-    globalPlugins = merge(this.globalExtraPlugins, globalPlugins)
-    const globalConfigRootPath = path.join(helper.getUserHomeDir(), helper.TARO_GLOBAL_CONFIG_DIR)
-    const resolvedGlobalPlugins = resolvePresetsOrPlugins(globalConfigRootPath , globalPlugins, PluginType.Plugin, true)
-
-    const resolvedPlugins = resolvedCliAndProjectPlugins.concat(resolvedGlobalPlugins)
-
-    while (resolvedPlugins.length) {
-      this.initPlugin(resolvedPlugins.shift()!)
-    }
-
-    this.extraPlugins = {}
-    this.globalExtraPlugins = {}
-  }
-
-  initPreset (preset: IPreset, isGlobalConfigPreset?: boolean) {
-    this.debugger('initPreset', preset)
-    const { id, path, opts, apply } = preset
-    const pluginCtx = this.initPluginCtx({ id, path, ctx: this })
-    const { presets, plugins } = apply()(pluginCtx, opts) || {}
-    this.registerPlugin(preset)
-    if (Array.isArray(presets)) {
-      const _presets = resolvePresetsOrPlugins(this.appPath, convertPluginsToObject(presets)(), PluginType.Preset, isGlobalConfigPreset)
-      while (_presets.length) {
-        this.initPreset(_presets.shift()!, isGlobalConfigPreset)
-      }
-    }
-    if (Array.isArray(plugins)) {
-      isGlobalConfigPreset
-        ? (this.globalExtraPlugins = merge(this.globalExtraPlugins, convertPluginsToObject(plugins)()))
-        : (this.extraPlugins = merge(this.extraPlugins, convertPluginsToObject(plugins)()))
-    }
-  }
-
-  initPlugin (plugin: IPlugin) {
-    const { id, path, opts, apply } = plugin
-    const pluginCtx = this.initPluginCtx({ id, path, ctx: this })
-    this.debugger('initPlugin', plugin)
-    this.registerPlugin(plugin)
-    apply()(pluginCtx, opts)
-    this.checkPluginOpts(pluginCtx, opts)
-  }
-
-  applyCliCommandPlugin (commandNames: string[] = []) {
-    const existsCliCommand: string[] = []
-    for( let i = 0; i < commandNames.length; i++ ) {
-      const commandName = commandNames[i]
-      const commandFilePath = path.resolve(this.cliCommandsPath, `${commandName}.js`)
-      if(this.cliCommands.includes(commandName)) existsCliCommand.push(commandFilePath)
-    }
-    const commandPlugins = convertPluginsToObject(existsCliCommand || [])()
-    helper.createSwcRegister({ only: [ ...Object.keys(commandPlugins) ] })
-    const resolvedCommandPlugins = resolvePresetsOrPlugins(this.appPath , commandPlugins, PluginType.Plugin)
-    while (resolvedCommandPlugins.length) {
-      this.initPlugin(resolvedCommandPlugins.shift()!)
-    }
-  }
-
-  checkPluginOpts (pluginCtx, opts) {
-    if (typeof pluginCtx.optsSchema !== 'function') {
-      return
-    }
-    this.debugger('checkPluginOpts', pluginCtx)
-    const joi = require('joi')
-    const schema = pluginCtx.optsSchema(joi)
-    if (!joi.isSchema(schema)) {
-      throw new Error(`插件${pluginCtx.id}中设置参数检查 schema 有误，请检查！`)
-    }
-    const { error } = schema.validate(opts)
-    if (error) {
-      error.message = `插件${pluginCtx.id}获得的参数不符合要求，请检查！`
-      throw error
-    }
-  }
-
-  registerPlugin (plugin: IPlugin) {
-    this.debugger('registerPlugin', plugin)
-    if (this.plugins.has(plugin.id)) {
-      throw new Error(`插件 ${plugin.id} 已被注册`)
-    }
-    this.plugins.set(plugin.id, plugin)
-  }
-
-  initPluginCtx ({ id, path, ctx }: { id: string, path: string, ctx: Kernel }) {
-    const pluginCtx = new Plugin({ id, path, ctx })
-    const internalMethods = ['onReady', 'onStart']
-    const kernelApis = [
-      'appPath',
-      'plugins',
-      'platforms',
-      'paths',
-      'helper',
-      'runOpts',
-      'initialConfig',
-      'applyPlugins',
-      'applyCliCommandPlugin'
-    ]
-    internalMethods.forEach(name => {
-      if (!this.methods.has(name)) {
-        pluginCtx.registerMethod(name)
-      }
-    })
-    return new Proxy(pluginCtx, {
-      get: (target, name: string) => {
-        if (this.methods.has(name)) {
-          const method = this.methods.get(name)
-          if (Array.isArray(method)) {
-            return (...arg) => {
-              method.forEach(item => {
-                item.apply(this, arg)
-              })
-            }
-          }
-          return method
-        }
-        if (kernelApis.includes(name)) {
-          return typeof this[name] === 'function' ? this[name].bind(this) : this[name]
-        }
-        return target[name]
-      }
-    })
-  }
-
-  async applyPlugins (args: string | { name: string, initialVal?: any, opts?: any }) {
-    let name
-    let initialVal
-    let opts
-    if (typeof args === 'string') {
-      name = args
-    } else {
-      name = args.name
-      initialVal = args.initialVal
-      opts = args.opts
-    }
-    this.debugger('applyPlugins')
-    this.debugger(`applyPlugins:name:${name}`)
-    this.debugger(`applyPlugins:initialVal:${initialVal}`)
-    this.debugger(`applyPlugins:opts:${opts}`)
-    if (typeof name !== 'string') {
-      throw new Error('调用失败，未传入正确的名称！')
-    }
-    const hooks = this.hooks.get(name) || []
-    if (!hooks.length) {
-      return await initialVal
-    }
-    const waterfall = new AsyncSeriesWaterfallHook(['arg'])
-    if (hooks.length) {
-      const resArr: any[] = []
-      for (const hook of hooks) {
-        waterfall.tapPromise({
-          name: hook.plugin!,
-          stage: hook.stage || 0,
-          // @ts-ignore
-          before: hook.before
-        }, async arg => {
-          const res = await hook.fn(opts, arg)
-          if (IS_MODIFY_HOOK.test(name) && IS_EVENT_HOOK.test(name)) {
-            return res
-          }
-          if (IS_ADD_HOOK.test(name)) {
-            resArr.push(res)
-            return resArr
-          }
-          return null
-        })
-      }
-    }
-    return await waterfall.promise(initialVal)
-  }
-
-  runWithPlatform (platform) {
-    if (!this.platforms.has(platform)) {
-      throw new Error(`不存在编译平台 ${platform}`)
-    }
-    const config = this.platforms.get(platform)!
-    const withNameConfig = this.config.getConfigWithNamed(config.name, config.useConfigName)
-    process.env.TARO_PLATFORM = getPlatformType(config.name, config.useConfigName)
-    return withNameConfig
-  }
-
-  setRunOpts (opts) {
-    this.runOpts = opts
-  }
-
-  runHelp (name: string) {
-    const command = this.commands.get(name)
-    const defaultOptionsMap = new Map()
-    defaultOptionsMap.set('-h, --help', 'output usage information')
-    let customOptionsMap = new Map()
-    if (command?.optionsMap) {
-      customOptionsMap = new Map(Object.entries(command?.optionsMap))
-    }
-    const optionsMap = new Map([...customOptionsMap, ...defaultOptionsMap])
-    printHelpLog(name, optionsMap, command?.synopsisList ? new Set(command?.synopsisList) : new Set())
-  }
-
-  async run (args: string | { name: string, opts?: any }) {
-    let name
-    let opts
-    if (typeof args === 'string') {
-      name = args
-    } else {
-      name = args.name
-      opts = args.opts
-    }
-    this.debugger('command:run')
-    this.debugger(`command:run:name:${name}`)
-    this.debugger('command:runOpts')
-    this.debugger(`command:runOpts:${JSON.stringify(opts, null, 2)}`)
-    this.setRunOpts(opts)
-
-    this.debugger('initPresetsAndPlugins')
-    this.initPresetsAndPlugins()
-
-    await this.applyPlugins('onReady')
-
-    this.debugger('command:onStart')
-    await this.applyPlugins('onStart')
-
-    if (!this.commands.has(name)) {
-      throw new Error(`${name} 命令不存在`)
-    }
-
-    if (opts?.isHelp) {
-      return this.runHelp(name)
-    }
-
-    if (opts?.options?.platform) {
-      opts.config = this.runWithPlatform(opts.options.platform)
-      await this.applyPlugins({
-        name: 'modifyRunnerOpts',
-        opts: {
-          opts: opts?.config
-        }
-      })
-    }
-
-    await this.applyPlugins({
-      name,
-      opts
-    })
-  }
-}

package/src/Plugin.ts

@@ -1,80 +0,0 @@
-import { addPlatforms } from '@tarojs/helper'
-
-import type Kernel from './Kernel'
-import type { Func, ICommand, IHook, IPlatform } from './utils/types'
-
-export default class Plugin {
-  id: string
-  path: string
-  ctx: Kernel
-  optsSchema: Func
-
-  constructor (opts) {
-    this.id = opts.id
-    this.path = opts.path
-    this.ctx = opts.ctx
-  }
-
-  register (hook: IHook) {
-    if (typeof hook.name !== 'string') {
-      throw new Error(`插件 ${this.id} 中注册 hook 失败， hook.name 必须是 string 类型`)
-    }
-    if (typeof hook.fn !== 'function') {
-      throw new Error(`插件 ${this.id} 中注册 hook 失败， hook.fn 必须是 function 类型`)
-    }
-    const hooks = this.ctx.hooks.get(hook.name) || []
-    hook.plugin = this.id
-    this.ctx.hooks.set(hook.name, hooks.concat(hook))
-  }
-
-  registerCommand (command: ICommand) {
-    if (this.ctx.commands.has(command.name)) {
-      throw new Error(`命令 ${command.name} 已存在`)
-    }
-    this.ctx.commands.set(command.name, command)
-    this.register(command)
-  }
-
-  registerPlatform (platform: IPlatform) {
-    if (this.ctx.platforms.has(platform.name)) {
-      throw new Error(`适配平台 ${platform.name} 已存在`)
-    }
-    addPlatforms(platform.name)
-    this.ctx.platforms.set(platform.name, platform)
-    this.register(platform)
-  }
-
-  registerMethod (...args) {
-    const { name, fn } = processArgs(args)
-    const methods = this.ctx.methods.get(name) || []
-    methods.push(fn || function (fn: Func) {
-      this.register({
-        name,
-        fn
-      })
-    }.bind(this))
-    this.ctx.methods.set(name, methods)
-  }
-
-  addPluginOptsSchema (schema) {
-    this.optsSchema = schema
-  }
-}
-
-function processArgs (args) {
-  let name, fn
-  if (!args.length) {
-    throw new Error('参数为空')
-  } else if (args.length === 1) {
-    if (typeof args[0] === 'string') {
-      name = args[0]
-    } else {
-      name = args[0].name
-      fn = args[0].fn
-    }
-  } else {
-    name = args[0]
-    fn = args[1]
-  }
-  return { name, fn }
-}

package/src/index.ts

@@ -1,9 +0,0 @@
-import Config from './Config'
-import Kernel from './Kernel'
-import { TaroPlatformBase, TaroPlatformWeb } from './platform-plugin-base'
-
-export * from './utils/types'
-export { Config, Kernel, TaroPlatformBase, TaroPlatformWeb }
-export default { Config, Kernel, TaroPlatformBase, TaroPlatformWeb }
-
-export type { IPluginContext } from './utils/types'

package/src/platform-plugin-base/index.ts

@@ -1,2 +0,0 @@
-export * from './mini'
-export * from './web'