@spcsn/taro-cli 0.1.0

package/src/presets/commands/build.ts

@@ -0,0 +1,215 @@
+import { MessageKind, validateConfig } from '@tarojs/plugin-doctor';
+
+import { extractCompileEntry } from '../../util/appConfig';
+import * as hooks from '../constant';
+
+import type { IPluginContext } from '@spcsn/taro-service';
+
+export default (ctx: IPluginContext) => {
+  ctx.registerCommand({
+    name: 'build',
+    optionsMap: {
+      '--type [typeName]': 'Build type, weapp（默认 weapp）',
+      '--watch': 'Watch mode',
+      '--env [env]': 'Value for process.env.NODE_ENV',
+      '--pages': 'Specify the pages to be compiled, separate multiple by comma',
+      '--components': 'Specify the components to be compiled, separate multiple by comma',
+      '--mode [mode]': 'Value of dotenv extname',
+      '-p, --port [port]': 'Specified port',
+      '--no-build': 'Do not build project',
+      '--blended': 'Blended Taro project in an original MiniApp project',
+      '--new-blended':
+        'Blended Taro project in an original MiniApp project while supporting building components independently',
+      '--plugin [typeName]': 'Build Taro plugin project, weapp',
+      '--env-prefix [envPrefix]': "Provide the dotEnv varables's prefix",
+      '--no-check': 'Do not check config is valid or not',
+    },
+    synopsisList: [
+      'taro build --type weapp',
+      'taro build --type weapp --watch',
+      'taro build --type weapp --watch --pages pages/index/index',
+      'taro build --type weapp --env production',
+      'taro build --type weapp --blended',
+      'taro build --type weapp --no-build',
+      'taro build native-components --type weapp',
+      'taro build --type weapp --new-blended',
+      'taro build --plugin weapp --watch',
+      'taro build --plugin weapp',
+      'taro build --type weapp --mode prepare --env-prefix TARO_APP_',
+    ],
+    async fn(opts) {
+      const { options, config, _ } = opts;
+      const { platform, isWatch, blended, newBlended, withoutBuild, noInjectGlobalStyle, noCheck } = options;
+      const { fs, chalk, PROJECT_CONFIG } = ctx.helper;
+      const { outputPath, configPath } = ctx.paths;
+      const { args } = options;
+
+      if (!configPath || !fs.existsSync(configPath)) {
+        console.log(chalk.red(`找不到项目配置文件${PROJECT_CONFIG}，请确定当前目录是 Taro 项目根目录!`));
+        process.exit(1);
+      }
+
+      if (typeof platform !== 'string') {
+        console.log(chalk.red('请传入正确的编译类型！'));
+        process.exit(0);
+      }
+
+      // 校验 Taro 项目配置
+      if (!noCheck) {
+        const checkResult = await checkConfig({
+          projectConfig: ctx.initialConfig,
+          helper: ctx.helper,
+        });
+        if (!checkResult.isValid) {
+          const ERROR = chalk.red('[✗] ');
+          const WARNING = chalk.yellow('[!] ');
+          const SUCCESS = chalk.green('[✓] ');
+
+          const lineChalk = chalk.hex('#fff');
+          const errorChalk = chalk.hex('#f00');
+          console.log(errorChalk(`Taro 配置有误，请检查！ (${configPath})`));
+          checkResult.messages.forEach((message) => {
+            switch (message.kind) {
+              case MessageKind.Error:
+                console.log('  ' + ERROR + lineChalk(message.content));
+                break;
+              case MessageKind.Success:
+                console.log('  ' + SUCCESS + lineChalk(message.content));
+                break;
+              case MessageKind.Warning:
+                console.log('  ' + WARNING + lineChalk(message.content));
+                break;
+              case MessageKind.Manual:
+                console.log('  ' + lineChalk(message.content));
+                break;
+              default:
+                break;
+            }
+          });
+          console.log('');
+          process.exit(0);
+        }
+      }
+
+      const isProduction = process.env.NODE_ENV === 'production' || !isWatch;
+
+      // dist folder
+      fs.ensureDirSync(outputPath);
+
+      // is build native components mode?
+      const isBuildNativeComp = _[1] === 'native-components';
+
+      await ctx.applyPlugins(hooks.ON_BUILD_START);
+      await ctx.applyPlugins({
+        name: platform,
+        opts: {
+          config: {
+            ...config,
+            isWatch,
+            mode: isProduction ? 'production' : 'development',
+            blended,
+            isBuildNativeComp,
+            withoutBuild,
+            newBlended,
+            noInjectGlobalStyle,
+            async modifyAppConfig(appConfig) {
+              extractCompileEntry(appConfig, args, ctx);
+
+              await ctx.applyPlugins({
+                name: hooks.MODIFY_APP_CONFIG,
+                opts: {
+                  appConfig,
+                },
+              });
+            },
+            async modifyWebpackChain(chain, webpack, data) {
+              await ctx.applyPlugins({
+                name: hooks.MODIFY_WEBPACK_CHAIN,
+                initialVal: chain,
+                opts: {
+                  chain,
+                  webpack,
+                  data,
+                },
+              });
+            },
+            async modifyViteConfig(viteConfig, data, viteCompilerContext) {
+              await ctx.applyPlugins({
+                name: hooks.MODIFY_VITE_CONFIG,
+                initialVal: viteConfig,
+                opts: {
+                  viteConfig,
+                  data,
+                  viteCompilerContext,
+                },
+              });
+            },
+            async modifyBuildAssets(assets, miniPlugin) {
+              await ctx.applyPlugins({
+                name: hooks.MODIFY_BUILD_ASSETS,
+                initialVal: assets,
+                opts: {
+                  assets,
+                  miniPlugin,
+                },
+              });
+            },
+            async modifyMiniConfigs(configMap) {
+              await ctx.applyPlugins({
+                name: hooks.MODIFY_MINI_CONFIGS,
+                initialVal: configMap,
+                opts: {
+                  configMap,
+                },
+              });
+            },
+            async modifyComponentConfig(componentConfig, config) {
+              await ctx.applyPlugins({
+                name: hooks.MODIFY_COMPONENT_CONFIG,
+                opts: {
+                  componentConfig,
+                  config,
+                },
+              });
+            },
+            async onCompilerMake(compilation, compiler, plugin) {
+              await ctx.applyPlugins({
+                name: hooks.ON_COMPILER_MAKE,
+                opts: {
+                  compilation,
+                  compiler,
+                  plugin,
+                },
+              });
+            },
+            async onParseCreateElement(nodeName, componentConfig) {
+              await ctx.applyPlugins({
+                name: hooks.ON_PARSE_CREATE_ELEMENT,
+                opts: {
+                  nodeName,
+                  componentConfig,
+                },
+              });
+            },
+            async onBuildFinish({ error, stats, isWatch }) {
+              await ctx.applyPlugins({
+                name: hooks.ON_BUILD_FINISH,
+                opts: {
+                  error,
+                  stats,
+                  isWatch,
+                },
+              });
+            },
+          },
+        },
+      });
+      await ctx.applyPlugins(hooks.ON_BUILD_COMPLETE);
+    },
+  });
+};
+
+async function checkConfig({ projectConfig, helper }) {
+  const result = await validateConfig(projectConfig, helper);
+  return result;
+}

package/src/presets/commands/config.ts

@@ -0,0 +1,86 @@
+import * as path from 'node:path';
+
+import type { IPluginContext } from '@spcsn/taro-service';
+
+export default (ctx: IPluginContext) => {
+  ctx.registerCommand({
+    name: 'config',
+    optionsMap: {
+      '--json': '以 JSON 形式输出',
+    },
+    synopsisList: [
+      'taro config set <key> <value>',
+      'taro config get <key>',
+      'taro config delete <key>',
+      'taro config list [--json]',
+    ],
+    fn({ _, options }) {
+      const [, cmd, key, value] = _;
+      const json = !!options.json;
+      const { fs, getUserHomeDir, TARO_CONFIG_FOLDER, TARO_BASE_CONFIG } = ctx.helper;
+      const homedir = getUserHomeDir();
+      const configPath = path.join(homedir, `${TARO_CONFIG_FOLDER}/${TARO_BASE_CONFIG}`);
+      if (!homedir) return console.log('找不到用户根目录');
+
+      function displayConfigPath(configPath) {
+        console.log(`Config path: ${configPath}`);
+        console.log();
+      }
+
+      switch (cmd) {
+        case 'get':
+          if (!key) return console.log('Usage: taro config get <key>');
+          if (fs.existsSync(configPath)) {
+            displayConfigPath(configPath);
+            const config = fs.readJSONSync(configPath);
+            console.log(`key: ${key}, value: ${config[key]}`);
+          }
+          break;
+        case 'set':
+          if (!key || !value) return console.log('Usage: taro config set <key> <value>');
+
+          if (fs.existsSync(configPath)) {
+            displayConfigPath(configPath);
+            const config = fs.readJSONSync(configPath);
+            config[key] = value;
+            fs.writeJSONSync(configPath, config);
+          } else {
+            fs.ensureFileSync(configPath);
+            fs.writeJSONSync(configPath, {
+              [key]: value,
+            });
+          }
+          console.log(`set key: ${key}, value: ${value}`);
+          break;
+        case 'delete':
+          if (!key) return console.log('Usage: taro config delete <key>');
+
+          if (fs.existsSync(configPath)) {
+            displayConfigPath(configPath);
+            const config = fs.readJSONSync(configPath);
+            delete config[key];
+            fs.writeJSONSync(configPath, config);
+          }
+          console.log(`deleted: ${key}`);
+          break;
+        case 'list':
+        case 'ls':
+          if (fs.existsSync(configPath)) {
+            displayConfigPath(configPath);
+            console.log('Config info:');
+            const config = fs.readJSONSync(configPath);
+            if (json) {
+              console.log(JSON.stringify(config, null, 2));
+            } else {
+              for (const key in config) {
+                console.log(`${key}=${config[key]}`);
+              }
+            }
+          }
+          break;
+        default:
+          break;
+      }
+    },
+  });
+};

package/src/presets/commands/create.ts

@@ -0,0 +1,104 @@
+import * as hooks from '../constant';
+
+import type { IPluginContext } from '@spcsn/taro-service';
+import type { TSetCustomTemplateConfig } from '../../create/page';
+
+declare const enum createTemplateTypeEnum {
+  /**
+   * taro页面，taro使用者使用
+   */
+  PAGE = 'page',
+  /**
+   * taro插件，用于扩展命令行
+   */
+  PLUGIN_COMMAND = 'plugin-command',
+  /**
+   * taro插件，用于扩展编译过程
+   */
+  PLUGIN_BUILD = 'plugin-build',
+  /**
+   * taro插件，用于扩展 taro create 自定义模版
+   */
+  PLUGIN_TEMPLATE = 'plugin-template',
+}
+
+export default (ctx: IPluginContext) => {
+  ctx.registerCommand({
+    name: 'create',
+    optionsMap: {
+      '--name [name]': '名称',
+      '--dir [dir]': '路径',
+      '--subpkg [subpkg]': '分包路径',
+      '--description [description]': '介绍',
+      '--type [type]': '模版类型(page(默认)|plugin-command|plugin-build|plugin-template)',
+    },
+    synopsisList: [
+      'taro create page',
+      'taro create --name=page --description=desc',
+      'taro create my-plugin --type=plugin-command',
+    ],
+    fn({ _, options }) {
+      const type = options.type || createTemplateTypeEnum.PAGE;
+      const name = _[1] || options.name;
+      const description = options.description || '';
+      const afterCreate = options.afterCreate;
+      const templateSource = options.templateSource;
+      const framework = options.framework;
+      const css = options.css;
+      const typescript = options.typescript;
+      const clone = options.clone;
+      const { chalk } = ctx.helper;
+      const { appPath } = ctx.paths;
+
+      switch (type) {
+        case createTemplateTypeEnum.PAGE: {
+          if (typeof name !== 'string') {
+            return console.log(chalk.red('请输入需要创建的页面名称'));
+          }
+
+          const Page = require('../../create/page').default;
+          const page = new Page({
+            clone,
+            subPkg: options.subpkg,
+            framework,
+            css,
+            typescript,
+            pageDir: options.dir,
+            pageName: name,
+            projectDir: appPath,
+            description,
+            templateSource,
+            afterCreate,
+            async modifyCustomTemplateConfig(cb: TSetCustomTemplateConfig) {
+              await ctx.applyPlugins({ name: hooks.MODIFY_CREATE_TEMPLATE, opts: cb });
+            },
+          });
+
+          page.create();
+          break;
+        }
+        case createTemplateTypeEnum.PLUGIN_COMMAND:
+        case createTemplateTypeEnum.PLUGIN_BUILD:
+        case createTemplateTypeEnum.PLUGIN_TEMPLATE: {
+          if (typeof name !== 'string') {
+            return console.log(chalk.red('请输入需要创建的插件名称'));
+          }
+
+          const Plugin = require('../../create/plugin').default;
+          const plugin = new Plugin({
+            pluginName: name,
+            projectDir: appPath,
+            type,
+            description,
+            template: 'plugin-compile',
+          });
+
+          plugin.create();
+          break;
+        }
+        default:
+          break;
+      }
+    },
+  });
+};

package/src/presets/commands/global-config.ts

@@ -0,0 +1,140 @@
+import * as path from 'node:path';
+
+import ora from 'ora';
+import * as validatePkgName from 'validate-npm-package-name';
+
+import { execCommand, getPkgNameByFilterVersion, getRootPath } from '../../util';
+
+import type { IPluginContext } from '@spcsn/taro-service';
+
+type TPresetOrPluginAction = 'install' | 'uninstall';
+type TPluginType = 'plugin' | 'preset';
+
+const PRESET_OR_PLUGIN_COMMAND_CHINESE_MAP_MAP = {
+  install: '添加',
+  uninstall: '删除',
+};
+const PRESET_OR_PLUGIN_CHINESE_NAME_MAP = {
+  plugin: '插件',
+  preset: '插件集',
+};
+
+const PLUGIN_TYPE_TO_CONFIG_KEY = {
+  plugin: 'plugins',
+  preset: 'presets',
+};
+
+export default (ctx: IPluginContext) => {
+  ctx.registerCommand({
+    name: 'global-config',
+    synopsisList: [
+      'taro global-config add-plugin [pluginName]',
+      'taro global-config remove-plugin [pluginName]',
+      'taro global-config add-preset [presetName]',
+      'taro global-config remove-preset [presetName]',
+      'taro global-config reset',
+    ],
+    optionsMap: {
+      '-r --registry [url]': '指定 npm registry',
+      '-h, --help': 'output usage information',
+    },
+    fn({ _, options }) {
+      const [, action, pluginName] = _;
+      const { getUserHomeDir, TARO_GLOBAL_CONFIG_DIR, fs, TARO_GLOBAL_CONFIG_FILE } = ctx.helper;
+      const homedir = getUserHomeDir();
+      const globalPluginConfigDir = path.join(homedir, TARO_GLOBAL_CONFIG_DIR);
+      if (!homedir) return console.log('找不到用户根目录');
+      const rootPath = getRootPath();
+      const templatePath = path.join(rootPath, 'templates', 'global-config');
+      const registry = options.registry || options.r;
+      function makeSureConfigExists() {
+        if (!fs.existsSync(globalPluginConfigDir)) {
+          const spinner = ora(`目录不存在，全局配置初始化`).start();
+          try {
+            fs.copySync(templatePath, globalPluginConfigDir);
+            spinner.succeed(`全局配置初始化成功，${globalPluginConfigDir}`);
+          } catch (e) {
+            spinner.fail(`全局配置初始化失败，${e}`);
+            process.exit(1);
+          }
+        }
+      }
+      function addOrRemovePresetOrPlugin(actionType: TPresetOrPluginAction, pluginType: TPluginType) {
+        makeSureConfigExists();
+        const presetOrPluginChineseName = PRESET_OR_PLUGIN_CHINESE_NAME_MAP[pluginType];
+        const chineseCommand = PRESET_OR_PLUGIN_COMMAND_CHINESE_MAP_MAP[actionType];
+        if (!pluginName) {
+          console.error(`缺少要${chineseCommand}的${presetOrPluginChineseName}`);
+          process.exit(1);
+        }
+
+        const spinner = ora(`开始${chineseCommand}${presetOrPluginChineseName} ${pluginName}`).start();
+        const pluginWithoutVersionName = getPkgNameByFilterVersion(pluginName);
+        if (!validatePkgName(pluginWithoutVersionName).validForNewPackages) {
+          spinner.fail('安装的插件名不合规！');
+          process.exit(1);
+        }
+        let command = `cd ${globalPluginConfigDir} && npm ${actionType} ${pluginName}`;
+        if (registry) {
+          command += ` --registry=${registry}`;
+        }
+        execCommand({
+          command,
+          successCallback(data) {
+            console.log(data.replace(/\n$/, ''));
+            spinner.start(`开始修改${presetOrPluginChineseName}配置`);
+            const configFilePath = path.join(globalPluginConfigDir, TARO_GLOBAL_CONFIG_FILE);
+            let globalConfig;
+            try {
+              globalConfig = fs.readJSONSync(configFilePath);
+            } catch (e) {
+              spinner.fail('获取配置文件失败');
+            }
+            const configKey = PLUGIN_TYPE_TO_CONFIG_KEY[pluginType];
+            const configItem = globalConfig[configKey] || [];
+            const pluginIndex = configItem.findIndex((item) => {
+              if (typeof item === 'string') return item === pluginWithoutVersionName;
+              if (item instanceof Array) return item?.[0] === pluginWithoutVersionName;
+            });
+            const shouldChangeFile = !(Number(pluginIndex !== -1) ^ Number(actionType === 'uninstall'));
+            if (shouldChangeFile) {
+              actionType === 'install' ? configItem.push(pluginWithoutVersionName) : configItem.splice(pluginIndex, 1);
+              try {
+                fs.writeJSONSync(configFilePath, {
+                  [configKey]: configItem,
+                });
+              } catch (e) {
+                spinner.fail(`修改配置文件失败：${e}`);
+              }
+            }
+            spinner.succeed('修改配置文件成功');
+          },
+          failCallback(data) {
+            spinner.stop();
+            spinner.warn(data.replace(/\n$/, ''));
+          },
+        });
+      }
+      switch (action) {
+        case 'add-plugin':
+          addOrRemovePresetOrPlugin('install', 'plugin');
+          break;
+        case 'remove-plugin':
+          addOrRemovePresetOrPlugin('uninstall', 'plugin');
+          break;
+        case 'add-preset':
+          addOrRemovePresetOrPlugin('install', 'preset');
+          break;
+        case 'remove-preset':
+          addOrRemovePresetOrPlugin('uninstall', 'preset');
+          break;
+        case 'reset':
+          if (fs.existsSync(globalPluginConfigDir)) fs.removeSync(globalPluginConfigDir);
+          fs.copySync(templatePath, globalPluginConfigDir);
+          break;
+        default:
+          console.error('请输出正确的参数');
+      }
+    },
+  });
+};

package/src/presets/commands/help.ts

@@ -0,0 +1,17 @@
+import { chalk } from '@spcsn/taro-helper';
+
+import type { IPluginContext } from '@spcsn/taro-service';
+
+export default (ctx: IPluginContext) => {
+  ctx.registerCommand({
+    name: 'help',
+    synopsisList: ['taro help [cmd]'],
+    async fn({ _ }) {
+      const cmd = _[1];
+
+      if (!cmd) return console.log(chalk.yellow('用法：taro help [cmd]，cmd 不存在！请输入需要查看帮助的命令名称。'));
+
+      ctx.ctx.runHelp(cmd);
+    },
+  });
+};

package/src/presets/commands/info.ts

@@ -0,0 +1,81 @@
+import * as path from 'node:path';
+
+import * as envinfo from 'envinfo';
+
+import { getPkgVersion } from '../../util';
+
+import type { IPluginContext } from '@spcsn/taro-service';
+
+export default (ctx: IPluginContext) => {
+  ctx.registerCommand({
+    name: 'info',
+    synopsisList: ['taro info', 'taro info rn'],
+    async fn({ _ }) {
+      const rn = _[1] === 'rn';
+      const { fs, chalk, PROJECT_CONFIG } = ctx.helper;
+      const { appPath, configPath } = ctx.paths;
+
+      if (!configPath || !fs.existsSync(configPath)) {
+        console.log(chalk.red(`找不到项目配置文件${PROJECT_CONFIG}，请确定当前目录是 Taro 项目根目录!`));
+        process.exit(1);
+      }
+
+      if (rn) {
+        const tempPath = path.join(appPath, '.rn_temp');
+        if (fs.lstatSync(tempPath).isDirectory()) {
+          process.chdir('.rn_temp');
+        }
+      }
+
+      await info({}, ctx);
+    },
+  });
+};
+
+// 单独function获取@jdtaro相关的包
+function getJdtaroPackages(ctx) {
+  try {
+    const { appPath } = ctx.paths;
+    const fs = ctx.helper.fs;
+    const packageJsonPath = path.join(appPath, 'package.json');
+
+    if (fs.existsSync(packageJsonPath)) {
+      const packageJsonContent = fs.readFileSync(packageJsonPath, 'utf8');
+      const packageJson = JSON.parse(packageJsonContent);
+      const dependencies = Object.assign({}, packageJson.dependencies || {}, packageJson.devDependencies || {});
+
+      // 筛选出@jdtaro相关的包
+      return Object.keys(dependencies).filter((pkg) => pkg.startsWith('@jdtaro/'));
+    }
+  } catch (error) {
+    // 记录错误但不中断程序执行（添加trycatch）
+    console.error('读取或解析package.json时发生错误:', error instanceof Error ? error.message : String(error));
+  }
+
+  return [];
+}
+
+async function info(options, ctx) {
+  let npmPackages = ctx.helper.UPDATE_PACKAGE_LIST.concat(['react', 'react-native', 'expo', 'taro-ui']);
+
+  // 调用新函数获取@jdtaro相关包
+  const jdtaroPackages = getJdtaroPackages(ctx);
+  npmPackages = npmPackages.concat(jdtaroPackages);
+
+  const info = await envinfo.run(
+    Object.assign(
+      {},
+      {
+        System: ['OS', 'Shell'],
+        Binaries: ['Node', 'Yarn', 'npm'],
+        npmPackages,
+        npmGlobalPackages: ['typescript'],
+      },
+      options,
+    ),
+    {
+      title: `Taro CLI ${getPkgVersion()} environment info`,
+    },
+  );
+  console.log(info);
+}