jiek 2.0.1 → 2.0.2-alpha.1

package/src/commands/init.ts

@@ -1,373 +0,0 @@
-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)
-  })

package/src/commands/meta.ts

@@ -1,5 +0,0 @@
-import { getWD } from '#~/utils/getWD.ts'
-
-const { notWorkspace } = getWD()
-
-export const IS_WORKSPACE = !notWorkspace

package/src/commands/publish.ts

@@ -1,204 +0,0 @@
-import * as childProcess from 'node:child_process'
-import fs from 'node:fs'
-import path from 'node:path'
-
-import { bump, type BumperType, TAGS } from '@jiek/utils/bumper'
-import { program } from 'commander'
-import detectIndent from 'detect-indent'
-import { applyEdits, modify } from 'jsonc-parser'
-
-import { actionDone, actionRestore } from '../inner'
-import { getSelectedProjectsGraph } from '../utils/filterSupport'
-import { getExports } from '../utils/getExports'
-import { loadConfig } from '../utils/loadConfig'
-import { outdirDescription } from './descriptions'
-
-declare module 'jiek' {
-  export interface Config {
-    publish?: {
-      /**
-       * @default false
-       */
-      withSuffix?: boolean
-      /**
-       * @default true
-       */
-      withSource?: boolean
-    }
-  }
-}
-
-program
-  .command('publish')
-  .aliases(['pub', 'p'])
-  .option('-b, --bumper <bumper>', 'bump version', 'patch')
-  .option('-no-b, --no-bumper', 'no bump version')
-  .option('-o, --outdir <OUTDIR>', outdirDescription, String, 'dist')
-  .option('-s, --silent', 'no output')
-  .option('-p, --preview', 'preview publish')
-  .action(async ({ outdir, preview, silent, bumper, ...options }: {
-    outdir?: string
-    preview?: boolean
-    silent?: boolean
-    bumper: false | BumperType
-  }) => {
-    actionRestore()
-
-    const { value = {} } = await getSelectedProjectsGraph() ?? {}
-    const selectedProjectsGraphEntries = Object.entries(value)
-    if (selectedProjectsGraphEntries.length === 0) {
-      throw new Error('no packages selected')
-    }
-    const manifests = selectedProjectsGraphEntries
-      .map(([dir, manifest]) => {
-        const { name, type, exports: entrypoints = {} } = manifest
-        if (!name) {
-          throw new Error(`package.json in ${dir} must have a name field`)
-        }
-
-        const pkgIsModule = type === 'module'
-        const newManifest = { ...manifest }
-        const [resolvedEntrypoints, exports, resolvedOutdir] = getExports({
-          entrypoints,
-          pkgIsModule,
-          pkgName: name,
-          config: loadConfig(dir),
-          dir,
-          defaultOutdir: outdir,
-          noFilter: true,
-          isPublish: true
-        })
-        newManifest.exports = {
-          ...resolvedEntrypoints,
-          ...exports
-        }
-        return [dir, newManifest, resolvedOutdir] as const
-      })
-    const passArgs = Object
-      .entries(options)
-      .reduce((acc, [key, value]) => {
-        if (value) {
-          acc.push(`--${key}`, value as string)
-        }
-        return acc
-      }, [] as string[])
-    for (const [dir, manifest, resolvedOutdir] of manifests) {
-      const oldJSONString = fs.readFileSync(path.join(dir, 'package.json'), 'utf-8')
-      const oldJSON = JSON.parse(oldJSONString) ?? '0.0.0'
-      const newVersion = bumper ? bump(oldJSON.version, bumper) : oldJSON.version
-      // TODO detectIndent by editorconfig
-      const { indent = '    ' } = detectIndent(oldJSONString)
-      const formattingOptions = {
-        tabSize: indent.length,
-        insertSpaces: true
-      }
-      let newJSONString = oldJSONString
-      newJSONString = applyEdits(
-        newJSONString,
-        modify(
-          newJSONString,
-          ['version'],
-          newVersion,
-          { formattingOptions }
-        )
-      )
-      for (const [key, value] of Object.entries(manifest)) {
-        if (JSON.stringify(value) === JSON.stringify(oldJSON[key])) continue
-
-        if (key !== 'exports') {
-          newJSONString = applyEdits(
-            newJSONString,
-            modify(
-              newJSONString,
-              ['publishConfig', key],
-              value,
-              { formattingOptions }
-            )
-          )
-        } else {
-          const exports = value as Record<string, unknown>
-          for (const [k, v] of Object.entries(exports)) {
-            newJSONString = applyEdits(
-              newJSONString,
-              modify(
-                newJSONString,
-                ['publishConfig', 'exports', k],
-                v,
-                { formattingOptions }
-              )
-            )
-          }
-          const index = exports?.['.']
-          const indexPublishConfig: Record<string, string> = {}
-          if (index) {
-            switch (typeof index) {
-              case 'string':
-                indexPublishConfig[
-                  manifest?.type === 'module' ? 'module' : 'main'
-                ] = index
-                break
-              case 'object': {
-                const indexExports = index as Record<string, string>
-                indexPublishConfig.main = indexExports['require'] ?? indexExports['default']
-                indexPublishConfig.module = indexExports['import'] ?? indexExports['module'] ?? indexExports['default']
-                break
-              }
-            }
-            for (const [k, v] of Object.entries(indexPublishConfig)) {
-              if (v === undefined) continue
-              newJSONString = applyEdits(
-                newJSONString,
-                modify(
-                  newJSONString,
-                  ['publishConfig', k],
-                  v,
-                  { formattingOptions }
-                )
-              )
-            }
-          }
-        }
-      }
-      newJSONString = applyEdits(
-        newJSONString,
-        modify(
-          newJSONString,
-          ['publishConfig', 'typesVersions'],
-          {
-            '<5.0': {
-              '*': [
-                '*',
-                `${resolvedOutdir}/*`,
-                `${resolvedOutdir}/*/index.d.ts`,
-                `${resolvedOutdir}/*/index.d.mts`,
-                `${resolvedOutdir}/*/index.d.cts`
-              ]
-            }
-          },
-          { formattingOptions }
-        )
-      )
-      try {
-        fs.renameSync(path.join(dir, 'package.json'), path.join(dir, 'package.json.bak'))
-        fs.writeFileSync(path.join(dir, 'package.json'), newJSONString)
-        !silent && console.log(newJSONString)
-        if (preview) {
-          continue
-        }
-        const args = ['pnpm', 'publish', '--access', 'public', '--no-git-checks', ...passArgs]
-        if (bumper && TAGS.includes(bumper)) {
-          args.push('--tag', bumper)
-        }
-        childProcess.execSync(args.join(' '), {
-          cwd: dir,
-          stdio: 'inherit'
-        })
-        const modifyVersionPackageJSON = applyEdits(oldJSONString, modify(oldJSONString, ['version'], newVersion, {}))
-        fs.writeFileSync(path.join(dir, 'package.json.bak'), modifyVersionPackageJSON)
-      } finally {
-        fs.unlinkSync(path.join(dir, 'package.json'))
-        fs.renameSync(path.join(dir, 'package.json.bak'), path.join(dir, 'package.json'))
-      }
-    }
-    actionDone()
-  })

package/src/index.ts

@@ -1,8 +0,0 @@
-import type {} from './commands/base'
-import type {} from './commands/build'
-import type {} from './commands/init'
-import type {} from './commands/publish'
-
-export interface Config {}
-
-export const defineConfig = (config: Config) => config

package/src/inner.ts

@@ -1,11 +0,0 @@
-let resolve: () => void
-
-export let actionFuture: Promise<void>
-
-export function actionDone() {
-  resolve()
-}
-
-export function actionRestore() {
-  actionFuture = new Promise<void>(r => resolve = r)
-}