jiek 0.4.6 → 0.4.7-alpha.1

package/src/commands/publish.ts

@@ -0,0 +1,156 @@
+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'
+
+program
+  .command('publish')
+  .aliases(['pub', 'p'])
+  .option('-b, --bumper <bumper>', 'bump version', 'patch')
+  .option('-p, --preview', 'preview publish')
+  .action(async ({ preview, bumper, ...options }: {
+    preview?: boolean
+    bumper: 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,
+          withSource: true,
+          withSuffix: 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 = bump(oldJSON.version, bumper)
+      // 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/pkg.ts

@@ -0,0 +1 @@
+export default require('../package.json')

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