jiek 1.1.4 → 1.1.6

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jiek",
   "type": "module",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "description": "YiJie's personal kits.",
   "bin": {
     "jiek": "bin/jiek.js",
@@ -61,8 +61,8 @@
     "rollup": "^4.1.5",
     "rollup-plugin-esbuild": "^6.1.0",
     "typescript": "^5.0.0",
-    "@jiek/pkger": "^0.2.0",
-    "@jiek/utils": "^0.2.2"
+    "@jiek/utils": "^0.2.2",
+    "@jiek/pkger": "^0.2.0"
   },
   "optionalDependencies": {
     "@pnpm/filter-workspace-packages": "^7.2.13",

package/src/commands/build.ts

@@ -8,7 +8,8 @@ import { execaCommand } from 'execa'
 
 import { actionDone, actionRestore } from '../inner'
 import type { RollupProgressEvent, TemplateOptions } from '../rollup/base'
-import { getSelectedProjectsGraph } from '../utils/filterSupport'
+import type { ProjectsGraph } from '../utils/filterSupport'
+import { filterPackagesGraph } from '../utils/filterSupport'
 import { loadConfig } from '../utils/loadConfig'
 import { tsRegisterName } from '../utils/tsRegister'
 
@@ -40,138 +41,154 @@ program
   .description(description)
   .option('-s, --silent', "Don't display logs.")
   .option('-e, --entries <ENTRIES>', "Specify the entries of the package.json's 'exports' field.(support glob)")
+  .option('--without-js', 'Do not output js files.')
+  .option('--without-dts', 'Do not output dts files.')
   .option('-v, --verbose', 'Display debug logs.')
   .action(async ({
     silent,
     entries,
-    verbose
+    verbose,
+    withoutJs,
+    withoutDts
   }: {
     silent: boolean
     entries: string
     verbose: boolean
+    withoutJs: boolean
+    withoutDts: boolean
   }) => {
     actionRestore()
     const { build } = loadConfig()
     silent = silent ?? build?.silent ?? false
-    const {
-      wd,
-      value = {}
-    } = await getSelectedProjectsGraph() ?? {}
-
-    if (Object.keys(value).length === 0) {
-      throw new Error('no package found')
-    }
-    const wdNodeModules = path.resolve(wd, 'node_modules')
-    if (!fs.existsSync(wdNodeModules)) {
-      fs.mkdirSync(wdNodeModules)
-    }
-    const jiekTempDir = (...paths: string[]) => path.resolve(wdNodeModules, '.jiek', ...paths)
-    if (!fs.existsSync(jiekTempDir())) {
-      fs.mkdirSync(jiekTempDir())
-    }
 
-    const rollupBinaryPath = require.resolve('rollup')
-      .replace(/dist\/rollup.js$/, 'dist/bin/rollup')
     const multiBars = new MultiBar({
       clearOnComplete: false,
       hideCursor: true,
-      format: '- {bar} | {status} | {input} | {message}'
+      format: '- {bar} | {status} | {pkgName} | {input} | {message}'
     }, Presets.shades_classic)
-    let i = 0
-    await Promise.all(
-      Object.entries(value).map(async ([dir, manifest]) => {
-        // TODO support auto build child packages in workspaces
-        const escapeManifestName = manifest.name?.replace(/^@/g, '').replace(/\//g, '+')
-        const configFile = jiekTempDir(
-          `${escapeManifestName ?? `anonymous-${i++}`}.rollup.config.js`
-        )
-        fs.writeFileSync(configFile, FILE_TEMPLATE(manifest))
-        let prefix = ''
-        if (tsRegisterName) {
-          prefix = `node -r ${tsRegisterName} `
-        }
-        const command = `${prefix}${rollupBinaryPath} --silent -c ${configFile}`
-        const child = execaCommand(command, {
-          ipc: true,
-          cwd: dir,
-          env: {
-            ...process.env,
-            JIEK_ROOT: wd,
-            JIEK_ENTRIES: entries
+
+    const buildPackage = async ({
+      wd,
+      value = {}
+    }: ProjectsGraph) => {
+      if (Object.keys(value).length === 0) {
+        throw new Error('no package found')
+      }
+      const wdNodeModules = path.resolve(wd, 'node_modules')
+      if (!fs.existsSync(wdNodeModules)) {
+        fs.mkdirSync(wdNodeModules)
+      }
+      const jiekTempDir = (...paths: string[]) => path.resolve(wdNodeModules, '.jiek', ...paths)
+      if (!fs.existsSync(jiekTempDir())) {
+        fs.mkdirSync(jiekTempDir())
+      }
+
+      const rollupBinaryPath = require.resolve('rollup')
+        .replace(/dist\/rollup.js$/, 'dist/bin/rollup')
+      let i = 0
+      await Promise.all(
+        Object.entries(value).map(async ([dir, manifest]) => {
+          // TODO support auto build child packages in workspaces
+          const escapeManifestName = manifest.name?.replace(/^@/g, '').replace(/\//g, '+')
+          const configFile = jiekTempDir(
+            `${escapeManifestName ?? `anonymous-${i++}`}.rollup.config.js`
+          )
+          fs.writeFileSync(configFile, FILE_TEMPLATE(manifest))
+          let prefix = ''
+          if (tsRegisterName) {
+            prefix = `node -r ${tsRegisterName} `
           }
-        })
-        const bars: Record<string, ReturnType<typeof multiBars.create>> = {}
-        let inputMaxLen = 10
-        child.on('message', (e: RollupProgressEvent) => {
-          if (e.type === 'debug') console.log(...(Array.isArray(e.data) ? e.data : [e.data]))
-        })
-        !silent && child.on('message', (e: RollupProgressEvent) => {
-          if (e.type === 'init') {
-            const { leafMap, targetsLength } = e.data
-            const leafs = Array
-              .from(leafMap.entries())
-              .flatMap(([input, pathAndCondiions]) =>
-                pathAndCondiions.map(([path, ...conditions]) => ({
-                  input,
-                  path,
-                  conditions
-                }))
-              )
-            console.log(`Package '${manifest.name}' has ${targetsLength} targets to build`)
-            leafs.forEach(({ input }) => {
-              inputMaxLen = Math.max(inputMaxLen, input.length)
-            })
-            leafs.forEach(({ input, path }) => {
-              const key = `${input}:${path}`
-              if (bars[key]) return
-              bars[key] = multiBars.create(50, 0, {
-                input: input.padEnd(inputMaxLen),
-                status: 'waiting'.padEnd(10)
-              }, {
-                barsize: 20,
-                linewrap: true
+          const command = `${prefix}${rollupBinaryPath} --silent -c ${configFile}`
+          const child = execaCommand(command, {
+            ipc: true,
+            cwd: dir,
+            env: {
+              ...process.env,
+              JIEK_ROOT: wd,
+              JIEK_ENTRIES: entries,
+              JIEK_WITHOUT_JS: String(withoutJs),
+              JIEK_WITHOUT_DTS: String(withoutDts)
+            }
+          })
+          const bars: Record<string, ReturnType<typeof multiBars.create>> = {}
+          let inputMaxLen = 10
+          child.on('message', (e: RollupProgressEvent) => {
+            if (e.type === 'debug') console.log(...(Array.isArray(e.data) ? e.data : [e.data]))
+          })
+          !silent && child.on('message', (e: RollupProgressEvent) => {
+            if (e.type === 'init') {
+              const { leafMap, targetsLength } = e.data
+              const leafs = Array
+                .from(leafMap.entries())
+                .flatMap(([input, pathAndCondiions]) =>
+                  pathAndCondiions.map(([path, ...conditions]) => ({
+                    input,
+                    path,
+                    conditions
+                  }))
+                )
+              console.log(`Package '${manifest.name}' has ${targetsLength} targets to build`)
+              leafs.forEach(({ input }) => {
+                inputMaxLen = Math.max(inputMaxLen, input.length)
+              })
+              leafs.forEach(({ input, path }) => {
+                const key = `${input}:${path}`
+                if (bars[key]) return
+                bars[key] = multiBars.create(50, 0, {
+                  pkgName: manifest.name,
+                  input: input.padEnd(inputMaxLen),
+                  status: 'waiting'.padEnd(10)
+                }, {
+                  barsize: 20,
+                  linewrap: true
+                })
               })
+            }
+            if (e.type === 'progress') {
+              const {
+                path,
+                tags,
+                input,
+                event,
+                message
+              } = e.data
+              const bar = bars[`${input}:${path}`]
+              if (!bar) return
+              bar.update(
+                {
+                  start: 0,
+                  resolve: 20,
+                  end: 50
+                }[event ?? 'start'] ?? 0,
+                {
+                  input: input.padEnd(inputMaxLen),
+                  status: event?.padEnd(10),
+                  message: `${tags?.join(', ')}: ${message}`
+                }
+              )
+            }
+          })
+          await new Promise<void>((resolve, reject) => {
+            let errorStr = ''
+            child.stderr?.on('data', (data) => {
+              errorStr += data
             })
-          }
-          if (e.type === 'progress') {
-            const {
-              path,
-              tags,
-              input,
-              event,
-              message
-            } = e.data
-            const bar = bars[`${input}:${path}`]
-            if (!bar) return
-            bar.update(
-              {
-                start: 0,
-                resolve: 20,
-                end: 50
-              }[event ?? 'start'] ?? 0,
-              {
-                input: input.padEnd(inputMaxLen),
-                status: event?.padEnd(10),
-                message: `${tags?.join(', ')}: ${message}`
-              }
-            )
-          }
-        })
-        await new Promise<void>((resolve, reject) => {
-          let errorStr = ''
-          child.stderr?.on('data', (data) => {
-            errorStr += data
+            child.once('exit', (code) =>
+              code === 0
+                ? resolve()
+                : reject(new Error(`rollup build failed:\n${errorStr}`)))
+            verbose && child.stdout?.pipe(process.stdout)
           })
-          child.once('exit', (code) =>
-            code === 0
-              ? resolve()
-              : reject(new Error(`rollup build failed:\n${errorStr}`)))
-          verbose && child.stdout?.pipe(process.stdout)
         })
+      )
+    }
+    const filters: string[] = program.getOptionValue('filter').split(',')
+    const packages = await filterPackagesGraph(filters)
+    await Promise
+      .all(packages.map(buildPackage))
+      .finally(() => {
+        multiBars.stop()
       })
-    ).finally(() => {
-      multiBars.stop()
-    })
 
     actionDone()
   })

package/src/rollup/base.ts

@@ -15,6 +15,8 @@ export interface ConfigGenerateContext {
   conditionals: string[]
 }
 
+export type OutputControl = boolean | ((context: ConfigGenerateContext) => boolean)
+
 export interface TemplateOptions {
   /**
    * When the user configures type: module, the generated output from entry points that don't
@@ -39,6 +41,8 @@ export interface TemplateOptions {
     dir?: Mapping2ROO<'dir'>
     sourcemap?: Mapping2ROO<'sourcemap'>
     strict?: Mapping2ROO<'strict'>
+    js?: OutputControl
+    dts?: OutputControl
   }
   plugins?:
     | InputPluginOption

package/src/rollup/index.ts

@@ -33,13 +33,17 @@ interface PackageJSON {
 
 const {
   JIEK_ROOT,
-  JIEK_ENTRIES
+  JIEK_ENTRIES,
+  JIEK_WITHOUT_JS,
+  JIEK_WITHOUT_DTS
 } = process.env
 const WORKSPACE_ROOT = JIEK_ROOT ?? getWorkspaceDir()
 const COMMON_OPTIONS = {} satisfies RollupOptions
 const COMMON_PLUGINS = [
   json()
 ]
+const WITHOUT_JS = JIEK_WITHOUT_JS === 'true'
+const WITHOUT_DTS = JIEK_WITHOUT_DTS === 'true'
 
 const config = loadConfig({
   root: WORKSPACE_ROOT
@@ -88,6 +92,22 @@ const resolveBuildPlugins = (context: ConfigGenerateContext, plugins: TemplateOp
   return { js, dts }
 }
 
+const resolveOutputControls = (
+  context: ConfigGenerateContext,
+  output: TemplateOptions['output']
+): { js: boolean; dts: boolean } => ({
+  js: typeof output?.js === 'boolean'
+    ? output.js
+    : typeof output?.js === 'function'
+    ? output.js(context)
+    : true,
+  dts: typeof output?.dts === 'boolean'
+    ? output.dts
+    : typeof output?.dts === 'function'
+    ? output.dts(context)
+    : true
+})
+
 const resolveWorkspacePath = (p: string) => resolve(WORKSPACE_ROOT, p)
 
 const pascalCase = (str: string) =>
@@ -212,8 +232,10 @@ const generateConfigs = (context: ConfigGenerateContext, options: TemplateOption
   }
   const jsOutputSuffix = extname(output)
   const tsOutputSuffix = jsOutputSuffix.replace(/(\.[cm]?)js$/, '.d$1ts')
-  return [
-    {
+  const { js: jsOutput, dts: dtsOutput } = resolveOutputControls(context, build.output)
+  const rollupOptions: RollupOptions[] = []
+  if (jsOutput && !WITHOUT_JS) {
+    rollupOptions.push({
       input: inputObj,
       external,
       output: [
@@ -268,8 +290,10 @@ const generateConfigs = (context: ConfigGenerateContext, options: TemplateOption
         }),
         jsPlugins
       ]
-    },
-    {
+    })
+  }
+  if (dtsOutput && !WITHOUT_DTS) {
+    rollupOptions.push({
       input: inputObj,
       external,
       output: [
@@ -321,8 +345,9 @@ const generateConfigs = (context: ConfigGenerateContext, options: TemplateOption
         }),
         dtsPlugins
       ]
-    }
-  ]
+    })
+  }
+  return rollupOptions
 }
 
 export function template(packageJSON: PackageJSON): RollupOptions[] {

package/src/rollup/utils/externalResolver.ts

@@ -1,4 +1,5 @@
 import fs from 'node:fs'
+import { builtinModules } from 'node:module'
 
 const EXCLUDE_SUFFIX = [
   'te?xt',
@@ -18,11 +19,14 @@ export default function(jsonOrPath: string | Record<string, unknown> = process.c
   if (!name) {
     throw new Error('package.json must have a name field')
   }
+
   const external = <(string | RegExp)[]> Object
     .keys(dependencies)
     .concat(Object.keys(peerDependencies))
     .concat(Object.keys(optionalDependencies))
-  return external
+    .concat(builtinModules)
+
+  return [...new Set(external)]
     .map(dep => new RegExp(`^${dep}(/.*)?$`))
     .concat([
       new RegExp(`^${name}(/.*)?(?<!${EXCLUDE_SUFFIX.map(suffix => `\\.${suffix}`).join('|')})$`),

package/src/utils/filterSupport.ts

@@ -18,10 +18,10 @@ try {
 } catch { /* empty */ }
 if (type !== '') {
   program
-    .option('-f, --filter <filter>', 'filter packages')
+    .option('-f, --filter <filter>', 'filter packages, support fuzzy match and array. e.g. -f core,utils')
 }
 
-interface ProjectsGraph {
+export interface ProjectsGraph {
   wd: string
   root: string
   value?: Record<string, {
@@ -31,8 +31,13 @@ interface ProjectsGraph {
   }>
 }
 
-export async function getSelectedProjectsGraph(): Promise<ProjectsGraph> {
-  let filter = program.getOptionValue('filter')
+export function filterPackagesGraph(filters: string[]): Promise<ProjectsGraph[]> {
+  return Promise.all(filters.map(async filter => getSelectedProjectsGraph(filter)))
+}
+
+export async function getSelectedProjectsGraph(
+  filter = program.getOptionValue('filter')
+): Promise<ProjectsGraph> {
   const root = getRoot()
   const { wd, notWorkspace } = getWD()
   if (!notWorkspace && type === 'pnpm') {