@spcsn/taro-cli 0.1.0

package/dist/util/types.d.ts

@@ -0,0 +1,58 @@
+export interface IInstallOptions {
+    dev: boolean;
+    peerDependencies?: boolean;
+}
+export interface INpmConfig {
+    dir: string;
+    name: string;
+}
+export interface IResolvedCache {
+    [key: string]: {
+        main: string;
+        files: string[];
+    };
+}
+export interface IPrettierConfig {
+    printWidth?: number;
+    tabWidth?: number;
+    useTabs?: boolean;
+    semi?: boolean;
+    singleQuote?: boolean;
+    jsxSingleQuote?: boolean;
+    trailingComma?: 'none' | 'es5' | 'all';
+    bracketSpacing?: boolean;
+    jsxBracketSameLine?: boolean;
+    arrowParens?: 'avoid' | 'always';
+    rangeStart?: number;
+    rangeEnd?: number;
+    parser?: 'babel' | 'babylon' | 'flow' | 'typescript' | 'css' | 'scss' | 'less' | 'json' | 'json5' | 'json-stringify' | 'graphql' | 'markdown' | 'mdx' | 'html' | 'vue' | 'angular' | 'yaml';
+    filepath?: string;
+    requirePragma?: boolean;
+    insertPragma?: boolean;
+    proseWrap?: 'always' | 'never' | 'preserve';
+    htmlWhitespaceSensitivity?: 'css' | 'strict' | 'ignore';
+    endOfLine?: 'auto' | 'lf' | 'crlf' | 'cr';
+}
+export interface IBuildOptions {
+    type?: string;
+    watch?: boolean;
+    platform?: string;
+    port?: number;
+    release?: boolean;
+    envHasBeenSet?: boolean;
+    page?: string;
+    component?: string;
+    uiIndex?: string;
+}
+export interface IMiniAppBuildConfig {
+    adapter: string;
+    watch?: boolean;
+    envHasBeenSet?: boolean;
+    port?: number;
+    release?: boolean;
+    page?: string;
+    component?: string;
+}
+export interface IOption {
+    [key: string]: any;
+}

package/dist/util/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/util/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/util/types.ts"],"names":[],"mappings":""}

package/global.d.ts

@@ -0,0 +1,4 @@
+declare module '*.json' {
+  const value: any
+  export default value
+}

package/index.js

@@ -0,0 +1,3 @@
+module.exports = require('./dist/index.js').default;
+
+module.exports.default = module.exports;

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@spcsn/taro-cli",
+  "version": "0.1.0",
+  "description": "cli tool for taro",
+  "author": "O2Team",
+  "license": "MIT",
+  "main": "index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "bin",
+    "src",
+    "dist",
+    "templates",
+    "postinstall.js",
+    "index.js",
+    "global.d.ts"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NervJS/taro.git"
+  },
+  "bin": {
+    "taro": "bin/taro"
+  },
+  "keywords": [
+    "taro",
+    "weapp"
+  ],
+  "engines": {
+    "node": ">= 22"
+  },
+  "dependencies": {
+    "@tarojs/plugin-doctor": "^0.0.13",
+    "adm-zip": "^0.5.12",
+    "axios": "^1.6.8",
+    "cli-highlight": "^2.1.11",
+    "download-git-repo": "^3.0.2",
+    "envinfo": "^7.12.0",
+    "inquirer": "^8.2.6",
+    "latest-version": "^5.1.0",
+    "minimist": "^1.2.8",
+    "ora": "^5.4.1",
+    "semver": "^7.6.0",
+    "validate-npm-package-name": "^5.0.0",
+    "@spcsn/taro-helper": "0.1.0",
+    "@spcsn/taro-plugin-generator": "0.1.0",
+    "@spcsn/taro-plugin-framework-react": "0.1.0",
+    "@spcsn/taro-vite-runner": "0.1.0",
+    "@spcsn/taro-shared": "0.1.0",
+    "@spcsn/babel-preset-taro": "0.1.0",
+    "@spcsn/taro-service": "0.1.0",
+    "@spcsn/taro-plugin-platform-weapp": "0.1.0",
+    "@spcsn/taro-binding": "0.1.0"
+  },
+  "devDependencies": {
+    "@babel/types": "^7.24.0",
+    "@types/babel__traverse": "^7.20.6",
+    "@spcsn/taro": "0.1.0",
+    "@spcsn/taro-plugin-platform-weapp": "0.1.0"
+  },
+  "scripts": {
+    "prod": "pnpm run build",
+    "postinstall": "node postinstall.js",
+    "test": "cross-env NODE_ENV=test jest",
+    "test:ci": "cross-env NODE_ENV=test jest --ci -i --coverage --silent",
+    "test:dev": "cross-env NODE_ENV=test jest --watch",
+    "test:coverage": "cross-env NODE_ENV=test jest --coverage",
+    "updateSnapshot": "cross-env NODE_ENV=test jest --updateSnapshot",
+    "prebuild": "pnpm run clean",
+    "build": "tsc || true",
+    "dev": "tsc -w",
+    "clean": "rimraf dist"
+  }
+}

package/postinstall.js

@@ -0,0 +1,17 @@
+const { exec } = require('child_process');
+const axios = require('axios');
+
+axios
+  .get('https://taro.jd.com/', { timeout: 5000 })
+  .then(() => {
+    exec(
+      './bin/taro global-config add-plugin  @jdtaro/plugin-build-report-performance@latest --registry http://registry.m.jd.com',
+      (error, _stdout, _stderr) => {
+        if (error) {
+          console.error(`install performance plugin error: ${error}`);
+        }
+      },
+    );
+    console.log('cli postinstall success');
+  })
+  .catch(() => {});

package/src/__tests__/__mocks__/presets.ts

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

package/src/__tests__/build-config.spec.ts

@@ -0,0 +1,66 @@
+import * as path from 'node:path';
+
+import { emptyDirectory } from '@spcsn/taro-helper';
+
+import { run } from './utils';
+
+const runBuild = run('build', ['commands/build', require.resolve('@spcsn/taro-plugin-platform-weapp')]);
+
+jest.mock('@spcsn/taro-helper', () => {
+  const helper = jest.requireActual('@spcsn/taro-helper');
+  const fs = helper.fs;
+  return {
+    __esModule: true,
+    ...helper,
+    emptyDirectory: jest.fn(),
+    fs: {
+      ...fs,
+    },
+  };
+});
+
+const APP_PATH = path.join(__dirname, 'fixtures/default');
+const OUTPUT_PATH = path.join(__dirname, 'fixtures/default/dist');
+
+describe('构建配置测试', () => {
+  const emptyDirectoryMocked = emptyDirectory as jest.Mock<any>;
+
+  beforeEach(() => {
+    emptyDirectoryMocked.mockReset();
+    process.argv = [];
+  });
+
+  afterEach(() => {
+    process.argv = [];
+    emptyDirectoryMocked.mockReset();
+  });
+
+  describe('小程序', () => {
+    it(`项目 output.clean = clean: { keep: ['project.config.json'] } ==> 清空dist文件夹但保留指定文件`, async () => {
+      const exitSpy = jest.spyOn(process, 'exit') as jest.SpyInstance<void, any>;
+      const logSpy = jest.spyOn(console, 'log');
+      const errorSpy = jest.spyOn(console, 'error');
+      logSpy.mockImplementation(() => {});
+      errorSpy.mockImplementation(() => {});
+      exitSpy.mockImplementation(() => {
+        throw new Error();
+      });
+
+      try {
+        await runBuild(APP_PATH, {
+          options: {
+            type: 'weapp',
+            platform: 'weapp',
+          },
+        });
+      } catch (error) {
+        // no handler
+      }
+      expect(emptyDirectoryMocked).toBeCalledWith(OUTPUT_PATH, { excludes: ['project.config.json'] });
+
+      exitSpy.mockRestore();
+      logSpy.mockRestore();
+      errorSpy.mockRestore();
+    });
+  });
+});

package/src/__tests__/cli.spec.ts

@@ -0,0 +1,226 @@
+import { Kernel } from '@spcsn/taro-service';
+
+import CLI from '../cli';
+import { getPkgVersion } from '../util';
+
+jest.mock('@spcsn/taro-service');
+const MockedKernel = Kernel as unknown as jest.Mock<Kernel>;
+const APP_PATH = '/a/b/c';
+
+function setProcessArgv(cmd: string) {
+  // @ts-ignore
+  process.argv = [null, ...cmd.split(' ')];
+}
+
+describe('inspect', () => {
+  let cli: CLI;
+
+  beforeAll(() => {
+    cli = new CLI(APP_PATH);
+  });
+
+  beforeEach(() => {
+    MockedKernel.mockClear();
+    process.argv = [];
+    delete process.env.NODE_ENV;
+    delete process.env.TARO_ENV;
+  });
+
+  afterEach(() => {
+    MockedKernel.mockClear();
+    process.argv = [];
+    delete process.env.NODE_ENV;
+    delete process.env.TARO_ENV;
+  });
+
+  describe('build', () => {
+    const baseOpts = {
+      _: ['build'],
+      options: {
+        args: expect.any(Object),
+        platform: undefined,
+        publicPath: undefined,
+        isWatch: false,
+        withoutBuild: false,
+        env: undefined,
+        blended: false,
+        assetsDest: undefined,
+        bundleOutput: undefined,
+        plugin: undefined,
+        isBuildNativeComp: false,
+        newBlended: false,
+        noInjectGlobalStyle: false,
+        noCheck: false,
+        sourceMapUrl: undefined,
+        sourcemapOutput: undefined,
+        sourcemapSourcesRoot: undefined,
+      },
+      isHelp: false,
+    };
+
+    it('should make configs', async () => {
+      const platform = 'weapp';
+      setProcessArgv('taro build --type weapp --watch --port 8080');
+      await cli.run();
+      const ins = MockedKernel.mock.instances[0];
+
+      const opts = Object.assign({}, baseOpts);
+      opts.options = Object.assign({}, baseOpts.options, {
+        platform,
+        isWatch: true,
+        port: 8080,
+        deviceType: undefined,
+        resetCache: false,
+        qr: false,
+      });
+
+      expect(ins.run).toHaveBeenCalledWith({
+        name: 'build',
+        opts,
+      });
+    });
+
+    it('should not set node env again', async () => {
+      process.env.NODE_ENV = 'development';
+      setProcessArgv('taro build --type weapp');
+      await cli.run();
+      expect(process.env.NODE_ENV).toEqual('development');
+    });
+
+    it.skip('should make plugin config', async () => {
+      setProcessArgv('taro build --plugin');
+      await cli.run();
+      const ins = MockedKernel.mock.instances[0];
+      expect(ins.run).toHaveBeenCalledWith({
+        name: 'build',
+        opts: Object.assign({}, baseOpts, {
+          platform: 'plugin',
+          plugin: 'weapp',
+        }),
+      });
+      expect(process.env.NODE_ENV).toEqual('production');
+      expect(process.env.TARO_ENV).toEqual('plugin');
+    });
+  });
+
+  describe('init', () => {
+    it('should make configs', async () => {
+      const projectName = 'temp';
+      const templateSource = 'https://url';
+      const template = 'mobx';
+      const css = 'sass';
+      setProcessArgv('taro init temp --typescript --template-source=https://url --clone --template mobx --css sass');
+      await cli.run();
+      const ins = MockedKernel.mock.instances[0];
+      expect(ins.run).toHaveBeenCalledWith({
+        name: 'init',
+        opts: {
+          _: ['init', 'temp'],
+          options: {
+            appPath: APP_PATH,
+            projectName,
+            typescript: true,
+            templateSource,
+            description: undefined,
+            clone: true,
+            template,
+            css,
+          },
+          isHelp: false,
+        },
+      });
+    });
+
+    it('should set project name', async () => {
+      const projectName = 'demo';
+      setProcessArgv('taro init --name demo');
+      await cli.run();
+      const ins = MockedKernel.mock.instances[0];
+      expect(ins.run).toHaveBeenCalledWith({
+        name: 'init',
+        opts: {
+          _: ['init'],
+          options: {
+            appPath: APP_PATH,
+            projectName,
+            typescript: undefined,
+            templateSource: undefined,
+            description: undefined,
+            clone: false,
+            template: undefined,
+            css: undefined,
+          },
+          isHelp: false,
+        },
+      });
+    });
+  });
+
+  describe('convert', () => {
+    it('should make configs', async () => {
+      setProcessArgv('taro convert');
+      await cli.run();
+      const ins = MockedKernel.mock.instances[0];
+      expect(ins.run).toHaveBeenCalledWith({
+        name: 'convert',
+        opts: {
+          _: ['convert'],
+          options: {
+            build: true,
+            check: true,
+            'inject-global-style': true,
+          },
+          isHelp: false,
+        },
+      });
+    });
+  });
+
+  describe('customCommand', () => {
+    it('should make configs', async () => {
+      const cmd = 'inspect';
+      const _ = [cmd, 'entry'];
+      const type = 'weapp';
+      setProcessArgv('taro inspect entry --type weapp -h --version');
+      await cli.run();
+      const ins = MockedKernel.mock.instances[0];
+      expect(ins.run).toHaveBeenCalledWith({
+        name: cmd,
+        opts: {
+          _,
+          options: {
+            build: true,
+            check: true,
+            'inject-global-style': true,
+            type,
+          },
+          isHelp: true,
+        },
+      });
+    });
+  });
+
+  describe('others', () => {
+    it('should log helps', async () => {
+      const spy = jest.spyOn(console, 'log');
+      spy.mockImplementation(() => {});
+
+      setProcessArgv('taro -h');
+      await cli.run();
+      expect(spy).toBeCalledTimes(16);
+
+      spy.mockRestore();
+    });
+
+    it('should log version', async () => {
+      const spy = jest.spyOn(console, 'log');
+      spy.mockImplementation(() => {});
+
+      setProcessArgv('taro -v');
+      await cli.run();
+      expect(spy).toBeCalledWith(getPkgVersion());
+
+      spy.mockRestore();
+    });
+  });
+});

package/src/__tests__/config.spec.ts

@@ -0,0 +1,224 @@
+import * as path from 'node:path';
+
+import { fs, getUserHomeDir, TARO_BASE_CONFIG, TARO_CONFIG_FOLDER } from '@spcsn/taro-helper';
+import { CONFIG_DIR_NAME, DEFAULT_CONFIG_FILE } from '@spcsn/taro-service/src/utils/constants';
+
+import { run } from './utils';
+
+jest.mock('@spcsn/taro-helper', () => {
+  const helper = jest.requireActual('@spcsn/taro-helper');
+  const fs = helper.fs;
+  return {
+    __esModule: true,
+    ...helper,
+    getUserHomeDir: jest.fn(),
+    fs: {
+      ...fs,
+      existsSync: jest.fn(),
+      readJSONSync: jest.fn(),
+      writeJSONSync: jest.fn(),
+      ensureFileSync: jest.fn(),
+    },
+  };
+});
+
+const runConfig = run('config', ['commands/config']);
+
+describe('config', () => {
+  const getUserHomeDirMocked = getUserHomeDir as jest.Mock<any>;
+  const existsSyncMocked = fs.existsSync as jest.Mock<any>;
+  const readJSONSyncMocked = fs.readJSONSync as jest.Mock<any>;
+  const writeJSONSyncMocked = fs.writeJSONSync as jest.Mock<any>;
+  const ensureFileSyncMocked = fs.ensureFileSync as jest.Mock<any>;
+  const appPath = '/';
+
+  beforeEach(() => {
+    getUserHomeDirMocked.mockReturnValue(appPath);
+    // Note: 设置项目配置文件为不存在，config 指令不一定在项目内执行，故而当前测试跳过配置（与过往配置保持一致，后续可视情况调整）
+    existsSyncMocked.mockImplementation(
+      (filePath = '') => !filePath.includes(path.join(appPath, CONFIG_DIR_NAME, DEFAULT_CONFIG_FILE)),
+    );
+  });
+
+  afterEach(() => {
+    getUserHomeDirMocked.mockReset();
+    existsSyncMocked.mockReset();
+  });
+
+  it("should exit because can't find home dir", async () => {
+    const logSpy = jest.spyOn(console, 'log');
+    logSpy.mockImplementation(() => {});
+
+    getUserHomeDirMocked.mockReturnValue('');
+
+    await runConfig(appPath);
+
+    expect(logSpy).toBeCalledWith('找不到用户根目录');
+    logSpy.mockRestore();
+  });
+
+  it('should warn when getting config without args key', async () => {
+    const logSpy = jest.spyOn(console, 'log');
+    logSpy.mockImplementation(() => {});
+
+    await runConfig(appPath, { args: ['get'] });
+
+    expect(logSpy).toBeCalledWith('Usage: taro config get <key>');
+    logSpy.mockRestore();
+  });
+
+  it('should get config', async () => {
+    const key = 'k';
+    const value = 'v';
+    const configPath = path.join('/', `${TARO_CONFIG_FOLDER}/${TARO_BASE_CONFIG}`);
+
+    const logSpy = jest.spyOn(console, 'log');
+    logSpy.mockImplementation(() => {});
+    readJSONSyncMocked.mockImplementation(() => ({
+      [key]: value,
+    }));
+
+    await runConfig(appPath, { args: ['get', key] });
+
+    expect(logSpy).nthCalledWith(1, `Config path: ${configPath}`);
+    expect(logSpy).nthCalledWith(2);
+    expect(logSpy).nthCalledWith(3, `key: ${key}, value: ${value}`);
+
+    logSpy.mockRestore();
+    readJSONSyncMocked.mockReset();
+  });
+
+  it('should warn when getting config without args value', async () => {
+    const logSpy = jest.spyOn(console, 'log');
+    logSpy.mockImplementation(() => {});
+
+    await runConfig(appPath, { args: ['set', 'k'] });
+
+    expect(logSpy).toBeCalledWith('Usage: taro config set <key> <value>');
+    logSpy.mockRestore();
+  });
+
+  it('should set config', async () => {
+    const key = 'k';
+    const value = 'v';
+    const configPath = path.join('/', `${TARO_CONFIG_FOLDER}/${TARO_BASE_CONFIG}`);
+
+    const logSpy = jest.spyOn(console, 'log');
+    logSpy.mockImplementation(() => {});
+    readJSONSyncMocked.mockReturnValue({ a: 1 });
+
+    await runConfig(appPath, { args: ['set', key, value] });
+
+    expect(writeJSONSyncMocked).toBeCalledWith(configPath, {
+      a: 1,
+      [key]: value,
+    });
+    expect(logSpy).nthCalledWith(1, `Config path: ${configPath}`);
+    expect(logSpy).nthCalledWith(2);
+    expect(logSpy).nthCalledWith(3, `set key: ${key}, value: ${value}`);
+
+    logSpy.mockRestore();
+    readJSONSyncMocked.mockReset();
+    writeJSONSyncMocked.mockClear();
+  });
+
+  it('should set config with init', async () => {
+    const key = 'k';
+    const value = 'v';
+    const configPath = path.join('/', `${TARO_CONFIG_FOLDER}/${TARO_BASE_CONFIG}`);
+
+    const logSpy = jest.spyOn(console, 'log');
+    logSpy.mockImplementation(() => {});
+    existsSyncMocked.mockReturnValue(false);
+
+    await runConfig(appPath, { args: ['set', key, value] });
+
+    expect(ensureFileSyncMocked).toBeCalledWith(configPath);
+    expect(writeJSONSyncMocked).toBeCalledWith(configPath, { [key]: value });
+    expect(logSpy).toBeCalledWith(`set key: ${key}, value: ${value}`);
+
+    logSpy.mockRestore();
+    existsSyncMocked.mockReset();
+    ensureFileSyncMocked.mockClear();
+    writeJSONSyncMocked.mockClear();
+  });
+
+  it('should warn when deleting config without args key', async () => {
+    const logSpy = jest.spyOn(console, 'log');
+    logSpy.mockImplementation(() => {});
+
+    await runConfig(appPath, { args: ['delete'] });
+
+    expect(logSpy).toBeCalledWith('Usage: taro config delete <key>');
+    logSpy.mockRestore();
+  });
+
+  it('should delete config', async () => {
+    const key = 'k';
+    const configPath = path.join('/', `${TARO_CONFIG_FOLDER}/${TARO_BASE_CONFIG}`);
+
+    const logSpy = jest.spyOn(console, 'log');
+    logSpy.mockImplementation(() => {});
+    readJSONSyncMocked.mockReturnValue({
+      a: 1,
+      [key]: 'v',
+    });
+
+    await runConfig(appPath, { args: ['delete', key] });
+
+    expect(writeJSONSyncMocked).toBeCalledWith(configPath, { a: 1 });
+    expect(logSpy).nthCalledWith(1, `Config path: ${configPath}`);
+    expect(logSpy).nthCalledWith(2);
+    expect(logSpy).nthCalledWith(3, `deleted: ${key}`);
+
+    logSpy.mockRestore();
+    readJSONSyncMocked.mockReset();
+    writeJSONSyncMocked.mockClear();
+  });
+
+  it('should list config', async () => {
+    const configPath = path.join('/', `${TARO_CONFIG_FOLDER}/${TARO_BASE_CONFIG}`);
+    const logSpy = jest.spyOn(console, 'log');
+    logSpy.mockImplementation(() => {});
+    readJSONSyncMocked.mockReturnValue({
+      a: 1,
+      b: 2,
+    });
+
+    await runConfig(appPath, { args: ['list'] });
+
+    expect(logSpy).nthCalledWith(1, `Config path: ${configPath}`);
+    expect(logSpy).nthCalledWith(2);
+    expect(logSpy).nthCalledWith(3, 'Config info:');
+    expect(logSpy).nthCalledWith(4, 'a=1');
+    expect(logSpy).nthCalledWith(5, 'b=2');
+
+    logSpy.mockRestore();
+    readJSONSyncMocked.mockReset();
+  });
+
+  it('should list config in json', async () => {
+    const configPath = path.join('/', `${TARO_CONFIG_FOLDER}/${TARO_BASE_CONFIG}`);
+    const logSpy = jest.spyOn(console, 'log');
+    logSpy.mockImplementation(() => {});
+    readJSONSyncMocked.mockReturnValue({
+      a: 1,
+      b: 2,
+    });
+
+    await runConfig(appPath, {
+      args: ['list'],
+      options: {
+        json: true,
+      },
+    });
+
+    expect(logSpy).nthCalledWith(1, `Config path: ${configPath}`);
+    expect(logSpy).nthCalledWith(2);
+    expect(logSpy).nthCalledWith(3, 'Config info:');
+    expect(logSpy).nthCalledWith(4, JSON.stringify({ a: 1, b: 2 }, null, 2));
+
+    logSpy.mockRestore();
+    readJSONSyncMocked.mockReset();
+  });
+});