jiek 1.0.0 → 1.0.2

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)
+  })

package/src/commands/publish.ts

@@ -0,0 +1,171 @@
+import * as childProcess from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+
+import { bump, type BumperType } 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'
+
+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('-p, --preview', 'preview publish')
+  .action(async ({ preview, bumper, ...options }: {
+    preview?: 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 { type, exports: entrypoints = {} } = manifest
+        const pkgIsModule = type === 'module'
+        const newManifest = { ...manifest }
+        const [resolvedEntrypoints, exports] = getExports({
+          entrypoints,
+          pkgIsModule,
+          config: loadConfig(dir),
+          dir,
+          noFilter: true,
+          isPublish: true
+        })
+        newManifest.exports = {
+          ...resolvedEntrypoints,
+          ...exports
+        }
+        return [dir, newManifest] 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] 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 }
+                )
+              )
+            }
+          }
+        }
+      }
+      try {
+        fs.renameSync(path.join(dir, 'package.json'), path.join(dir, 'package.json.bak'))
+        fs.writeFileSync(path.join(dir, 'package.json'), newJSONString)
+        console.log(newJSONString)
+        if (preview) {
+          console.warn('preview mode')
+          continue
+        }
+        childProcess.execSync(['pnpm', 'publish', '--access', 'public', '--no-git-checks', ...passArgs].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

@@ -0,0 +1,8 @@
+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

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

package/src/merge-package-json.ts

@@ -0,0 +1,75 @@
+import path from 'node:path'
+
+import { type Options, pkger } from '@jiek/pkger'
+import { commondir } from '@jiek/utils/commondir'
+import type { Manifest } from '@pnpm/workspace.pkgs-graph'
+
+export function mergePackageJson(manifest: Manifest & {
+  jiek?: Options
+  exports?: unknown | unknown[]
+}, cwd: string, options: {
+  excludeDistInExports?: boolean
+} = {}) {
+  const {
+    excludeDistInExports = false
+  } = options
+  const {
+    jiek: { cwd: _, ...jiek } = {}
+  } = manifest
+  const { outdir = 'dist' } = jiek
+  let { exports } = manifest
+  let includeIndex = false
+  if (typeof exports === 'string') {
+    includeIndex = true
+    exports = { '.': exports }
+  }
+  if (exports === undefined) {
+    exports = { '.': './src/index.ts' }
+  }
+  if (typeof exports === 'object') {
+    if (Array.isArray(exports) && exports.length > 0) {
+      includeIndex = true
+    } else {
+      includeIndex = !!(<Record<string, unknown>>exports)['.']
+    }
+  }
+  let inputs = Array.isArray(exports)
+    ? exports as string[]
+    : Object
+      .entries(<Record<string, unknown>>exports)
+      .reduce((acc, [key, value]) => {
+        if (typeof value === 'string') return key === '.'
+          ? [value, ...acc]
+          : acc.concat(value)
+        if (Array.isArray(value)) return acc.concat(value)
+
+        throw new TypeError(`Unexpected value type for key "${key}" in exports, expected string, got ${typeof value}`)
+      }, [] as string[])
+  if (excludeDistInExports) {
+    inputs = inputs.filter(input => !input.startsWith(`./${outdir}`) && !input.startsWith(outdir))
+  }
+  if (inputs.length === 0)
+    throw new Error('No inputs found')
+
+  const absoluteInputs = inputs.map(input => path.isAbsolute(input)
+    ? input
+    : path.resolve(cwd, input)
+  )
+  let cDir = path.dirname(absoluteInputs[0])
+  if (absoluteInputs.length > 1) {
+    cDir = commondir(absoluteInputs, cwd)
+  }
+  const resolvedInputs = absoluteInputs.map(input => {
+    return path.relative(cDir, input)
+  })
+  return {
+    ...manifest,
+    ...pkger({
+      cwd,
+      noIndex: !includeIndex,
+      source: path.relative(cwd, cDir),
+      inputs: resolvedInputs,
+      ...jiek
+    })
+  }
+}

package/src/rollup/base.ts

@@ -0,0 +1,72 @@
+import type { OutputOptions } from 'rollup'
+
+export type Mapping2ROO<K extends keyof OutputOptions> = OutputOptions[K] | {
+  js?: OutputOptions[K]
+  dts?: OutputOptions[K]
+}
+
+export interface TemplateOptions {
+  /**
+   * When the user configures type: module, the generated output from entry points that don't
+   * have cts as a suffix will automatically include the CJS version.
+   * if it is not configured, and the generated output from entry points that do not have mts
+   * as a suffix will automatically include the ESM version.
+   *
+   * @default true
+   */
+  crossModuleConvertor?: boolean
+  output?: {
+    /**
+     * @default true
+     *
+     * When minify is set to true, the output will with minified files.
+     * When minify is set to 'only-minify', the output will direct output minified files.
+     */
+    minify?: boolean | 'only-minify'
+    /**
+     * @default 'dist'
+     */
+    dir?: Mapping2ROO<'dir'>
+    sourcemap?: Mapping2ROO<'sourcemap'>
+    strict?: Mapping2ROO<'strict'>
+  }
+}
+
+export type RollupProgressEvent =
+  | {
+    type: 'init'
+    data: {
+      leafMap: Map<string, string[][]>
+      targetsLength: number
+    }
+  }
+  | {
+    type: 'debug'
+    data: unknown
+  }
+  | {
+    type: 'progress'
+    data: {
+      // name, path, exportConditions, input
+      name: string
+      path: string
+      exportConditions: string[]
+      input: string
+      tags?: string[]
+      event?: string
+      message?: string
+    }
+  }
+
+declare module 'jiek' {
+  export interface Config {
+    build?: TemplateOptions & {
+      /**
+       * Whether to run in silent mode, only active when configured in the workspace root or cwd.
+       *
+       * @default false
+       */
+      silent?: boolean
+    }
+  }
+}