jiek 2.0.2-alpha.1 → 2.0.2-alpha.2

package/src/commands/publish.ts

@@ -0,0 +1,242 @@
+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
+    }
+  }
+}
+
+const description = `
+Publish package to npm registry, and auto generate exports field and other fields in published package.json.
+If you want to through the options to the \`pnpm publish\` command, you can pass the options after '--'.
+`.trim()
+
+program
+  .command('publish')
+  .description(description)
+  .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
+  }) => {
+    let shouldPassThrough = false
+
+    const passThroughOptions = process.argv
+      .reduce(
+        (acc, value) => {
+          if (shouldPassThrough) {
+            acc.push(value)
+          }
+          if (value === '--') {
+            shouldPassThrough = true
+          }
+          return acc
+        },
+        [] as string[]
+      )
+    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 resolveByDir = (...paths: string[]) => path.resolve(dir, ...paths)
+
+      const oldJSONString = fs.readFileSync(resolveByDir('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 }
+        )
+      )
+      newJSONString = applyEdits(
+        newJSONString,
+        modify(newJSONString, ['publishConfig', 'directory'], resolvedOutdir, { formattingOptions })
+      )
+      !silent && console.log(newJSONString)
+      if (preview) {
+        continue
+      }
+      const effects: (() => void)[] = []
+      try {
+        // fs.renameSync(resolveByDir('package.json'), resolveByDir('package.json.bak'))
+
+        if (!fs.existsSync(resolveByDir(resolvedOutdir))) {
+          fs.mkdirSync(resolveByDir(resolvedOutdir))
+          effects.push(() => fs.rmdirSync(resolveByDir(resolvedOutdir), { recursive: true }))
+        }
+        // fs.writeFileSync(resolveByDir('package.json'), newJSONString)
+        fs.writeFileSync(resolveByDir(resolvedOutdir, 'package.json'), newJSONString)
+        effects.push(() => fs.unlinkSync(resolveByDir(resolvedOutdir, 'package.json')))
+
+        const modifyVersionPackageJSON = applyEdits(oldJSONString, modify(oldJSONString, ['version'], newVersion, {}))
+        fs.writeFileSync(resolveByDir('package.json'), modifyVersionPackageJSON)
+        effects.push(() => fs.writeFileSync(resolveByDir('package.json'), oldJSONString))
+
+        const args = ['pnpm', 'publish', '--access', 'public', '--no-git-checks', ...passArgs]
+        if (bumper && TAGS.includes(bumper)) {
+          args.push('--tag', bumper)
+        }
+        args.push(...passThroughOptions)
+        childProcess.execSync(args.join(' '), {
+          cwd: dir,
+          stdio: 'inherit'
+        })
+      } finally {
+        effects.forEach(effect => effect())
+      }
+    }
+    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/rollup/base.ts

@@ -0,0 +1,137 @@
+import type { InputPluginOption, OutputOptions } from 'rollup'
+
+export type Mapping2ROO<K extends keyof OutputOptions> = OutputOptions[K] | {
+  js?: OutputOptions[K]
+  dts?: OutputOptions[K]
+}
+
+export interface ConfigGenerateContext {
+  path: string
+  name: string
+  input: string
+  output: string
+  external: (string | RegExp)[]
+  pkgIsModule: boolean
+  conditionals: string[]
+}
+
+export type OutputControl = boolean | ((context: ConfigGenerateContext) => boolean)
+
+export const BUILDER_TYPES = ['esbuild', 'swc'] as const
+
+export const BUILDER_TYPE_PACKAGE_NAME_MAP = {
+  esbuild: 'rollup-plugin-esbuild',
+  swc: 'rollup-plugin-swc3'
+}
+
+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
+  /**
+   * Auto-detect the builder from the installed dependencies.
+   * If the builder is not installed, it will prompt the user to install it.
+   * If exists multiple builders, it will fall back to the 'esbuild'.
+   *
+   * @default 'esbuild'
+   */
+  builder?:
+    | typeof BUILDER_TYPES[number]
+    | ({
+      type: 'esbuild'
+    } & import('rollup-plugin-esbuild').Options)
+    | ({
+      type: 'swc'
+    } & import('rollup-plugin-swc3').PluginOptions)
+  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'
+    minifyOptions?:
+      | typeof BUILDER_TYPES[number]
+      | 'terser'
+      | (
+        {
+          type: 'terser'
+        } & import('@rollup/plugin-terser').Options
+      )
+      | (
+        {
+          type: 'esbuild'
+        } & Parameters<typeof import('rollup-plugin-esbuild').minify>[0]
+      )
+      | (
+        {
+          type: 'swc'
+        } & Parameters<typeof import('rollup-plugin-swc3').minify>[0]
+      )
+    /**
+     * @default 'dist'
+     */
+    dir?: Mapping2ROO<'dir'>
+    sourcemap?: Mapping2ROO<'sourcemap'>
+    strict?: Mapping2ROO<'strict'>
+    js?: OutputControl
+    dts?: OutputControl
+  }
+  /**
+   * Set the external dependencies of the package.
+   */
+  external?: (string | RegExp)[]
+  plugins?:
+    | InputPluginOption
+    | ((type: 'js' | 'dts', context: ConfigGenerateContext) => InputPluginOption)
+    | {
+      js: InputPluginOption
+      dts?: InputPluginOption
+    }
+    | {
+      js?: InputPluginOption
+      dts: InputPluginOption
+    }
+}
+
+export type RollupProgressEvent =
+  | {
+    type: 'init'
+    data: {
+      leafMap: Map<string, string[][]>
+      targetsLength: number
+    }
+  }
+  | {
+    type: 'watchChange'
+    data: {
+      id: string
+      name: string
+      path: string
+      input: string
+    }
+  }
+  | {
+    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
+    }
+  }