jiek 0.4.6 → 0.4.7-alpha.1

package/package.json

@@ -1,60 +1,84 @@
 {
   "name": "jiek",
-  "version": "0.4.6",
+  "version": "0.4.7-alpha.1",
   "description": "YiJie's personal kits.",
   "bin": {
     "jiek": "bin/jiek.js",
     "jk": "bin/jiek.js"
   },
-  "jiek": {
-    "noBrowser": true
-  },
   "files": [
-    "dist"
+    "dist",
+    "src",
+    "bin",
+    "LICENSE",
+    "README.md"
   ],
+  "typesVersions": {
+    "<5.0": {
+      "*": [
+        "*",
+        "./dist/*",
+        "./dist/*/index.d.ts"
+      ]
+    }
+  },
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.esm.js",
-      "require": "./dist/index.cjs",
-      "inner-src": "./src/index.ts"
+      "source": "./src/index.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.js"
     },
     "./cli": {
-      "types": "./dist/cli.d.ts",
-      "import": "./dist/cli.esm.js",
-      "require": "./dist/cli.cjs",
-      "inner-src": "./src/cli.ts"
+      "source": "./src/cli.ts",
+      "import": "./dist/cli.mjs",
+      "default": "./dist/cli.js"
     },
     "./rollup": {
-      "types": "./dist/rollup.d.ts",
-      "import": "./dist/rollup.esm.js",
-      "require": "./dist/rollup.cjs",
-      "inner-src": "./src/rollup/index.ts"
+      "source": "./src/rollup/index.ts",
+      "import": "./dist/rollup/index.mjs",
+      "default": "./dist/rollup/index.js"
+    },
+    "./cli.js": {
+      "source": "./src/cli.ts",
+      "import": "./dist/cli.mjs",
+      "default": "./dist/cli.js"
+    },
+    "./rollup.js": {
+      "source": "./src/rollup/index.ts",
+      "import": "./dist/rollup/index.mjs",
+      "default": "./dist/rollup/index.js"
     }
   },
+  "imports": {
+    "#~/*": "./src/*"
+  },
   "dependencies": {
+    "@jiek/rollup-plugin-dts": "^6.1.1",
     "@rollup/plugin-json": "^6.0.1",
+    "@rollup/plugin-node-resolve": "^15.3.0",
     "@rollup/plugin-terser": "^0.4.4",
     "autoprefixer": "^10.4.16",
     "cli-progress": "^3.12.0",
     "commander": "^12.0.0",
     "detect-indent": "^6.1.0",
+    "execa": "9.3.1",
     "inquirer": "^8.2.6",
     "js-yaml": "^4.1.0",
     "jsonc-parser": "^3.2.1",
     "micromatch": "^4.0.5",
     "rollup": "^4.1.5",
     "rollup-plugin-copy": "^3.5.0",
-    "@jiek/rollup-plugin-dts": "^6.1.1",
     "rollup-plugin-esbuild": "^6.1.0",
-    "rollup-plugin-postcss": "^4.0.2",
-    "@jiek/pkger": "0.1.10",
-    "@jiek/utils": "0.2.0"
+    "typescript": "^5.0.0",
+    "@jiek/utils": "^0.2.0",
+    "@jiek/pkger": "^0.1.11"
   },
   "optionalDependencies": {
     "@pnpm/filter-workspace-packages": "^7.2.13",
-    "esbuild-register": "^3.5.0"
+    "esbuild-register": "^3.5.0",
+    "postcss": "^8.4.47",
+    "rollup-plugin-postcss": "^4.0.2"
   },
   "devDependencies": {
     "@npm/types": "^1.0.2",
@@ -64,18 +88,11 @@
     "@types/inquirer": "^9.0.7",
     "@types/js-yaml": "^4.0.9",
     "@types/micromatch": "^4.0.6",
-    "esbuild-register": "^3.5.0"
+    "esbuild-register": "^3.5.0",
+    "node-sass": "^9.0.0",
+    "postcss": "^8.4.47",
+    "rollup-plugin-postcss": "^4.0.2"
   },
-  "types": "./dist/index.d.ts",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.esm.js",
-  "typesVersions": {
-    "<5.0": {
-      "*": [
-        "*",
-        "./dist/*",
-        "./dist/*/index.esm.d.ts"
-      ]
-    }
-  }
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs"
 }

package/src/cli.ts

@@ -0,0 +1,9 @@
+import './utils/filterSupport'
+import './commands/base'
+import './commands/build'
+import './commands/init'
+import './commands/publish'
+
+import { program } from 'commander'
+
+program.parse(process.argv)

package/src/commands/base.ts

@@ -0,0 +1,9 @@
+import { program } from 'commander'
+
+import pkg from '../pkg'
+
+program
+  .version(pkg.version)
+  .description(pkg.description)
+  .option('--root <root>', 'root path')
+  .option('-c, --config-path <configPath>', 'config path')

package/src/commands/build.ts

@@ -0,0 +1,156 @@
+import '../rollup/base'
+
+import fs from 'node:fs'
+import path from 'node:path'
+
+import { MultiBar, Presets } from 'cli-progress'
+import { program } from 'commander'
+import { execaCommand } from 'execa'
+
+import { actionDone, actionRestore } from '../inner'
+import type { RollupProgressEvent } from '../rollup/base'
+import { getSelectedProjectsGraph } from '../utils/filterSupport'
+import { loadConfig } from '../utils/loadConfig'
+import { tsRegisterName } from '../utils/tsRegister'
+
+const FILE_TEMPLATE = (manifest: unknown) => (`
+const manifest = ${JSON.stringify(manifest, null, 2)}
+module.exports = require('jiek/rollup').template(manifest)
+`.trimStart())
+
+program
+  .command('build')
+  .option('-s, --silent', "Don't display logs.")
+  .option('-e, --entries <ENTRIES>', "Specify the entries of the package.json's 'exports' field.(support glob)")
+  .action(async ({
+    silent,
+    entries
+  }: {
+    silent: boolean
+    entries: string
+  }) => {
+    actionRestore()
+    const { build } = loadConfig()
+    silent = silent ?? build?.silent ?? false
+    const {
+      wd,
+      value = {}
+    } = await getSelectedProjectsGraph() ?? {}
+
+    if (Object.keys(value).length === 0) {
+      throw new Error('no package found')
+    }
+    const wdNodeModules = path.resolve(wd, 'node_modules')
+    if (!fs.existsSync(wdNodeModules)) {
+      fs.mkdirSync(wdNodeModules)
+    }
+    const jiekTempDir = (...paths: string[]) => path.resolve(wdNodeModules, '.jiek', ...paths)
+    if (!fs.existsSync(jiekTempDir())) {
+      fs.mkdirSync(jiekTempDir())
+    }
+
+    const rollupBinaryPath = require.resolve('rollup')
+      .replace(/dist\/rollup.js$/, 'dist/bin/rollup')
+    const multiBars = new MultiBar({
+      clearOnComplete: false,
+      hideCursor: true,
+      format: '- {bar} | {status} | {input} | {message}'
+    }, Presets.shades_classic)
+    let i = 0
+    await Promise.all(
+      Object.entries(value).map(async ([dir, manifest]) => {
+        // TODO support auto build child packages in workspaces
+        const escapeManifestName = manifest.name?.replace(/^@/g, '').replace(/\//g, '+')
+        const configFile = jiekTempDir(
+          `${escapeManifestName ?? `anonymous-${i++}`}.rollup.config.js`
+        )
+        fs.writeFileSync(configFile, FILE_TEMPLATE(manifest))
+        let prefix = ''
+        if (tsRegisterName) {
+          prefix = `node -r ${tsRegisterName} `
+        }
+        // TODO replace with `spawn` to support watch mode
+        const command = `${prefix}${rollupBinaryPath} --silent -c ${configFile}`
+        const child = execaCommand(command, {
+          ipc: true,
+          cwd: dir,
+          env: {
+            ...process.env,
+            JIEK_ROOT: wd,
+            JIEK_ENTRIES: entries
+          }
+        })
+        const bars: Record<string, ReturnType<typeof multiBars.create>> = {}
+        let inputMaxLen = 10
+        child.on('message', (e: RollupProgressEvent) => {
+          if (e.type === 'debug') console.log(...(Array.isArray(e.data) ? e.data : [e.data]))
+        })
+        !silent && child.on('message', (e: RollupProgressEvent) => {
+          if (e.type === 'init') {
+            const { leafMap, targetsLength } = e.data
+            const leafs = Array
+              .from(leafMap.entries())
+              .flatMap(([input, pathAndCondiions]) =>
+                pathAndCondiions.map(([path, ...conditions]) => ({
+                  input,
+                  path,
+                  conditions
+                }))
+              )
+            console.log(`Package '${manifest.name}' has ${targetsLength} targets to build`)
+            leafs.forEach(({ input }) => {
+              inputMaxLen = Math.max(inputMaxLen, input.length)
+            })
+            leafs.forEach(({ input, path }) => {
+              const key = `${input}:${path}`
+              if (bars[key]) return
+              bars[key] = multiBars.create(50, 0, {
+                input: input.padEnd(inputMaxLen),
+                status: 'waiting'.padEnd(10)
+              }, {
+                barsize: 20,
+                linewrap: true
+              })
+            })
+          }
+          if (e.type === 'progress') {
+            const {
+              path,
+              tags,
+              input,
+              event,
+              message
+            } = e.data
+            const bar = bars[`${input}:${path}`]
+            if (!bar) return
+            bar.update(
+              {
+                start: 0,
+                resolve: 20,
+                end: 50
+              }[event ?? 'start'] ?? 0,
+              {
+                input: input.padEnd(inputMaxLen),
+                status: event?.padEnd(10),
+                message: `${tags?.join(', ')}: ${message}`
+              }
+            )
+          }
+        })
+        await new Promise<void>((resolve, reject) => {
+          let errorStr = ''
+          child.stderr?.on('data', (data) => {
+            errorStr += data
+          })
+          child.once('exit', (code) =>
+            code === 0
+              ? resolve()
+              : reject(new Error(`rollup build failed:\n${errorStr}`)))
+        })
+      })
+    ).finally(() => {
+      multiBars.stop()
+    })
+
+    actionDone()
+  })

package/src/commands/init.ts

@@ -0,0 +1,373 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+import { program } from 'commander'
+import detectIndent from 'detect-indent'
+import inquirer from 'inquirer'
+import type { Config, InitNamed } from 'jiek'
+import { applyEdits, modify } from 'jsonc-parser'
+import { isMatch } from 'micromatch'
+
+import { getWD } from '../utils/getWD'
+import { loadConfig } from '../utils/loadConfig'
+
+declare module 'jiek' {
+  export type InitNamedFunction = (
+    argument: string,
+    paths: {
+      full: string
+      relative: string
+      basename?: string
+    }
+  ) => [name?: string, path?: string]
+  export type InitNamed =
+    | InitNamedFunction
+    | {
+      [key: string]: string | InitNamedFunction
+    }
+  export interface Config {
+    init?: {
+      /**
+       * the package.json template file path or file content
+       *
+       * if it can be parsed as json, it will be parsed
+       * if it is a relative file path, it will be resolved to an absolute path based on the current working directory
+       * if it is an absolute file path, it will be used directly
+       * @default '.jiek.template.package.json'
+       */
+      template?: string
+      /**
+       * the readme content
+       *
+       * $name will be replaced with the package name
+       * $license will be replaced with the license
+       */
+      readme?:
+        | string
+        | ((ctx: {
+          dir: string
+          packageJson: Record<string, any>
+        }) => string)
+      /**
+       * the readme template file path
+       * @default '.jiek.template.readme.md'
+       */
+      readmeTemplate?: string
+      bug?: {
+        /**
+         * @default 'bug_report.yml'
+         */
+        template?: string
+        /**
+         * @default ['bug']
+         */
+        labels?:
+          | string[]
+          | ((ctx: {
+            name: string
+            dir: string
+          }) => string[])
+      }
+      named?: InitNamed
+    }
+  }
+}
+
+const PACKAGE_JSON_TEMPLATE = `{
+  "name": "",
+  "version": "0.0.1",
+  "description": "",
+  "license": "",
+  "author": "",
+  "files": ["dist"],
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+  },
+  "homepage": "",
+  "repository": "",
+  "bugs": ""
+}`.trimStart()
+const README_TEMPLATE = `# $name
+
+## Installation
+
+\`\`\`bash
+npm install $name
+# or
+pnpm install $name
+# or
+yarn add $name
+\`\`\`
+
+## Usage
+
+
+## License
+
+$license
+`.trimStart()
+
+function getTemplateStr(wd: string, template: string | undefined) {
+  let templateString = template ?? PACKAGE_JSON_TEMPLATE
+  let isTemplateFile = false
+  try {
+    if (template) JSON.parse(template)
+  } catch (e) {
+    isTemplateFile = true
+  }
+  if (isTemplateFile) {
+    const templatePath = path.resolve(wd, template!)
+    templateString = fs.readFileSync(templatePath, 'utf-8')
+  }
+  return templateString
+}
+const wdCache = new Map<string, Record<string, any>>()
+function getWDPackageJSONFiled(wd: string, field: string) {
+  if (wdCache.has(wd)) {
+    return wdCache.get(wd)![field]
+  }
+  const packageJSONPath = path.resolve(wd, 'package.json')
+  const packageJSON = JSON.parse(fs.readFileSync(packageJSONPath, 'utf-8'))
+  wdCache.set(wd, packageJSON)
+  return packageJSON[field]
+}
+async function getName(
+  named: InitNamed | undefined,
+  name: string,
+  {
+    wd,
+    cwd,
+    workspaceName
+  }: {
+    wd: string
+    cwd: string
+    workspaceName: string
+  }
+): Promise<[name?: string, path?: string]> {
+  const relativePath = cwd.replace(`${wd}/`, '')
+  let basename = path.basename(cwd)
+
+  if (typeof named === 'function') {
+    return named(name, {
+      full: wd,
+      relative: cwd
+    })
+  }
+
+  let isParentMatched = false
+  let matchedKey: string | undefined
+  let matchedRule: NonNullable<typeof named>[string] | undefined
+  if (typeof named === 'object') {
+    const isWD = cwd === wd
+    if (isWD) {
+      const { rule } = await inquirer.prompt<{ rule: string }>({
+        type: 'list',
+        name: 'rule',
+        message: 'choose a rule',
+        default: 'default',
+        choices: ['default'].concat(Object.keys(named))
+      })
+      if (rule !== 'default') {
+        matchedKey = rule
+        matchedRule = named[rule]
+      }
+    } else {
+      for (const [key, value] of Object.entries(named)) {
+        if (isMatch(relativePath, key)) {
+          matchedKey = key
+          matchedRule = value
+          break
+        }
+        if (isMatch(`${relativePath}/jiek_ignore_dont_use_same_file_name`, key)) {
+          isParentMatched = true
+          matchedKey = key
+          matchedRule = value
+          break
+        }
+      }
+    }
+  }
+  if (!matchedRule) {
+    matchedKey = 'packages/*'
+    matchedRule = `@${workspaceName}/$basename`
+  }
+  if (!matchedRule) {
+    throw new Error('no matched rule')
+  }
+  if (!name && isParentMatched) {
+    basename = await inquirer.prompt<{ name: string }>({
+      type: 'input',
+      name: 'name',
+      message: `the matched rule is \`${String(matchedRule)}\`, please input the basename\n`
+    }).then(({ name }) => name)
+  }
+
+  if (typeof matchedRule === 'function') {
+    return matchedRule(name, {
+      full: wd,
+      relative: cwd,
+      basename: basename
+    })
+  }
+  if (typeof matchedRule === 'string') {
+    const dirName = name ?? basename
+    return [
+      matchedRule.replace(/\$basename/g, dirName),
+      matchedKey?.replace(/\/\*$/g, `/${dirName}`)
+    ]
+  }
+  throw new Error('no matched rule')
+}
+
+program
+  .command('init [name]')
+  .option('-t, --template <template>', 'the package.json template file path or file content')
+  .action(async () => {
+    const [, name] = program.args
+    const cwd = process.cwd()
+    const { init = {} }: Config = loadConfig() ?? {}
+    const { wd } = getWD()
+    const workspaceName = path.basename(wd)
+
+    const {
+      named,
+      template,
+      bug = {},
+      readme: _readme = README_TEMPLATE,
+      readmeTemplate
+    } = init
+    const resolvedBug = {
+      template: 'bug_report.yml',
+      labels: ['bug'],
+      ...bug
+    }
+    let readme = _readme
+    if (readmeTemplate) {
+      const readmeTemplatePath = path.resolve(wd, readmeTemplate)
+      readme = fs.readFileSync(readmeTemplatePath, 'utf-8')
+    }
+
+    const templateString = getTemplateStr(wd, template)
+    // TODO detectIndent by editorconfig
+    const { indent = '    ' } = detectIndent(templateString)
+    const formattingOptions = {
+      tabSize: indent.length,
+      insertSpaces: true
+    }
+    const passFields = [
+      'license',
+      'author'
+    ]
+    let newJSONString = templateString
+    for (const field of passFields) {
+      newJSONString = applyEdits(
+        newJSONString,
+        modify(
+          newJSONString,
+          [field],
+          getWDPackageJSONFiled(wd, field),
+          { formattingOptions }
+        )
+      )
+    }
+    let [pkgName, pkgDir] = await getName(named, name, {
+      wd,
+      cwd,
+      workspaceName
+    })
+    if (!pkgDir) {
+      const { dir } = await inquirer.prompt<{ dir: string }>({
+        type: 'input',
+        name: 'dir',
+        message: 'package directory',
+        default: name
+      })
+      pkgDir = dir
+    }
+    if (!pkgName) {
+      const { name: inputName } = await inquirer.prompt<{
+        name: string
+      }>({
+        type: 'input',
+        name: 'name',
+        message: 'package name',
+        default: name
+      })
+      pkgName = inputName
+    }
+    newJSONString = applyEdits(newJSONString, modify(newJSONString, ['name'], pkgName, { formattingOptions }))
+
+    let pkgRepo = getWDPackageJSONFiled(wd, 'repository')
+    if (typeof pkgRepo === 'string') {
+      pkgRepo = {
+        type: 'git',
+        url: pkgRepo,
+        directory: pkgDir
+      }
+    }
+    newJSONString = applyEdits(
+      newJSONString,
+      modify(
+        newJSONString,
+        ['repository'],
+        pkgRepo,
+        { formattingOptions }
+      )
+    )
+    const homepage = `${pkgRepo?.url}/blob/master/${pkgDir}/README.md`
+    newJSONString = applyEdits(
+      newJSONString,
+      modify(
+        newJSONString,
+        ['homepage'],
+        homepage,
+        { formattingOptions }
+      )
+    )
+    let labels = resolvedBug.labels
+    if (typeof labels === 'function') {
+      labels = labels({
+        name: pkgName,
+        dir: pkgDir
+      })
+    }
+    labels.push(`scope:${pkgName}`)
+    const bugs = `${pkgRepo?.url}/issues/new?template=${resolvedBug.template}&labels=${labels.join(',')}`
+    newJSONString = applyEdits(
+      newJSONString,
+      modify(
+        newJSONString,
+        ['bugs'],
+        bugs,
+        { formattingOptions }
+      )
+    )
+
+    function pkgDirTo(to: string) {
+      if (!pkgDir) throw new Error('pkgDir is not defined')
+
+      return path.resolve(pkgDir, to)
+    }
+    if (!fs.existsSync(pkgDir)) fs.mkdirSync(pkgDir)
+    const pkgJSONFilePath = pkgDirTo('package.json')
+    if (fs.existsSync(pkgJSONFilePath)) {
+      throw new Error('package.json already exists')
+    }
+    fs.writeFileSync(pkgJSONFilePath, newJSONString)
+    console.log(newJSONString, 'written to', pkgJSONFilePath)
+
+    const license = getWDPackageJSONFiled(wd, 'license')
+    const readmeFilePath = pkgDirTo('README.md')
+    if (typeof readme === 'function') {
+      readme = readme({
+        dir: pkgDir,
+        packageJson: JSON.parse(newJSONString)
+      })
+    }
+    const readmeContent = readme
+      .replace(/\$name/g, pkgName)
+      .replace(/\$license/g, license)
+    fs.writeFileSync(readmeFilePath, readmeContent)
+  })