@spcsn/taro-cli 0.1.0

package/src/presets/commands/init.ts

@@ -0,0 +1,63 @@
+import type { IPluginContext } from '@spcsn/taro-service';
+
+export default (ctx: IPluginContext) => {
+  ctx.registerCommand({
+    name: 'init',
+    optionsMap: {
+      '--name [name]': '项目名称',
+      '--description [description]': '项目介绍',
+      '--typescript': '使用TypeScript',
+      '--build-es5': '是否需要编译为es5',
+      '--npm [npm]': '包管理工具',
+      '--template-source [templateSource]': '项目模板源',
+      '--clone [clone]': '拉取远程模板时使用git clone',
+      '--template [template]': '项目模板',
+      '--css [css]': 'CSS预处理器(sass/less/stylus/none)',
+      '--autoInstall': '自动安装依赖',
+      '-h, --help': 'output usage information',
+    },
+    async fn(opts) {
+      // init project
+      const { appPath } = ctx.paths;
+      const {
+        projectName,
+        templateSource,
+        clone,
+        template,
+        description,
+        typescript,
+        buildEs5,
+        css,
+        npm,
+        framework,
+        compiler,
+        hideDefaultTemplate,
+        sourceRoot,
+        autoInstall,
+        ask,
+      } = opts.options;
+
+      const Project = require('../../create/project').default;
+      const project = new Project({
+        sourceRoot,
+        projectName,
+        projectDir: appPath,
+        npm,
+        templateSource,
+        clone,
+        template,
+        description,
+        typescript,
+        buildEs5,
+        framework,
+        compiler,
+        hideDefaultTemplate,
+        autoInstall,
+        css,
+        ask,
+      });
+
+      project.create();
+    },
+  });
+};

package/src/presets/commands/inspect.ts

@@ -0,0 +1,137 @@
+import * as path from 'node:path';
+
+import { ENTRY, OUTPUT_DIR, resolveScriptPath, SOURCE_DIR } from '@spcsn/taro-helper';
+import { getPlatformType } from '@spcsn/taro-shared';
+
+import * as hooks from '../constant';
+
+import type { IPluginContext } from '@spcsn/taro-service';
+
+export default (ctx: IPluginContext) => {
+  ctx.registerCommand({
+    name: 'inspect',
+    optionsMap: {
+      '-t, --type [typeName]': 'Build type, weapp',
+      '-o, --output [outputPath]': 'output config to outputPath',
+    },
+    synopsisList: [
+      'taro inspect --type weapp',
+      'taro inspect --type weapp --output inspect.config.js',
+      'taro inspect --type weapp plugins',
+      'taro inspect --type weapp module.rules.0',
+    ],
+    async fn({ _, options }) {
+      const { fs, chalk } = ctx.helper;
+      const platform = options.type || options.t;
+
+      verifyIsTaroProject(ctx);
+      verifyPlatform(platform, chalk);
+
+      const configName = ctx.platforms.get(platform)?.useConfigName || '';
+      process.env.TARO_ENV = platform;
+      process.env.TARO_PLATFORM = getPlatformType(platform, configName);
+
+      let config = getConfig(ctx, platform);
+      config = {
+        ...config,
+        ...config[configName],
+      };
+      delete config.mini;
+      delete config.h5;
+
+      const isProduction = process.env.NODE_ENV === 'production';
+      const outputPath = options.output || options.o;
+      const mode = outputPath ? 'output' : 'console';
+      const extractPath = _[1];
+
+      await ctx.applyPlugins({
+        name: platform,
+        opts: {
+          config: {
+            ...config,
+            isWatch: !isProduction,
+            mode: isProduction ? 'production' : 'development',
+            async modifyWebpackChain(chain, webpack, data) {
+              await ctx.applyPlugins({
+                name: hooks.MODIFY_WEBPACK_CHAIN,
+                initialVal: chain,
+                opts: {
+                  chain,
+                  webpack,
+                  data,
+                },
+              });
+            },
+            onWebpackChainReady(chain) {
+              const webpackConfig = chain.toConfig();
+              const { toString } = chain.constructor;
+              const config = extractConfig(webpackConfig, extractPath);
+              const res = toString(config);
+
+              if (mode === 'console') {
+                const highlight = require('cli-highlight').default;
+                console.info(highlight(res, { language: 'js' }));
+              } else if (mode === 'output' && outputPath) {
+                fs.writeFileSync(outputPath, res);
+              }
+
+              process.exit(0);
+            },
+          },
+        },
+      });
+    },
+  });
+};
+
+/** 是否 Taro 项目根路径 */
+function verifyIsTaroProject(ctx: IPluginContext) {
+  const { fs, chalk, PROJECT_CONFIG } = ctx.helper;
+  const { configPath } = ctx.paths;
+
+  if (!configPath || !fs.existsSync(configPath)) {
+    console.log(chalk.red(`找不到项目配置文件${PROJECT_CONFIG}，请确定当前目录是 Taro 项目根目录!`));
+    process.exit(1);
+  }
+}
+
+/** 检查平台类型 */
+function verifyPlatform(platform, chalk) {
+  if (typeof platform !== 'string') {
+    console.log(chalk.red('请传入正确的编译类型！'));
+    process.exit(0);
+  }
+  if (platform !== 'weapp') {
+    console.log(chalk.red('当前 Fork 仅支持 weapp 平台检查。'));
+    process.exit(0);
+  }
+}
+
+/** 整理 config */
+function getConfig(ctx: IPluginContext, platform: string) {
+  const { initialConfig } = ctx;
+  const sourceDirName = initialConfig.sourceRoot || SOURCE_DIR;
+  const outputDirName = initialConfig.outputRoot || OUTPUT_DIR;
+  const sourceDir = path.join(ctx.appPath, sourceDirName);
+  const entryFilePath = resolveScriptPath(path.join(sourceDir, ENTRY));
+
+  const entry = {
+    [ENTRY]: [entryFilePath],
+  };
+
+  return {
+    ...initialConfig,
+    entry,
+    sourceRoot: sourceDirName,
+    outputRoot: outputDirName,
+    platform,
+  };
+}
+
+/** 按路径取出 webpackConfig 内的对应值 */
+function extractConfig(webpackConfig, extractPath: string | undefined) {
+  if (!extractPath) return webpackConfig;
+
+  const list = extractPath.split('.');
+  return list.reduce((config, current) => config[current], webpackConfig);
+}

package/src/presets/commands/update.ts

@@ -0,0 +1,175 @@
+import * as path from 'node:path';
+
+import * as inquirer from 'inquirer';
+import getLatestVersion from 'latest-version';
+import ora from 'ora';
+import * as semver from 'semver';
+
+import packagesManagement from '../../config/packagesManagement';
+import { execCommand, getPkgItemByKey } from '../../util';
+
+import type { IPluginContext } from '@spcsn/taro-service';
+
+export default (ctx: IPluginContext) => {
+  ctx.registerCommand({
+    name: 'update',
+    synopsisList: ['taro update self [version]', 'taro update project [version]'],
+    optionsMap: {
+      '--npm [npm]': '包管理工具',
+      '-h, --help': 'output usage information',
+    },
+    async fn({ _, options }) {
+      const { npm } = options;
+      const [, updateType, version] = _ as [string, ('self' | 'project')?, string?];
+      const { appPath, configPath } = ctx.paths;
+      const { chalk, fs, PROJECT_CONFIG, UPDATE_PACKAGE_LIST } = ctx.helper;
+
+      const pkgPath = path.join(appPath, 'package.json');
+      const pkgName = getPkgItemByKey('name');
+      const conf = {
+        npm: null,
+      };
+      const prompts: Record<string, unknown>[] = [];
+
+      async function getTargetVersion() {
+        let targetTaroVersion;
+
+        if (version) {
+          targetTaroVersion = semver.clean(version);
+        } else {
+          try {
+            targetTaroVersion = await getLatestVersion(pkgName, {
+              version: 'latest',
+            });
+          } catch (e) {
+            targetTaroVersion = await getLatestVersion(pkgName);
+          }
+        }
+        if (!semver.valid(targetTaroVersion)) {
+          console.log(chalk.red('命令错误:无效的 version ~'));
+          throw Error('无效的 version!');
+        }
+        return targetTaroVersion;
+      }
+
+      function execUpdate(command: string, version: string, isSelf = false) {
+        const updateTarget = isSelf ? ' CLI ' : ' Taro 项目依赖';
+        const spinString = `正在更新${updateTarget}到 v${version} ...`;
+        const spinner = ora(spinString).start();
+        execCommand({
+          command,
+          successCallback(data) {
+            spinner.stop();
+            console.log(data.replace(/\n$/, ''));
+          },
+          failCallback(data) {
+            spinner.stop();
+            spinner.warn(data.replace(/\n$/, ''));
+          },
+        });
+      }
+
+      /** 更新全局的 Taro CLI */
+      async function updateSelf() {
+        const spinner = ora('正在获取最新版本信息...').start();
+        const targetTaroVersion = await getTargetVersion();
+        spinner.stop();
+        console.log(chalk.green(`Taro 最新版本：${targetTaroVersion}\n`));
+
+        askNpm(conf, prompts);
+        const answers = npm ? { npm } : await inquirer.prompt(prompts);
+
+        const command = `${packagesManagement[answers.npm].globalCommand}@${targetTaroVersion}`;
+        execUpdate(command, targetTaroVersion, true);
+      }
+
+      /** 更新当前项目中的 Taro 相关依赖 */
+      async function updateProject() {
+        if (!configPath || !fs.existsSync(configPath)) {
+          console.log(chalk.red(`找不到项目配置文件 ${PROJECT_CONFIG}，请确定当前目录是 Taro 项目根目录!`));
+          process.exit(1);
+        }
+        const packageMap = require(pkgPath);
+
+        const spinner = ora('正在获取最新版本信息...').start();
+
+        const version = await getTargetVersion();
+
+        spinner.stop();
+
+        const oldVersion = packageMap.dependencies['@spcsn/taro'];
+        // 更新 @spcsn/* 底座版本
+        Object.keys(packageMap.dependencies || {}).forEach((key) => {
+          if (UPDATE_PACKAGE_LIST.indexOf(key) !== -1) {
+            packageMap.dependencies[key] = version;
+          }
+        });
+        Object.keys(packageMap.devDependencies || {}).forEach((key) => {
+          if (UPDATE_PACKAGE_LIST.indexOf(key) !== -1) {
+            packageMap.devDependencies[key] = version;
+          }
+        });
+
+        // 写入package.json
+        try {
+          await fs.writeJson(pkgPath, packageMap, { spaces: '\t' });
+          console.log(
+            chalk.green(`项目当前 Taro 版本：${oldVersion}，Taro 最新版本：${version}，更新项目 package.json 成功！`),
+          );
+          console.log();
+        } catch (err) {
+          console.error(err);
+        }
+
+        askNpm(conf, prompts);
+        const answers = npm ? { npm } : await inquirer.prompt(prompts);
+
+        const command = packagesManagement[answers.npm].command;
+
+        execUpdate(command, version);
+      }
+
+      function askNpm(conf, prompts) {
+        const packages = [
+          {
+            name: 'yarn',
+            value: 'yarn',
+          },
+          {
+            name: 'pnpm',
+            value: 'pnpm',
+          },
+          {
+            name: 'npm',
+            value: 'npm',
+          },
+          {
+            name: 'cnpm',
+            value: 'cnpm',
+          },
+        ];
+
+        if ((typeof conf.npm as string | undefined) !== 'string') {
+          prompts.push({
+            type: 'list',
+            name: 'npm',
+            message: '请选择包管理工具',
+            choices: packages,
+          });
+        }
+      }
+
+      if (updateType === 'self') return updateSelf();
+
+      if (updateType === 'project') return updateProject();
+
+      console.log(chalk.red('命令错误:'));
+      console.log(
+        `${chalk.green('taro update self [version]')} 更新 Taro 开发工具 taro-cli 到指定版本或 Taro3 的最新版本`,
+      );
+      console.log(
+        `${chalk.green('taro update project [version]')} 更新项目所有 Taro 相关依赖到指定版本或 Taro3 的最新版本`,
+      );
+    },
+  });
+};

package/src/presets/constant/hooks.ts

@@ -0,0 +1,14 @@
+export const MODIFY_APP_CONFIG = 'modifyAppConfig';
+export const MODIFY_WEBPACK_CHAIN = 'modifyWebpackChain';
+export const MODIFY_VITE_CONFIG = 'modifyViteConfig';
+export const MODIFY_BUILD_ASSETS = 'modifyBuildAssets';
+export const MODIFY_MINI_CONFIGS = 'modifyMiniConfigs';
+export const MODIFY_COMPONENT_CONFIG = 'modifyComponentConfig';
+export const MODIFY_RUNNER_OPTS = 'modifyRunnerOpts';
+export const ON_COMPILER_MAKE = 'onCompilerMake';
+export const ON_PARSE_CREATE_ELEMENT = 'onParseCreateElement';
+export const ON_BUILD_START = 'onBuildStart';
+export const ON_BUILD_FINISH = 'onBuildFinish';
+export const ON_BUILD_COMPLETE = 'onBuildComplete';
+
+export const MODIFY_CREATE_TEMPLATE = 'modifyCreateTemplate';

package/src/presets/constant/index.ts

@@ -0,0 +1 @@
+export * from './hooks';

package/src/presets/files/generateFrameworkInfo.ts

@@ -0,0 +1,30 @@
+import { getPkgVersion } from '../../util';
+
+import type { IPluginContext } from '@spcsn/taro-service';
+
+export default (ctx: IPluginContext) => {
+  ctx.registerMethod('generateFrameworkInfo', () => {
+    const { getInstalledNpmPkgVersion, processTypeEnum, printLog, chalk } = ctx.helper;
+    const { nodeModulesPath } = ctx.paths;
+    const { date, outputRoot } = ctx.initialConfig;
+    const frameworkInfoFileName = '.frameworkinfo';
+    const frameworkName = '@spcsn/taro-runtime';
+    const frameworkVersion = getInstalledNpmPkgVersion(frameworkName, nodeModulesPath);
+
+    if (frameworkVersion) {
+      const frameworkinfo = {
+        toolName: 'Taro',
+        toolCliVersion: getPkgVersion(),
+        toolFrameworkVersion: frameworkVersion,
+        createTime: date ? new Date(date).getTime() : Date.now(),
+      };
+      ctx.writeFileToDist({
+        filePath: frameworkInfoFileName,
+        content: JSON.stringify(frameworkinfo, null, 2),
+      });
+      printLog(processTypeEnum.GENERATE, '框架信息', `${outputRoot}/${frameworkInfoFileName}`);
+    } else {
+      printLog(processTypeEnum.WARNING, '依赖安装', chalk.red(`项目依赖 ${frameworkName} 未安装，或安装有误！`));
+    }
+  });
+};

package/src/presets/files/generateProjectConfig.ts

@@ -0,0 +1,41 @@
+import * as path from 'node:path';
+
+import type { IPluginContext } from '@spcsn/taro-service';
+
+export default (ctx: IPluginContext) => {
+  ctx.registerMethod('generateProjectConfig', ({ srcConfigName, distConfigName }) => {
+    // 混合模式不需要生成项目配置
+    const { blended, newBlended } = ctx.runOpts;
+    if (blended || newBlended) return;
+
+    const { appPath, sourcePath, outputPath } = ctx.paths;
+    const { printLog, processTypeEnum, fs } = ctx.helper;
+    // 生成 project.config.json
+    const projectConfigFileName = srcConfigName;
+    let projectConfigPath = path.join(appPath, projectConfigFileName);
+    if (!fs.existsSync(projectConfigPath)) {
+      // 若项目根目录不存在对应平台的 projectConfig 文件，则尝试从源代码目录查找
+      projectConfigPath = path.join(sourcePath, projectConfigFileName);
+      if (!fs.existsSync(projectConfigPath)) return;
+    }
+
+    const origProjectConfig = fs.readJSONSync(projectConfigPath);
+    // 优先从环境变量中获取 appid, 以应对多环境appid不同的情况
+    origProjectConfig.appid = process.env.TARO_APP_ID || origProjectConfig.appid;
+
+    // compileType 是 plugin 时不修改 miniprogramRoot 字段
+    let distProjectConfig = origProjectConfig;
+    if (origProjectConfig.compileType !== 'plugin') {
+      distProjectConfig = Object.assign({}, origProjectConfig, { miniprogramRoot: './' });
+    }
+    ctx.writeFileToDist({
+      filePath: distConfigName,
+      content: JSON.stringify(distProjectConfig, null, 2),
+    });
+
+    if (ctx.initialConfig.logger?.quiet === false) {
+      printLog(processTypeEnum.REMIND, 'appid', `${origProjectConfig.appid}`);
+      printLog(processTypeEnum.GENERATE, '工具配置', `${outputPath}/${distConfigName}`);
+    }
+  });
+};

package/src/presets/files/writeFileToDist.ts

@@ -0,0 +1,17 @@
+import * as path from 'node:path';
+
+import type { IPluginContext } from '@spcsn/taro-service';
+
+export default (ctx: IPluginContext) => {
+  ctx.registerMethod('writeFileToDist', ({ filePath, content }) => {
+    const { outputPath } = ctx.paths;
+    const { printLog, processTypeEnum, fs } = ctx.helper;
+    if (path.isAbsolute(filePath)) {
+      printLog(processTypeEnum.ERROR, 'ctx.writeFileToDist 不能接受绝对路径');
+      return;
+    }
+    const absFilePath = path.join(outputPath, filePath);
+    fs.ensureDirSync(path.dirname(absFilePath));
+    fs.writeFileSync(absFilePath, content);
+  });
+};

package/src/presets/hooks/build.ts

@@ -0,0 +1,22 @@
+import * as hooks from '../constant';
+
+import type { IPluginContext } from '@spcsn/taro-service';
+
+export default (ctx: IPluginContext) => {
+  [
+    hooks.MODIFY_APP_CONFIG,
+    hooks.MODIFY_WEBPACK_CHAIN,
+    hooks.MODIFY_VITE_CONFIG,
+    hooks.MODIFY_BUILD_ASSETS,
+    hooks.MODIFY_MINI_CONFIGS,
+    hooks.MODIFY_COMPONENT_CONFIG,
+    hooks.ON_COMPILER_MAKE,
+    hooks.ON_PARSE_CREATE_ELEMENT,
+    hooks.ON_BUILD_START,
+    hooks.ON_BUILD_FINISH,
+    hooks.ON_BUILD_COMPLETE,
+    hooks.MODIFY_RUNNER_OPTS,
+  ].forEach((methodName) => {
+    ctx.registerMethod(methodName);
+  });
+};

package/src/presets/hooks/create.ts

@@ -0,0 +1,9 @@
+import * as hooks from '../constant';
+
+import type { IPluginContext } from '@spcsn/taro-service';
+
+export default (ctx: IPluginContext) => {
+  [hooks.MODIFY_CREATE_TEMPLATE].forEach((methodName) => {
+    ctx.registerMethod(methodName);
+  });
+};

package/src/presets/index.ts

@@ -0,0 +1,15 @@
+import * as path from 'node:path';
+
+export default () => {
+  return {
+    plugins: [
+      // hooks
+      path.resolve(__dirname, 'hooks', 'build.js'),
+      path.resolve(__dirname, 'hooks', 'create.js'),
+      // 兼容其他平台小程序插件
+      path.resolve(__dirname, 'files', 'writeFileToDist.js'),
+      path.resolve(__dirname, 'files', 'generateProjectConfig.js'),
+      path.resolve(__dirname, 'files', 'generateFrameworkInfo.js'),
+    ],
+  };
+};

package/src/presets/platforms/plugin.ts

@@ -0,0 +1,75 @@
+import * as path from 'node:path';
+
+import { fs } from '@spcsn/taro-helper';
+import { getPlatformType } from '@spcsn/taro-shared';
+
+import type { IPluginContext } from '@spcsn/taro-service';
+
+const configName = 'mini';
+export default (ctx: IPluginContext) => {
+  ctx.registerPlatform({
+    name: 'plugin',
+    useConfigName: configName,
+    async fn({ config }) {
+      const { options, _ } = ctx.runOpts;
+      const { chalk, PLATFORMS } = ctx.helper;
+      const { WEAPP } = PLATFORMS;
+      const typeMap = {
+        [WEAPP]: '微信',
+      };
+      const { plugin, isWatch } = options;
+      if (plugin !== WEAPP) {
+        console.log(chalk.red('当前 Fork 仅支持微信小程序插件编译！'));
+        return;
+      }
+      console.log(chalk.green(`开始编译${typeMap[plugin]}小程序插件`));
+      async function buildPlugin(platform) {
+        process.env.TARO_ENV = platform;
+        process.env.TARO_PLATFORM = getPlatformType(platform, configName);
+        await ctx.applyPlugins({
+          name: 'build',
+          opts: {
+            config: {
+              ...config,
+              isBuildPlugin: true,
+              isWatch,
+              outputRoot: `${config.outputRoot}/plugin`,
+              platform,
+            },
+            options: Object.assign({}, options, {
+              platform,
+            }),
+            _,
+          },
+        });
+        await ctx.applyPlugins({
+          name: 'build',
+          opts: {
+            config: {
+              ...config,
+              isBuildPlugin: false,
+              isWatch,
+              outputRoot: `${config.outputRoot}/miniprogram`,
+              platform,
+              output: { ...(config.output || {}), clean: false },
+            },
+            options: Object.assign({}, options, {
+              platform,
+            }),
+            _,
+          },
+        });
+      }
+
+      await buildPlugin(plugin);
+
+      try {
+        const docSrcPath = path.join(process.cwd(), 'src/plugin/doc');
+        const docDestPath = path.join(process.cwd(), 'miniprogram/doc');
+        fs.copy(docSrcPath, docDestPath);
+      } catch (err) {
+        console.error('[@spcsn/taro-cli] build plugin doc failed: ', err);
+      }
+    },
+  });
+};