jiek 2.0.2-alpha.13 → 2.0.2-alpha.15

package/src/commands/publish.ts

@@ -0,0 +1,394 @@
+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 type { ProjectsGraph } from '../utils/filterSupport'
+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()
+
+async function forEachSelectedProjectsGraphEntries(
+  callback: (dir: string, manifest: NonNullable<ProjectsGraph['value']>[string]) => void
+) {
+  const { value = {} } = await getSelectedProjectsGraph() ?? {}
+  const selectedProjectsGraphEntries = Object.entries(value)
+  if (selectedProjectsGraphEntries.length === 0) {
+    throw new Error('no packages selected')
+  }
+  for (const [dir, manifest] of selectedProjectsGraphEntries) {
+    callback(dir, manifest)
+  }
+}
+
+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')
+  .action(async ({ outdir, bumper }: {
+    outdir?: string
+    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[]
+      )
+
+    await forEachSelectedProjectsGraphEntries(dir => {
+      const args = ['pnpm', 'publish', '--access', 'public', '--no-git-checks']
+      if (bumper && TAGS.includes(bumper)) {
+        args.push('--tag', bumper)
+      }
+      args.push(...passThroughOptions)
+      childProcess.execSync(args.join(' '), {
+        cwd: dir,
+        stdio: 'inherit',
+        env: {
+          ...process.env,
+          JIEK_PUBLISH_OUTDIR: JSON.stringify(outdir),
+          JIEK_PUBLISH_BUMPER: JSON.stringify(bumper)
+        }
+      })
+    })
+  })
+
+async function prepublish() {
+  const {
+    JIEK_PUBLISH_OUTDIR: outdirEnv,
+    JIEK_PUBLISH_BUMPER: bumperEnv
+  } = process.env
+  const outdir = outdirEnv ? JSON.parse(outdirEnv) : 'dist'
+  const bumper = bumperEnv ? JSON.parse(bumperEnv) : false
+
+  const generateNewManifest = (dir: string, manifest: NonNullable<ProjectsGraph['value']>[string]) => {
+    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 [newManifest, resolvedOutdir] as const
+  }
+
+  const generateNewPackageJSONString = ({
+    oldJSONString,
+    oldJSON,
+    manifest,
+    formattingOptions
+  }: {
+    oldJSONString: string
+    oldJSON: Record<string, unknown>
+    manifest: NonNullable<ProjectsGraph['value']>[string]
+    formattingOptions: {
+      tabSize: number
+      insertSpaces: boolean
+    }
+  }) => {
+    let newJSONString = oldJSONString
+    newJSONString = applyEdits(
+      newJSONString,
+      modify(
+        newJSONString,
+        ['publishConfig', 'typesVersions'],
+        {
+          '<5.0': {
+            '*': [
+              '*',
+              `./*`,
+              `./*/index.d.ts`,
+              `./*/index.d.mts`,
+              `./*/index.d.cts`
+            ]
+          }
+        },
+        { formattingOptions }
+      )
+    )
+    for (const [key, value] of Object.entries(manifest)) {
+      if (key === 'version') continue
+      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 }
+              )
+            )
+          }
+        }
+      }
+    }
+    if (oldJSON['peerDependencies']) {
+      const peerDependenciesMeta = Object.keys(oldJSON['peerDependencies']).reduce(
+        (acc, key) => {
+          acc[key] = { optional: true }
+          return acc
+        },
+        {} as Record<string, { optional: boolean }>
+      )
+      newJSONString = applyEdits(
+        newJSONString,
+        modify(
+          newJSONString,
+          ['peerDependenciesMeta'],
+          peerDependenciesMeta,
+          { formattingOptions }
+        )
+      )
+    }
+    if (oldJSON['files']) {
+      newJSONString = applyEdits(
+        newJSONString,
+        modify(
+          newJSONString,
+          ['files'],
+          undefined,
+          { formattingOptions }
+        )
+      )
+    }
+    return newJSONString
+  }
+
+  await forEachSelectedProjectsGraphEntries((dir, originalManifest) => {
+    const [manifest, resolvedOutdir] = generateNewManifest(dir, originalManifest)
+    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'
+    if (typeof oldJSON.version !== 'string') {
+      throw new Error(`${dir}/package.json must have a version field with a string value`)
+    }
+
+    // TODO detectIndent by editorconfig
+    const { indent = '    ' } = detectIndent(oldJSONString)
+    const formattingOptions = {
+      tabSize: indent.length,
+      insertSpaces: true
+    }
+
+    const newVersion = bumper ? bump(oldJSON.version, bumper) : oldJSON.version
+    const modifyVersionPackageJSON = applyEdits(
+      oldJSONString,
+      modify(oldJSONString, ['version'], newVersion, { formattingOptions })
+    )
+
+    const newJSONString = generateNewPackageJSONString({
+      oldJSONString: modifyVersionPackageJSON,
+      oldJSON: {
+        ...oldJSON,
+        version: newVersion
+      },
+      manifest,
+      formattingOptions
+    })
+
+    const withPublishConfigDirectoryOldJSONString = applyEdits(
+      modifyVersionPackageJSON,
+      modify(modifyVersionPackageJSON, ['publishConfig', 'directory'], resolvedOutdir, { formattingOptions })
+    )
+
+    if (!fs.existsSync(resolveByDir(resolvedOutdir))) {
+      fs.mkdirSync(resolveByDir(resolvedOutdir))
+    }
+    const jiekTempDir = resolveByDir('node_modules/.jiek/.tmp')
+    if (!fs.existsSync(resolveByDir(jiekTempDir))) {
+      fs.mkdirSync(resolveByDir(jiekTempDir), { recursive: true })
+    }
+
+    fs.writeFileSync(resolveByDir(resolvedOutdir, 'package.json'), newJSONString)
+    fs.writeFileSync(resolveByDir(jiekTempDir, 'package.json'), modifyVersionPackageJSON)
+    fs.writeFileSync(resolveByDir('package.json'), withPublishConfigDirectoryOldJSONString)
+
+    const allBuildFiles = fs
+      .readdirSync(resolveByDir(resolvedOutdir), { recursive: true })
+      .filter(file => typeof file === 'string')
+    for (const file of allBuildFiles) {
+      const filepath = resolveByDir(resolvedOutdir, file)
+      const stat = fs.statSync(filepath)
+      if (stat.isDirectory()) {
+        const existsIndexFile = allBuildFiles
+          .some(f =>
+            [
+              path.join(file, 'index.js'),
+              path.join(file, 'index.mjs'),
+              path.join(file, 'index.cjs')
+            ].includes(f)
+          )
+        if (existsIndexFile) {
+          fs.writeFileSync(
+            resolveByDir(resolvedOutdir, file, 'package.json'),
+            JSON.stringify({ type: oldJSON['type'] })
+          )
+        }
+      }
+    }
+
+    if (oldJSON.files) {
+      if (!Array.isArray(oldJSON.files)) {
+        throw new Error(`${dir}/package.json files field must be an array`)
+      }
+      if (Array.isArray(oldJSON.files) && oldJSON.files.every((file: unknown) => typeof file !== 'string')) {
+        throw new Error(`${dir}/package.json files field must be an array of string`)
+      }
+    }
+    const resolvedOutdirAbs = resolveByDir(resolvedOutdir)
+    const files = (
+      (oldJSON.files as undefined | string[]) ?? fs.readdirSync(resolveByDir('.'))
+    ).filter(file => file === 'node_modules' || resolveByDir(file) !== resolvedOutdirAbs)
+
+    for (const file of files) {
+      const path = resolveByDir(file)
+      try {
+        const stat = fs.statSync(path)
+        if (stat.isDirectory()) {
+          fs.cpSync(path, resolveByDir(resolvedOutdir, file), { recursive: true })
+          continue
+        }
+        if (stat.isFile()) {
+          fs.cpSync(path, resolveByDir(resolvedOutdir, file))
+          continue
+        }
+      } catch (e) {
+        console.warn(String(e))
+        continue
+      }
+      throw new Error(`file type of ${path} is not supported`)
+    }
+  })
+}
+
+async function postpublish() {
+  await forEachSelectedProjectsGraphEntries(dir => {
+    const jiekTempDir = path.resolve(dir, 'node_modules/.jiek/.tmp')
+    const packageJSON = path.resolve(dir, 'package.json')
+    const jiekTempPackageJSON = path.resolve(jiekTempDir, 'package.json')
+    if (fs.existsSync(jiekTempPackageJSON)) {
+      fs.copyFileSync(jiekTempPackageJSON, packageJSON)
+      fs.rmSync(jiekTempPackageJSON)
+      console.log(`${dir}/package.json has been restored`)
+    } else {
+      throw new Error(
+        `jiek temp \`${dir}/package.json\` not found, please confirm the jiek pre-publish command has been executed`
+      )
+    }
+  })
+}
+
+program
+  .action(async () => {
+    const {
+      npm_lifecycle_event: NPM_LIFECYCLE_EVENT
+    } = process.env
+    switch (NPM_LIFECYCLE_EVENT) {
+      case 'prepublish':
+        await prepublish()
+        break
+      case 'postpublish':
+        await postpublish()
+        break
+      default:
+        program.help()
+    }
+  })
+
+program.command('prepublish').action(prepublish)
+program.command('postpublish').action(postpublish)

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