@liuli-util/cli 3.9.0 → 3.11.0

package/src/index.ts

@@ -1 +1,3 @@
-export {}
+export * from './commands/esbuild/ESBuildProgram'
+export * from './commands/generate/GenerateProgram'
+export * from './commands/sync/SyncProgram'

package/src/utils/AsyncArray.ts

@@ -0,0 +1,144 @@
+import { IterableElement } from 'type-fest'
+
+enum ActionTypeEnum {
+  Filter = 'filter',
+  Map = 'map',
+  ForEach = 'forEach',
+  Reduce = 'reduce',
+  FlatMap = 'flatMap',
+}
+
+class Action {
+  public static Type = ActionTypeEnum
+
+  constructor(
+    public readonly type: ActionTypeEnum,
+    public readonly args: any[],
+  ) {
+    this.type = type
+    this.args = args
+  }
+}
+
+/**
+ * 异步数组，支持静态方法和链式调用
+ */
+export class AsyncArray<T> implements PromiseLike<T[]> {
+  static reduce<T extends any[], R>(
+    arr: T,
+    fn: (res: R, item: IterableElement<T>, index: number) => Promise<R>,
+    res: R,
+  ): Promise<R> {
+    return arr.reduce(
+      (res: Promise<R>, item: IterableElement<T>, index: number) =>
+        res.then((r) => fn(r, item, index)),
+      Promise.resolve(res),
+    )
+  }
+
+  static map<T, R>(
+    arr: T[],
+    fn: (item: T, index: number) => Promise<R>,
+  ): Promise<R[]> {
+    return Promise.all(arr.map((item, index) => fn(item, index)))
+  }
+
+  static async filter<T>(
+    arr: T[],
+    fn: (item: T, index: number) => Promise<boolean>,
+  ): Promise<T[]> {
+    const res: T[] = []
+    await AsyncArray.map(arr, async (item, index) => {
+      if (await fn(item, index)) {
+        res.push(item)
+      }
+    })
+    return res
+  }
+
+  static async flatMap<T, R>(
+    arr: T[],
+    fn: (item: T, index: number) => Promise<R[]>,
+  ): Promise<R[]> {
+    return (
+      await Promise.all(arr.map((item, index) => fn(item, index)))
+    ).flatMap((r) => r)
+  }
+
+  static async forEach<T extends any[]>(
+    arr: T,
+    fn: (item: IterableElement<T>, index: number) => Promise<void>,
+  ): Promise<void> {
+    await AsyncArray.map(arr, fn)
+  }
+
+  private tasks: Action[] = []
+
+  constructor(private readonly arr: T[]) {}
+
+  map<R>(fn: (item: T, index: number) => Promise<R>): AsyncArray<R> {
+    this.tasks.push(new Action(ActionTypeEnum.Map, [fn]))
+    return this as any
+  }
+
+  flatMap<R>(fn: (item: T, index: number) => Promise<R[]>): AsyncArray<R> {
+    this.tasks.push(new Action(ActionTypeEnum.FlatMap, [fn]))
+    return this as any
+  }
+
+  filter(fn: (item: T, index: number) => Promise<boolean>): this {
+    this.tasks.push(new Action(ActionTypeEnum.Filter, [fn]))
+    return this
+  }
+
+  async forEach<R>(fn: (item: T, index: number) => Promise<R>): Promise<void> {
+    this.tasks.push(new Action(ActionTypeEnum.Map, [fn]))
+    await this
+  }
+
+  then<TResult1 = T[], TResult2 = never>(
+    resolve?:
+      | ((value: T[]) => PromiseLike<TResult1> | TResult1)
+      | undefined
+      | null,
+    reject?:
+      | ((reason: any) => PromiseLike<TResult2> | TResult2)
+      | undefined
+      | null,
+  ): PromiseLike<TResult1 | TResult2> {
+    const res = this.value()
+    res
+      .then((r) => {
+        resolve && resolve(res as any)
+        return r
+      })
+      .catch((e) => {
+        reject && reject(e as any)
+        throw e
+      })
+    return res as any
+  }
+
+  private async value(): Promise<any> {
+    let res = this.arr
+    for (const task of this.tasks) {
+      switch (task.type) {
+        case ActionTypeEnum.Filter:
+          res = await AsyncArray.filter(res, task.args[0])
+          break
+        case ActionTypeEnum.Map:
+          res = await AsyncArray.map(res, task.args[0])
+          break
+        case ActionTypeEnum.FlatMap:
+          res = await AsyncArray.flatMap(res, task.args[0])
+          break
+        case ActionTypeEnum.ForEach:
+          await AsyncArray.forEach(res, task.args[0])
+          return
+        case ActionTypeEnum.Reduce:
+          return await AsyncArray.reduce(res, task.args[0], task.args[1])
+      }
+    }
+    return res
+  }
+}

package/src/utils/__tests__/appendScript.test.ts

@@ -0,0 +1,15 @@
+import { appendScript } from '../appendScript'
+
+describe('测试 appendScript', () => {
+  const newScript = 'liuli-cli sync'
+  it('脚本不存在', () => {
+    expect(appendScript(undefined, newScript)).toBe(newScript)
+  })
+  it('脚本存在但不包含新的脚本', () => {
+    expect(appendScript('tsc', newScript)).toBe('tsc && ' + newScript)
+  })
+  it('脚本存在且包含新的脚本', () => {
+    const oldScript = `${newScript} && tsc`
+    expect(appendScript(oldScript, newScript)).toBe(oldScript)
+  })
+})

package/src/utils/__tests__/arrayToMap.test.ts

@@ -0,0 +1,37 @@
+import { arrayToMap } from '../arrayToMap'
+
+/**
+ * @test {arrayToMap}
+ */
+describe('test arrayToMap', () => {
+  it('arrayToMap [1, 2, 3] to equals Map({1 => 1, 2 => 2, 3 => 3})', () => {
+    const arr = [1, 2, 3]
+    expect(arrayToMap(arr, (i: any) => i)).toEqual(
+      new Map().set(1, 1).set(2, 2).set(3, 3),
+    )
+  })
+  it('use vFn', () => {
+    const arr = [1, 2, 3]
+    expect(
+      arrayToMap(
+        arr,
+        (v) => v,
+        (i) => i * 2 + '',
+      ),
+    ).toEqual(new Map().set(1, '2').set(2, '4').set(3, '6'))
+  })
+  it('use string k/v field', () => {
+    class User {
+      constructor(public id: number, public name: string) {}
+    }
+
+    const arr = [new User(1, 'rx'), new User(2, '琉璃'), new User(3, '楚轩')]
+    expect(
+      arrayToMap(
+        arr,
+        (item) => item.id,
+        (item) => item.name,
+      ),
+    ).toEqual(new Map().set(1, 'rx').set(2, '琉璃').set(3, '楚轩'))
+  })
+})

package/src/utils/__tests__/findParent.test.ts

@@ -0,0 +1,15 @@
+import { findParent } from '../findParent'
+import { mkdir, remove } from 'fs-extra'
+import path from 'path'
+
+describe('测试 findParent', () => {
+  it('基本示例', async () => {
+    const tempPath = path.resolve(__dirname, 'temp')
+    await mkdir(tempPath)
+    expect(findParent(tempPath, (dir) => dir === __dirname)).toBe(__dirname)
+    await remove(tempPath)
+  })
+  it('测试找不到的情况', () => {
+    expect(findParent(__dirname, () => false)).toBeNull()
+  })
+})

package/src/utils/appendScript.ts

@@ -0,0 +1,17 @@
+/**
+ * 在之前的脚本中追加新的脚本
+ * @param oldScript
+ * @param newScript
+ */
+export function appendScript(
+  oldScript: string | undefined,
+  newScript: string,
+): string {
+  if (!oldScript) {
+    return newScript
+  }
+  if (oldScript.includes(newScript)) {
+    return oldScript
+  }
+  return oldScript + ' && ' + newScript
+}

package/src/utils/arrayToMap.ts

@@ -0,0 +1,27 @@
+export function arrayToMap<T, K>(
+  arr: T[],
+  kFn: (item: T, index: number, arr: T[]) => K,
+): Map<K, T>
+export function arrayToMap<T, K, V>(
+  arr: T[],
+  kFn: (item: T, index: number, arr: T[]) => K,
+  vFn: (item: T, index: number, arr: T[]) => V,
+): Map<K, V>
+/**
+ * 将数组映射为 Map
+ * @param arr 数组
+ * @param kFn 产生 Map 元素唯一标识的函数
+ * @param vFn 产生 Map 值的函数，默认为返回数组的元素
+ * @returns 映射产生的 map 集合
+ */
+export function arrayToMap<T, K, V>(
+  arr: T[],
+  kFn: (item: T, index: number, arr: T[]) => K,
+  vFn: (item: T, index: number, arr: T[]) => V = (v) => v as any,
+): Map<K, V> {
+  return arr.reduce(
+    (res, item, index, arr) =>
+      res.set(kFn(item, index, arr), vFn(item, index, arr)),
+    new Map<K, V>(),
+  )
+}

package/src/utils/findParent.ts

@@ -0,0 +1,36 @@
+import path from 'path'
+
+/**
+ * 向上查找目录
+ * @param cwd
+ * @param predicate
+ */
+export function findParent(
+  cwd: string,
+  predicate: (dir: string) => boolean,
+): string | null
+export function findParent(
+  cwd: string,
+  predicate: (dir: string) => Promise<boolean>,
+): Promise<string | null>
+export function findParent<
+  T extends (dir: string) => boolean | Promise<boolean>,
+  R extends string | null,
+>(
+  cwd: string,
+  predicate: T,
+): ReturnType<T> extends Promise<any> ? Promise<R> : R {
+  const res = predicate(cwd)
+  function f(res: boolean): string | null {
+    if (res) {
+      return cwd
+    }
+    const parent = path.dirname(cwd)
+    if (parent === cwd) {
+      return null
+    }
+    return findParent(parent, predicate as any)
+  }
+
+  return res instanceof Promise ? res.then(f) : (f(res) as any)
+}

package/src/utils/index.ts

@@ -0,0 +1,4 @@
+export * from './arrayToMap'
+export * from './appendScript'
+export * from './findParent'
+export * from './AsyncArray'

package/templates/cli/CHANGELOG.md

@@ -0,0 +1 @@
+# CHANGELOG

package/templates/cli/README.md

@@ -0,0 +1 @@
+# @liuli-util/cli-template

package/templates/cli/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@liuli-util/cli-template",
+  "version": "0.1.0",
+  "main": "dist/index.js",
+  "module": "dist/index.esm.js",
+  "types": "dist/index.d.ts",
+  "license": "MIT",
+  "scripts": {
+    "build": "rimraf dist && liuli-cli build cli",
+    "dev": "liuli-cli build cli -w",
+    "start": "esno src/bin.ts",
+    "docs:server": "live-server docs",
+    "docs:dev": "typedoc --watch",
+    "docs:build": "rimraf docs && typedoc",
+    "docs:deploy": "yarn docs:build && gh-pages -d docs/ -e / -a"
+  },
+  "bin": {
+    "cli-name": "dist/bin.js"
+  },
+  "jest": {
+    "preset": "ts-jest"
+  },
+  "dependencies": {
+    "commander": "^8.2.0",
+    "fs-extra": "^10.0.0",
+    "inquirer": "^8.1.5"
+  },
+  "devDependencies": {
+    "@liuli-util/cli": "^3.11.0",
+    "@types/fs-extra": "^9.0.13",
+    "@types/inquirer": "^8.1.2",
+    "@types/jest": "^27.0.2",
+    "@types/lodash": "^4.14.173",
+    "@types/node": "^16.9.6",
+    "esno": "^0.9.1",
+    "gh-pages": "^3.2.3",
+    "jest": "^27.2.1",
+    "rimraf": "^3.0.2",
+    "ts-jest": "^27.0.5",
+    "type-fest": "^2.3.4",
+    "typedoc": "^0.22.4",
+    "typescript": "^4.4.3"
+  }
+}

package/templates/cli/src/bin.ts

@@ -0,0 +1,13 @@
+import { Command } from 'commander'
+import { prompt } from 'inquirer'
+
+new Command()
+  .action(async () => {
+    const { name } = await prompt<{ name: string }>({
+      type: 'input',
+      name: 'name',
+      message: '请输入名字',
+    })
+    console.log(`hello ${name}`)
+  })
+  .parse()

package/templates/cli/src/index.ts

@@ -0,0 +1 @@
+export {}

package/templates/cli/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "lib": [
+      "ESNext"
+    ],
+    "outDir": "./dist",
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "strict": true,
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true
+  },
+  "include": [
+    "src"
+  ],
+  "typedocOptions": {
+    "entryPoints": [
+      "src/index.ts"
+    ],
+    "out": "docs",
+    "readme": "README.md",
+    "gitRemote": "origin"
+  }
+}

package/templates/lib/CHANGELOG.md

@@ -0,0 +1 @@
+# CHANGELOG

package/templates/lib/README.md

@@ -0,0 +1 @@
+# @liuli-util/lib-template

package/templates/lib/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@liuli-util/lib-template",
+  "private": true,
+  "version": "0.1.0",
+  "main": "dist/index.js",
+  "module": "dist/index.esm.js",
+  "types": "dist/index.d.ts",
+  "license": "MIT",
+  "scripts": {
+    "build": "rimraf dist && liuli-cli build pkg",
+    "dev": "liuli-cli build pkg -w",
+    "docs:server": "live-server docs",
+    "docs:dev": "typedoc --watch",
+    "docs:build": "rimraf docs && typedoc",
+    "docs:deploy": "yarn docs:build && gh-pages -d docs/ -e / -a"
+  },
+  "jest": {
+    "preset": "ts-jest"
+  },
+  "devDependencies": {
+    "@liuli-util/cli": "^3.11.0",
+    "@types/jest": "^27.0.2",
+    "esno": "^0.9.1",
+    "gh-pages": "^3.2.3",
+    "jest": "^27.2.1",
+    "rimraf": "^3.0.2",
+    "ts-jest": "^27.0.5",
+    "type-fest": "^2.3.4",
+    "typedoc": "^0.22.4",
+    "typescript": "^4.4.3"
+  }
+}

package/templates/lib/src/__tests__/hello.test.ts

@@ -0,0 +1,5 @@
+import { hello } from '../index'
+
+it('测试 hello', () => {
+  expect(hello('liuli')).toBe('hello liuli')
+})

package/templates/lib/src/index.ts

@@ -0,0 +1,3 @@
+export function hello(name: string) {
+  return `hello ${name}`
+}

package/templates/lib/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "lib": [
+      "ESNext"
+    ],
+    "outDir": "./dist",
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "strict": true,
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true
+  },
+  "include": [
+    "src"
+  ],
+  "typedocOptions": {
+    "entryPoints": [
+      "src/index.ts"
+    ],
+    "out": "docs",
+    "readme": "README.md",
+    "gitRemote": "origin"
+  }
+}

package/tsconfig.json

@@ -1,28 +1,34 @@
-{
-  "compilerOptions": {
-    "target": "ES6",
-    "lib": ["ESNext"],
-    "outDir": "./dist",
-    "skipLibCheck": true,
-    "esModuleInterop": true,
-    "strict": true,
-    "module": "ESNext",
-    "moduleResolution": "node",
-    "sourceMap": true,
-    "declaration": true,
-    "declarationMap": true,
-    "resolveJsonModule": true
-  },
-  "include": ["src"],
-  "typedocOptions": {
-    "entryPoints": ["src/index.ts"],
-    "out": "docs",
-    "readme": "README.md",
-    "gitRemote": "origin"
-  },
-  "ts-node": {
-    "compilerOptions": {
-      "module": "CommonJS"
-    }
-  }
-}
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "lib": [
+      "ESNext"
+    ],
+    "outDir": "./dist",
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "strict": true,
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+    "resolveJsonModule": true
+  },
+  "include": [
+    "src"
+  ],
+  "typedocOptions": {
+    "entryPoints": [
+      "src/index.ts"
+    ],
+    "out": "docs",
+    "readme": "README.md",
+    "gitRemote": "origin"
+  },
+  "ts-node": {
+    "compilerOptions": {
+      "module": "CommonJS"
+    }
+  }
+}