@liuli-util/cli 3.9.0 → 3.11.0

package/src/commands/esbuild/util/esbuildPlugins.ts

@@ -0,0 +1,82 @@
+import { Plugin } from 'esbuild'
+
+/**
+ * 处理 nodejs 原生模块
+ * @link https://github.com/evanw/esbuild/issues/1051#issuecomment-806325487
+ */
+export function nativeNodeModules(): Plugin {
+  return {
+    name: 'native-node-modules',
+    setup(build) {
+      // If a ".node" file is imported within a module in the "file" namespace, resolve
+      // it to an absolute path and put it into the "node-file" virtual namespace.
+      build.onResolve({ filter: /\.node$/, namespace: 'file' }, (args) => ({
+        path: require.resolve(args.path, { paths: [args.resolveDir] }),
+        namespace: 'node-file',
+      }))
+
+      // Files in the "node-file" virtual namespace call "require()" on the
+      // path from esbuild of the ".node" file in the output directory.
+      build.onLoad({ filter: /.*/, namespace: 'node-file' }, (args) => ({
+        contents: `
+        import path from ${JSON.stringify(args.path)}
+        try { module.exports = require(path) }
+        catch {}
+      `,
+      }))
+
+      // If a ".node" file is imported within a module in the "node-file" namespace, put
+      // it in the "file" namespace where esbuild's default loading behavior will handle
+      // it. It is already an absolute path since we resolved it to one above.
+      build.onResolve(
+        { filter: /\.node$/, namespace: 'node-file' },
+        (args) => ({
+          path: args.path,
+          namespace: 'file',
+        }),
+      )
+
+      // Tell esbuild's default loading behavior to use the "file" loader for
+      // these ".node" files.
+      const opts = build.initialOptions
+      opts.loader = opts.loader || {}
+      opts.loader['.node'] = 'file'
+    },
+  }
+}
+
+/**
+ * 排除和替换 node 内置模块
+ */
+export function nodeExternals(): Plugin {
+  return {
+    name: 'esbuild-plugin-node-externals',
+    setup(build) {
+      build.onResolve({ filter: /(^node:)/ }, (args) => ({
+        path: args.path.slice(5),
+        external: true,
+      }))
+    },
+  }
+}
+
+/**
+ * 自动排除所有依赖项
+ * golang 不支持 js 的一些语法，参考 https://github.com/evanw/esbuild/issues/1634
+ */
+export function autoExternal(): Plugin {
+  return {
+    name: 'esbuild-plugin-auto-external',
+    setup(build) {
+      build.onResolve({ filter: /.*/ }, (args) => {
+        if (/^\.{1,2}\//.test(args.path)) {
+          return
+        }
+        return {
+          path: args.path,
+          external: true,
+        }
+      })
+    },
+  }
+}

package/src/commands/generate/GenerateProgram.ts

@@ -0,0 +1,115 @@
+import path from 'path'
+import {
+  copy,
+  pathExists,
+  readdir,
+  readFile,
+  readJSON,
+  remove,
+  writeFile,
+  writeJSON,
+} from 'fs-extra'
+import { prompt } from 'enquirer'
+import { SyncProgram } from '../sync/SyncProgram'
+import { PathUtil } from '../../PathUtil'
+
+export enum TemplateTypeEnum {
+  Cli = 'cli',
+  Lib = 'lib',
+}
+
+export interface GenerateConfig {
+  template: TemplateTypeEnum
+  dest: string
+  initSync?: boolean
+}
+
+export class GenerateProgram {
+  /**
+   * 生成项目
+   */
+  async generate(config: GenerateConfig): Promise<void> {
+    if (!config.dest) {
+      const { dest } = await prompt<{ dest: string }>({
+        name: 'dest',
+        type: 'input',
+        message: '请输入项目名',
+        validate(input: string): boolean {
+          return input.trim() !== ''
+        },
+      })
+      config.dest = path.resolve(dest)
+    }
+    if (!config.template) {
+      const { template } = await prompt<{ template: TemplateTypeEnum }>({
+        name: 'template',
+        type: 'list',
+        message: '请选择模板',
+        choices: [
+          TemplateTypeEnum.Lib,
+          TemplateTypeEnum.Cli,
+        ] as TemplateTypeEnum[],
+      })
+      config.template = template
+    }
+
+    /*
+    克隆项目
+    修改一些内容
+    共通修改
+      - 修改 package.json，删除 private，修改名字
+    模板特定修改
+     */
+    const srcFile = path.resolve(
+      PathUtil.RootPath,
+      `templates/${config.template}`,
+    )
+    const destFile = path.resolve(config.dest)
+    if (
+      (await pathExists(destFile)) &&
+      (await readdir(destFile)).some((file) => pathExists(file))
+    ) {
+      const { override } = await prompt<{
+        override: boolean
+      }>({
+        name: 'override',
+        type: 'confirm',
+        initial: true,
+        message: '目标位置不是一个空目录，确认要覆盖么？',
+      })
+      if (!override) {
+        return
+      }
+    }
+    await remove(destFile)
+    await copy(srcFile, destFile)
+    await GenerateProgram.updatePackageJSON(destFile)
+    await GenerateProgram.updateReadme(destFile)
+    if (config.initSync) {
+      const syncProgram = new SyncProgram(path.resolve(config.dest))
+      await syncProgram.init()
+      await syncProgram.sync()
+    }
+  }
+
+  static async updatePackageJSON(destFile: string): Promise<void> {
+    const pkgPath = path.resolve(destFile, 'package.json')
+    await writeJSON(
+      pkgPath,
+      {
+        ...(await readJSON(pkgPath)),
+        name: path.basename(destFile),
+      },
+      {
+        spaces: 2,
+      },
+    )
+  }
+
+  static async updateReadme(destFile: string): Promise<void> {
+    const readmePath = path.resolve(destFile, 'README.md')
+    let readmeFile = await readFile(readmePath, 'utf-8')
+    readmeFile = readmeFile.replace('template', path.basename(destFile))
+    await writeFile(readmePath, readmeFile)
+  }
+}

package/src/commands/generate/__tests__/GenerateProgram.test.ts

@@ -0,0 +1,51 @@
+import { GenerateProgram, TemplateTypeEnum } from '../GenerateProgram'
+import path from 'path'
+import {
+  mkdir,
+  pathExists,
+  readFile,
+  readJson,
+  remove,
+  writeFile,
+  writeJson,
+} from 'fs-extra'
+import { PackageJson } from 'type-fest'
+
+describe('测试 InitProgram', () => {
+  const initProgram = new GenerateProgram()
+  const tempPath = path.resolve(__dirname, 'temp')
+  it('生成项目', async () => {
+    const dest = path.resolve(tempPath, 'lib-demo')
+    await remove(dest)
+    await initProgram.generate({
+      template: TemplateTypeEnum.Lib,
+      dest,
+    })
+    expect(await pathExists(dest)).toBeTruthy()
+  }, 100_000)
+  describe('测试一些钩子', () => {
+    beforeAll(async () => {
+      await remove(tempPath)
+      await mkdir(tempPath)
+    })
+    it('测试修改 package.json', async () => {
+      const jsonPath = path.resolve(tempPath, 'package.json')
+      await writeJson(jsonPath, {
+        name: '@liuli-util/template',
+      })
+      await GenerateProgram.updatePackageJSON(tempPath)
+      expect(
+        ((await readJson(jsonPath)) as PackageJson).name?.endsWith('temp'),
+      ).toBeTruthy()
+    })
+    it('测试修改 readme', async () => {
+      const readmePath = path.resolve(tempPath, 'README.md')
+      await writeFile(readmePath, `# @liuli-util/template`)
+      await GenerateProgram.updateReadme(tempPath)
+      console.log('readme: ', await readFile(readmePath, 'utf-8'))
+      expect(
+        (await readFile(readmePath, 'utf-8')).endsWith('temp'),
+      ).toBeTruthy()
+    })
+  })
+})

package/src/commands/generate/index.ts

@@ -0,0 +1,26 @@
+import { Command, Option } from 'commander'
+import {
+  GenerateConfig,
+  GenerateProgram,
+  TemplateTypeEnum,
+} from './GenerateProgram'
+
+const generateProgram = new GenerateProgram()
+
+const templateOption = new Option('--template [template]', '模板类型').choices([
+  TemplateTypeEnum.Lib,
+  TemplateTypeEnum.Cli,
+])
+templateOption.required = true
+
+export const generateCommand = new Command()
+  .command('generate [dest]')
+  .description('生成一些初始项目')
+  .addOption(templateOption)
+  .action(async (dest, options: Pick<GenerateConfig, 'template'>) => {
+    await generateProgram.generate({
+      ...options,
+      dest: dest,
+      initSync: true,
+    })
+  })

package/src/commands/sync/SyncProgram.ts

@@ -0,0 +1,247 @@
+import { readFile, readJson, writeFile, writeJson } from 'fs-extra'
+import path from 'path'
+import { merge } from 'lodash-es'
+import { PackageJson } from 'type-fest'
+import prettier from '@liuli-util/prettier-standard-config/package.json'
+import eslintTs from '@liuli-util/eslint-config-ts/package.json'
+import eslintReactTs from '@liuli-util/eslint-config-react-ts/package.json'
+import commitlint from '@liuli-util/commitlint-standard-config/package.json'
+import { prompt } from 'enquirer'
+import { isIncludeDep, isNpmPackage, isYarnRoot, isYarnSubModule } from './when'
+import { appendScript, arrayToMap, AsyncArray } from '../../utils'
+import { PathUtil } from '../../PathUtil'
+
+export async function mergeJson(base: string, json: object): Promise<void> {
+  const pkgJsonFilePath = path.resolve(base, './package.json')
+  await writeJson(
+    pkgJsonFilePath,
+    merge(await readJson(pkgJsonFilePath), json),
+    {
+      spaces: 2,
+    },
+  )
+}
+
+export type SyncConfigType =
+  | 'prettier'
+  | 'commitlint'
+  | 'simplehooks'
+  | 'workspaces'
+  | 'gitignore'
+  | 'eslint-ts'
+  | 'eslint-vue-ts'
+  | 'eslint-react-ts'
+  | 'jest'
+
+export interface SyncConfig {
+  type: SyncConfigType
+  handler(): Promise<void>
+  when?(): Promise<boolean>
+}
+
+export class SyncProgram {
+  constructor(private readonly base: string) {}
+  private syncConfigs: SyncConfig[] = [
+    {
+      type: 'workspaces',
+      handler: async () => {
+        const pkgPath = path.resolve(this.base, './package.json')
+        const lernaPath = path.resolve(this.base, 'lerna.json')
+        const pkgJson = (await readJson(pkgPath)) as { workspaces: string[] }
+        const lernaJson = await readJson(lernaPath)
+        lernaJson.packages = pkgJson.workspaces
+        await writeJson(lernaPath, lernaJson, {
+          spaces: 2,
+        })
+      },
+      when: isYarnRoot,
+    },
+    {
+      type: 'prettier',
+      handler: async () => {
+        await mergeJson(this.base, {
+          prettier: '@liuli-util/prettier-standard-config',
+          devDependencies: {
+            prettier: '^2.3.2',
+            '@liuli-util/prettier-standard-config': `^${prettier.version}`,
+          },
+        } as PackageJson)
+      },
+      async when(): Promise<boolean> {
+        return (
+          (await isNpmPackage()) &&
+          ((await isYarnRoot()) || !(await isYarnSubModule()))
+        )
+      },
+    },
+    {
+      type: 'commitlint',
+      handler: async () => {
+        await mergeJson(this.base, {
+          'simple-git-hooks': {
+            'commit-msg': 'yarn commitlint --edit $1',
+          },
+          commitlint: {
+            extends: ['@liuli-util/commitlint-standard-config'],
+          },
+          devDependencies: {
+            '@commitlint/cli': '^12.1.4',
+            '@liuli-util/commitlint-standard-config': `^${commitlint.version}`,
+          },
+        } as PackageJson)
+      },
+      async when(): Promise<boolean> {
+        return (
+          (await isNpmPackage()) &&
+          ((await isYarnRoot()) || !(await isYarnSubModule()))
+        )
+      },
+    },
+    {
+      type: 'gitignore',
+      handler: async () => {
+        const gitignorePath = path.resolve(this.base, '.gitignore')
+        await writeFile(
+          gitignorePath,
+          await readFile(
+            path.resolve(PathUtil.RootPath, '_gitignore'),
+            'utf-8',
+          ),
+        )
+      },
+    },
+    {
+      type: 'eslint-ts',
+      handler: async () => {
+        await mergeJson(this.base, {
+          eslintConfig: {
+            extends: ['@liuli-util/eslint-config-ts'],
+          },
+          devDependencies: {
+            '@liuli-util/eslint-config-ts': `^${eslintTs.version}`,
+          },
+        } as PackageJson)
+      },
+      async when(): Promise<boolean> {
+        return (
+          (await isNpmPackage()) &&
+          !(await isIncludeDep(['vue'])) &&
+          !(await isIncludeDep(['react']))
+        )
+      },
+    },
+    {
+      type: 'eslint-react-ts',
+      handler: async () => {
+        await mergeJson(this.base, {
+          eslintConfig: {
+            extends: ['@liuli-util/eslint-config-react-ts'],
+          },
+          devDependencies: {
+            '@liuli-util/eslint-config-react-ts': `^${eslintReactTs.version}`,
+          },
+        } as PackageJson)
+      },
+      async when(): Promise<boolean> {
+        return (await isNpmPackage()) && (await isIncludeDep(['react']))
+      },
+    },
+    {
+      type: 'jest',
+      handler: async () => {
+        await mergeJson(this.base, {
+          jest: {
+            preset: 'ts-jest',
+            testMatch: ['<rootDir>/src/**/__tests__/*.test.ts'],
+          },
+        })
+      },
+    },
+    //必须放到最后一个，后续根据检测结果添加 hooks
+    {
+      type: 'simplehooks',
+      handler: async () => {
+        const json = await readJson(path.resolve(this.base, './package.json'))
+        const lintStaged: string[] = []
+        if (json.prettier) {
+          lintStaged.push('prettier --write')
+        }
+        if (json.eslintConfig) {
+          lintStaged.push('eslint --fix')
+        }
+        let config = {
+          scripts: {
+            postinstall: appendScript(
+              json?.scripts?.postinstall,
+              'npx simple-git-hooks',
+            ),
+          },
+          'simple-git-hooks': {
+            'pre-commit': 'yarn lint-staged',
+          },
+          'lint-staged': {
+            '*.{ts,tsx,js,jsx,css,vue}': [...lintStaged, 'git add'],
+          },
+          devDependencies: {
+            'simple-git-hooks': '^2.5.1',
+            'lint-staged': '^11.1.1',
+          },
+        }
+        if (json.commitlint) {
+          config = merge(config, {
+            'simple-git-hooks': {
+              'commit-msg': 'yarn commitlint --edit $1',
+            },
+          })
+        }
+        await mergeJson(this.base, config as PackageJson)
+      },
+      async when(): Promise<boolean> {
+        return (
+          (await isNpmPackage()) &&
+          ((await isYarnRoot()) || !(await isYarnSubModule()))
+        )
+      },
+    },
+  ]
+
+  async sync(): Promise<void> {
+    const { sync } = (await readJson(
+      path.resolve(this.base, 'package.json'),
+    )) as {
+      sync?: SyncConfigType[]
+    }
+    if (!sync) {
+      return
+    }
+    const syncConfigs = this.syncConfigs.filter((config) =>
+      sync.includes(config.type),
+    )
+    for (const syncConfig of syncConfigs) {
+      await syncConfig.handler()
+    }
+  }
+
+  async init(): Promise<void> {
+    const configMap = arrayToMap(
+      await AsyncArray.filter(this.syncConfigs, async (config) => {
+        if (!config.when) {
+          return true
+        }
+        return await config.when()
+      }),
+      (item) => item.type,
+    )
+    const res = await prompt<{
+      sync: string[]
+    }>({
+      type: 'multiselect',
+      message: '请选择需要同步的配置项',
+      name: 'sync',
+      choices: [...configMap.keys()],
+    })
+    await mergeJson(this.base, {
+      sync: res.sync,
+    })
+  }
+}

package/src/commands/sync/__tests__/SyncProgram.test.ts

@@ -0,0 +1,50 @@
+import { mkdir, readJson, remove, writeJson } from 'fs-extra'
+import path from 'path'
+import { SyncConfigType, SyncProgram } from '../SyncProgram'
+import { merge } from 'lodash-es'
+import { PackageJson } from 'type-fest'
+
+describe('测试 SyncProgram', () => {
+  const tempPath = path.resolve(__dirname, 'temp')
+  const syncProgram = new SyncProgram(tempPath)
+  beforeEach(async () => {
+    await remove(tempPath)
+    await mkdir(tempPath)
+  })
+  it('测试 sync', async () => {
+    const workspaces = ['packages/common/*', 'apps/*']
+    await writeJson(path.resolve(tempPath, 'lerna.json'), {})
+    await writeJson(path.resolve(tempPath, 'package.json'), {
+      name: 'temp',
+      license: 'mit',
+      private: true,
+      sync: [
+        'prettier',
+        'commitlint',
+        'workspaces',
+        'gitignore',
+        'simplehooks',
+        'eslint-ts',
+        'jest',
+      ] as SyncConfigType[],
+      workspaces,
+    } as PackageJson)
+    await syncProgram.sync()
+  }, 100_000)
+
+  it('测试初始化同步配置', async () => {
+    await writeJson(path.resolve(tempPath, 'lerna.json'), {})
+    const file = path.resolve(tempPath, 'package.json')
+    await writeJson(file, {
+      name: 'temp',
+      private: true,
+    } as PackageJson)
+    await syncProgram.init()
+    expect(((await readJson(file)).sync as string[]).length).toBeGreaterThan(0)
+  }, 100_000)
+})
+
+it('测试 lodash-es.merge', () => {
+  const res = merge({ arr: ['a'] }, { arr: ['b'] })
+  expect(res).toEqual({ arr: ['b'] })
+})

package/src/commands/sync/__tests__/when.test.ts

@@ -0,0 +1,46 @@
+import {
+  isIncludeDep,
+  isNpmPackage,
+  isYarnRoot,
+  isYarnSubModule,
+} from '../when'
+import { pathExists, readJson } from 'fs-extra'
+import { PackageJson } from 'type-fest'
+import path from 'path'
+import { findParent } from '../../../utils'
+
+describe('测试 when', () => {
+  let rootPath: string
+  let subModulePath: string
+  beforeAll(async () => {
+    rootPath = (await findParent(__dirname, async (dir) => {
+      const jsonPath = path.resolve(dir, 'package.json')
+      return (
+        (await pathExists(jsonPath)) &&
+        !!((await readJson(jsonPath)) as PackageJson).workspaces
+      )
+    }))!
+    subModulePath = (await findParent(__dirname, async (dir) =>
+      pathExists(path.join(dir, 'package.json')),
+    ))!
+  })
+  it('测试 isNpmPackage', async () => {
+    expect(await isNpmPackage(subModulePath)).toBeTruthy()
+    expect(await isNpmPackage(rootPath)).toBeTruthy()
+    expect(await isNpmPackage(__dirname)).toBeFalsy()
+  })
+  it('测试 isYarnRoot', async () => {
+    expect(await isYarnRoot(rootPath)).toBeTruthy()
+    expect(await isYarnRoot(subModulePath)).toBeFalsy()
+  })
+  it('测试 isYarnSubModule', async () => {
+    expect(await isYarnSubModule(subModulePath)).toBeTruthy()
+    expect(await isYarnSubModule(rootPath)).toBeFalsy()
+    expect(await isYarnSubModule(__dirname)).toBeFalsy()
+  })
+  it('测试 isIncludeDep', async () => {
+    expect(
+      await isIncludeDep(['vue'], path.resolve(__dirname, 'temp')),
+    ).toBeFalsy()
+  })
+})

package/src/commands/sync/index.ts

@@ -0,0 +1,15 @@
+import { Command } from 'commander'
+import { SyncProgram } from './SyncProgram'
+
+const syncProgram = new SyncProgram(process.cwd())
+export const syncCommand = new Command('sync')
+  .description('同步配置')
+  .action(async () => {
+    await syncProgram.sync()
+  })
+  .addCommand(
+    new Command('init').description('初始化同步配置').action(async () => {
+      await syncProgram.init()
+      await syncProgram.sync()
+    }),
+  )

package/src/commands/sync/when.ts

@@ -0,0 +1,67 @@
+import { pathExists, readJson } from 'fs-extra'
+import path from 'path'
+import { PackageJson } from 'type-fest'
+import { findParent } from '../../utils'
+
+/**
+ * 判断是否包含 package.json
+ * @param cwd
+ */
+export async function isNpmPackage(
+  cwd: string = process.cwd(),
+): Promise<boolean> {
+  return await pathExists(path.resolve(cwd, './package.json'))
+}
+
+/**
+ * 判断是 yarn2 monorepo 项目
+ * @param cwd
+ */
+export async function isYarnRoot(
+  cwd: string = process.cwd(),
+): Promise<boolean> {
+  if (!(await isNpmPackage(cwd))) {
+    return false
+  }
+  const json = (await readJson(
+    path.resolve(cwd, './package.json'),
+  )) as PackageJson
+  return !!json.workspaces
+}
+
+/**
+ * 判断是 yarn2 monorepo 的子模块
+ */
+export async function isYarnSubModule(
+  cwd: string = process.cwd(),
+): Promise<boolean> {
+  if (!(await isNpmPackage(cwd))) {
+    return false
+  }
+  //如果是 yarn monorepo 根模块则直接返回 true
+  if (await isYarnRoot(cwd)) {
+    return false
+  }
+  return (await findParent(path.dirname(cwd), isYarnRoot)) !== null
+}
+
+/**
+ * 是否包含指定依赖
+ * @param deps
+ * @param cwd
+ */
+export async function isIncludeDep(
+  deps: string[],
+  cwd: string = process.cwd(),
+): Promise<boolean> {
+  if (!(await isNpmPackage(cwd))) {
+    return false
+  }
+  const json = (await readJson(
+    path.resolve(cwd, './package.json'),
+  )) as PackageJson
+  const set = new Set(
+    Object.keys({ ...json.dependencies, ...json.devDependencies }),
+  )
+  return deps.every((dep) => set.has(dep))
+}