jiek 1.0.0 → 1.0.2

package/src/rollup/index.ts

@@ -0,0 +1,422 @@
+import '../rollup/base'
+
+import fs from 'node:fs'
+import { dirname, relative, resolve } from 'node:path'
+
+import type { RecursiveRecord } from '@jiek/pkger/entrypoints'
+import { getAllLeafs } from '@jiek/pkger/entrypoints'
+import { dts } from '@jiek/rollup-plugin-dts'
+import { getWorkspaceDir } from '@jiek/utils/getWorkspaceDir'
+import commonjs from '@rollup/plugin-commonjs'
+import json from '@rollup/plugin-json'
+import { nodeResolve } from '@rollup/plugin-node-resolve'
+import terser from '@rollup/plugin-terser'
+import { sendMessage } from 'execa'
+import { parse } from 'jsonc-parser'
+import { isMatch } from 'micromatch'
+import type { OutputOptions, OutputPlugin, RollupOptions } from 'rollup'
+import esbuild from 'rollup-plugin-esbuild'
+import ts from 'typescript'
+
+import { getExports } from '../utils/getExports'
+import { loadConfig } from '../utils/loadConfig'
+import type { RollupProgressEvent, TemplateOptions } from './base'
+import progress from './plugins/progress'
+import skip from './plugins/skip'
+import externalResolver from './utils/externalResolver'
+
+interface PackageJSON {
+  name?: string
+  type?: string
+  exports?: Record<string, unknown> | string | string[]
+}
+
+const {
+  JIEK_ROOT,
+  JIEK_ENTRIES
+} = process.env
+const WORKSPACE_ROOT = JIEK_ROOT ?? getWorkspaceDir()
+const COMMON_OPTIONS = {} satisfies RollupOptions
+const COMMON_PLUGINS = [
+  json()
+]
+
+const config = loadConfig() ?? {}
+const { build = {} } = config
+const jsOutdir = `./${
+  relative(
+    process.cwd(),
+    resolve(
+      (
+        typeof build?.output?.dir === 'object'
+          // the outdir only affect js output in this function
+          ? build.output.dir.js
+          : build?.output?.dir
+      ) ?? 'dist'
+    )
+  )
+}`
+
+const STYLE_REGEXP = /\.(css|s[ac]ss|less|styl)$/
+
+// eslint-disable-next-line unused-imports/no-unused-vars
+const debug = (...args: unknown[]) => sendMessage({ type: 'debug', data: args } satisfies RollupProgressEvent)
+
+const resolveWorkspacePath = (p: string) => resolve(WORKSPACE_ROOT, p)
+
+const pascalCase = (str: string) =>
+  str
+    .replace(/[@|/-](\w)/g, (_, $1) => $1.toUpperCase())
+    .replace(/(?:^|-)(\w)/g, (_, $1) => $1.toUpperCase())
+
+const reveal = (obj: string | Record<string, unknown>, keys: string[]) =>
+  keys.reduce((acc, key) => {
+    if (typeof acc === 'string') throw new Error('key not found in exports')
+    if (!(key in acc)) throw new Error(`key ${key} not found in exports`)
+    return acc[key] as string | Record<string, unknown>
+  }, obj)
+
+const withMinify = (
+  output: OutputOptions & {
+    plugins?: OutputPlugin[]
+  },
+  minify = build?.output?.minify
+) =>
+  minify === false
+    ? [output]
+    : minify === 'only-minify'
+    ? [{
+      ...output,
+      // TODO replace suffix when pubish to npm and the `build.output.minify` is 'only-minify'
+      // TODO resolve dts output file name
+      file: output.file?.replace(/(\.[cm]?js)$/, '.min$1'),
+      plugins: [
+        ...(output.plugins ?? []),
+        terser()
+      ]
+    }]
+    : [
+      output,
+      {
+        ...output,
+        file: output.file?.replace(/(\.[cm]?js)$/, '.min$1'),
+        plugins: [
+          ...(output.plugins ?? []),
+          terser()
+        ]
+      }
+    ]
+
+type TSConfig = {
+  extends?: string | string[]
+  compilerOptions?: Record<string, unknown>
+  references?: { path: string }[]
+  files?: string[]
+  include?: string[]
+  exclude?: string[]
+}
+
+const getTSConfig = (p: string): TSConfig =>
+  !fs.existsSync(p) || !fs.statSync(p).isFile()
+    ? {}
+    : parse(fs.readFileSync(p, 'utf-8'), [], { allowTrailingComma: true, allowEmptyContent: true })
+
+const getExtendTSConfig = (tsconfigPath: string): TSConfig => {
+  tsconfigPath = resolve(tsconfigPath)
+  const tsconfigPathDirname = dirname(tsconfigPath)
+  const { extends: exts, ...tsconfig } = getTSConfig(tsconfigPath)
+  const resolvePaths = (paths: string[] | undefined) => paths?.map(p => resolve(tsconfigPathDirname, p)) ?? []
+
+  const extendsPaths = resolvePaths(
+    exts ? Array.isArray(exts) ? exts : [exts] : []
+  )
+  if (extendsPaths.length === 0) return tsconfig
+  return extendsPaths
+    .map(getExtendTSConfig)
+    .concat(tsconfig)
+    // https://www.typescriptlang.org/tsconfig/#files:~:text=Currently%2C%20the%20only%20top%2Dlevel%20property%20that%20is%20excluded%20from%20inheritance%20is%20references.
+    // Currently, the only top-level property that is excluded from inheritance is references.
+    .reduce((acc, { compilerOptions = {}, references: _, ...curr }) => ({
+      ...acc,
+      ...curr,
+      compilerOptions: {
+        ...acc.compilerOptions,
+        ...compilerOptions
+      }
+    }), {})
+}
+
+const getCompilerOptionsByFilePath = (tsconfigPath: string, filePath: string): Record<string, unknown> | undefined => {
+  tsconfigPath = resolve(tsconfigPath)
+  filePath = resolve(filePath)
+  const tsconfigPathDirname = dirname(tsconfigPath)
+  // https://www.typescriptlang.org/tsconfig/#files:~:text=It%E2%80%99s%20worth%20noting%20that%20files%2C%20include%2C%20and%20exclude%20from%20the%20inheriting%20config%20file%20overwrite%20those%20from%20the%20base%20config%20file%2C%20and%20that%20circularity%20between%20configuration%20files%20is%20not%20allowed.
+  // It’s worth noting that files, include, and exclude from the inheriting config file overwrite
+  // those from the base config file, and that circularity between configuration files is not allowed.
+  const tsconfig = getExtendTSConfig(tsconfigPath)
+
+  const resolvePaths = (paths: string[] | undefined) => paths?.map(p => resolve(tsconfigPathDirname, p)) ?? []
+
+  const [
+    references,
+    files,
+    include,
+    exclude
+  ] = [
+    tsconfig.references?.map(({ path }) => path),
+    tsconfig.files,
+    tsconfig.include,
+    tsconfig.exclude
+  ].map(resolvePaths)
+  if (exclude.length > 0 && exclude.some(i => isMatch(filePath, i))) return
+
+  // when files or include is not empty, the tsconfig should be ignored
+  if (tsconfig.files?.length === 0 && tsconfig.include?.length === 0) return
+  let isInclude = false
+  isInclude ||= files.length > 0 && files.includes(filePath)
+  isInclude ||= include.length > 0 && include.some(i => isMatch(filePath, i))
+  if (isInclude) {
+    return tsconfig.compilerOptions ?? {}
+  } else {
+    // when files or include is not empty, but the file is not matched, the tsconfig should be ignored
+    if (
+      (tsconfig.files && tsconfig.files.length > 0)
+      || (tsconfig.include && tsconfig.include.length > 0)
+    ) return
+  }
+
+  references.reverse()
+  for (const ref of references) {
+    const compilerOptions = getCompilerOptionsByFilePath(ref, filePath)
+    if (compilerOptions) return compilerOptions
+  }
+  return tsconfig.compilerOptions
+}
+
+const generateConfigs = ({
+  path,
+  name,
+  input,
+  output,
+  external,
+  pkgIsModule,
+  conditionals
+}: {
+  path: string
+  name: string
+  input: string
+  output: string
+  external: (string | RegExp)[]
+  pkgIsModule: boolean
+  conditionals: string[]
+}, options: TemplateOptions = {}): RollupOptions[] => {
+  const isModule = conditionals.includes('import')
+  const isCommonJS = conditionals.includes('require')
+  const isBrowser = conditionals.includes('browser')
+  const dtsTSConfigPaths = [
+    resolveWorkspacePath('tsconfig.json'),
+    resolveWorkspacePath('tsconfig.dts.json')
+  ]
+  let dtsTSConfigPath: string | undefined
+  dtsTSConfigPaths.forEach(p => {
+    if (fs.existsSync(p) && fs.statSync(p).isFile()) {
+      dtsTSConfigPath = p
+    }
+  })
+  let compilerOptions: ts.CompilerOptions = {}
+  if (dtsTSConfigPath) {
+    const jsonCompilerOptions = getCompilerOptionsByFilePath(dtsTSConfigPath, resolve(input))
+    const { options, errors } = ts.convertCompilerOptionsFromJson(
+      jsonCompilerOptions,
+      dirname(dtsTSConfigPath)
+    )
+    if (errors.length > 0) {
+      throw new Error(errors.map(e => e.messageText).join('\n'))
+    }
+    compilerOptions = options
+  }
+  const exportConditions = [...conditionals, ...(compilerOptions.customConditions ?? [])]
+  const throughEventProps: RollupProgressEvent & { type: 'progress' } = {
+    type: 'progress',
+    data: { name, path, exportConditions, input }
+  }
+  const outdir = options?.output?.dir
+  return [
+    {
+      input,
+      external,
+      output: [
+        ...withMinify({
+          file: output,
+          name,
+          interop: 'auto',
+          sourcemap: typeof options?.output?.sourcemap === 'object'
+            ? options.output.sourcemap.js
+            : options?.output?.sourcemap,
+          format: isModule ? 'esm' : (
+            isCommonJS ? 'cjs' : (
+              isBrowser ? 'umd' : (
+                pkgIsModule ? 'esm' : 'cjs'
+              )
+            )
+          ),
+          strict: typeof options?.output?.strict === 'object'
+            ? options.output.strict.js
+            : options?.output?.strict
+        })
+      ],
+      plugins: [
+        nodeResolve({ exportConditions }),
+        import('rollup-plugin-postcss')
+          .then(({ default: postcss }) =>
+            postcss({
+              extract: resolve(output.replace(/\.[cm]?js$/, '.css')),
+              minimize: true
+            })
+          )
+          .catch(() => void 0),
+        esbuild(),
+        commonjs(),
+        progress({
+          onEvent: (event, message) =>
+            sendMessage(
+              {
+                ...throughEventProps,
+                data: { ...throughEventProps.data, event, message, tags: ['js'] }
+              } satisfies RollupProgressEvent
+            )
+        })
+      ]
+    },
+    {
+      input,
+      external,
+      output: [
+        {
+          dir: resolve((typeof outdir === 'object' ? outdir.dts : outdir) ?? 'dist'),
+          sourcemap: typeof options?.output?.sourcemap === 'object'
+            ? options.output.sourcemap.dts
+            : options?.output?.sourcemap,
+          entryFileNames: () =>
+            output
+              .replace(`${jsOutdir}/`, '')
+              .replace(/(\.[cm]?)js$/, '.d$1ts'),
+          strict: typeof options?.output?.strict === 'object'
+            ? options.output.strict.dts
+            : options?.output?.strict
+        }
+      ],
+      plugins: [
+        nodeResolve({ exportConditions }),
+        skip({ patterns: [STYLE_REGEXP] }),
+        dts({
+          respectExternal: true,
+          compilerOptions
+        }),
+        progress({
+          onEvent: (event, message) =>
+            sendMessage(
+              {
+                ...throughEventProps,
+                data: { ...throughEventProps.data, event, message, tags: ['dts'] }
+              } satisfies RollupProgressEvent
+            )
+        })
+      ]
+    }
+  ]
+}
+
+export function template(packageJSON: PackageJSON): RollupOptions[] {
+  const { name, type, exports: entrypoints } = packageJSON
+  const pkgIsModule = type === 'module'
+  if (!name) throw new Error('package.json name is required')
+  if (!entrypoints) throw new Error('package.json exports is required')
+
+  const entries = JIEK_ENTRIES
+    ?.split(',')
+    .map(e => e.trim())
+    .map(e => ({
+      'index': '.'
+    }[e] ?? e))
+
+  const packageName = pascalCase(name)
+
+  const external = externalResolver(packageJSON as Record<string, unknown>)
+
+  const [filteredResolvedEntrypoints, exports] = getExports({
+    entrypoints,
+    pkgIsModule,
+    entries,
+    config
+  })
+
+  const leafMap = new Map<string, string[][]>()
+  getAllLeafs(filteredResolvedEntrypoints as RecursiveRecord<string>, ({ keys, value }) => {
+    if (typeof value === 'string') {
+      const keysArr = leafMap.get(value) ?? []
+      leafMap.set(value, keysArr)
+      keysArr.push(keys)
+    }
+    return false
+  })
+
+  const configs: RollupOptions[] = []
+  leafMap.forEach((keysArr, input) =>
+    keysArr.forEach((keys) => {
+      const [path, ...conditionals] = keys
+
+      const name = packageName + (path === '.' ? '' : pascalCase(path))
+      const keyExports = reveal(exports, keys)
+      const commonOptions = {
+        path,
+        name,
+        input,
+        external,
+        pkgIsModule
+      }
+
+      switch (typeof keyExports) {
+        case 'string': {
+          configs.push(...generateConfigs({
+            ...commonOptions,
+            output: keyExports,
+            conditionals
+          }, build))
+          break
+        }
+        case 'object': {
+          getAllLeafs(keyExports as RecursiveRecord<string>, ({ keys: nextKeys, value }) => {
+            const allConditionals = [...new Set([...conditionals, ...nextKeys])]
+            if (typeof value === 'string') {
+              configs.push(...generateConfigs({
+                ...commonOptions,
+                output: value,
+                conditionals: allConditionals
+              }, build))
+            }
+            return false
+          })
+          break
+        }
+      }
+    })
+  )
+  sendMessage(
+    {
+      type: 'init',
+      data: {
+        leafMap,
+        targetsLength: configs.length
+      }
+    } satisfies RollupProgressEvent
+  )
+  return configs.map(c => ({
+    ...COMMON_OPTIONS,
+    ...c,
+    plugins: [
+      ...COMMON_PLUGINS,
+      c.plugins
+    ]
+  }))
+}

package/src/rollup/plugins/globals.ts

@@ -0,0 +1,34 @@
+import type { Plugin, PluginImpl } from 'rollup'
+
+import globalResolver from '../utils/globalResolver'
+
+interface GlobalsOptions {
+  external?: (string | RegExp)[]
+}
+
+export function createGlobalsLinkage() {
+  let globals = {}
+  const dependencies = new Set<string>([])
+  return [
+    (({ external } = {}) => {
+      return {
+        name: 'globals',
+        resolveId(id) {
+          if (external?.some(dep => dep instanceof RegExp ? dep.test(id) : dep === id)) {
+            dependencies.add(id)
+            return { id, external: true }
+          }
+          return null
+        },
+        outputOptions(options) {
+          globals = [...dependencies].reduce((acc, value) => ({
+            ...acc,
+            [value]: globalResolver(value)
+          }), {})
+          return { ...options, globals }
+        }
+      }
+    }) as PluginImpl<GlobalsOptions>,
+    { outputOptions: options => ({ ...options, globals }) } as Plugin
+  ] as const
+}

package/src/rollup/plugins/progress.ts

@@ -0,0 +1,26 @@
+import type { PluginImpl } from 'rollup'
+
+interface Options {
+  onEvent?: (event: string, message?: string) => void
+}
+
+export default ((options = {}) => {
+  const { onEvent } = options
+  return {
+    name: 'progress',
+    buildStart: () => onEvent?.('start', 'Start building...'),
+    buildEnd: () => onEvent?.('end', 'Build completed!'),
+    resolveId: {
+      order: 'post',
+      handler: source => onEvent?.('resolve', `Resolving ${source}...`)
+    },
+    load: {
+      order: 'post',
+      handler: id => onEvent?.('load', `Loading ${id}...`)
+    },
+    transform: {
+      order: 'post',
+      handler: (_, id) => onEvent?.('transform', `Transforming ${id}...`)
+    }
+  }
+}) as PluginImpl<Options>

package/src/rollup/plugins/skip.ts

@@ -0,0 +1,23 @@
+import type { PluginImpl } from 'rollup'
+
+interface Options {
+  patterns?: (string | RegExp)[]
+}
+
+export default ((options = {}) => {
+  return {
+    name: 'skip',
+    // skip the specified files by `options.patterns`
+    load(id) {
+      if (
+        options.patterns?.some((pattern) =>
+          typeof pattern === 'string'
+            ? id.includes(pattern)
+            : pattern.test(id)
+        )
+      ) {
+        return ''
+      }
+    }
+  }
+}) as PluginImpl<Options>

package/src/rollup/utils/commonOptions.ts

@@ -0,0 +1,9 @@
+import type { OutputOptions } from 'rollup'
+
+const defineOutput = <O extends OutputOptions>(output: O) => output
+
+export const commonOutputOptions = defineOutput({
+  exports: 'named',
+  interop: 'auto',
+  sourcemap: true
+})

package/src/rollup/utils/externalResolver.ts

@@ -0,0 +1,21 @@
+import fs from 'node:fs'
+
+export default function(json: Record<string, unknown>): (string | RegExp)[]
+export default function(path?: string): (string | RegExp)[]
+export default function(jsonOrPath: string | Record<string, unknown> = process.cwd()): (string | RegExp)[] {
+  const pkg = typeof jsonOrPath === 'string'
+    ? fs.existsSync(`${jsonOrPath}/package.json`)
+      ? JSON.parse(fs.readFileSync(`${jsonOrPath}/package.json`, 'utf-8'))
+      : {}
+    : jsonOrPath
+  const { dependencies = {}, peerDependencies = {}, optionalDependencies = {} } = pkg
+  const external = <(string | RegExp)[]> Object
+    .keys(dependencies)
+    .concat(Object.keys(peerDependencies))
+    .concat(Object.keys(optionalDependencies))
+  return external
+    .map(dep => new RegExp(`^${dep}(/.*)?$`))
+    .concat([
+      /^node:/
+    ])
+}

package/src/rollup/utils/globalResolver.ts

@@ -0,0 +1,13 @@
+export default function (external: string) {
+  // a/b      => AB
+  // a-b      => AB
+  // a@b      => AB
+  // a@b/c    => ABC
+  // node:a   => a
+  // node:a_b => a_b
+  if (external.startsWith('node:')) {
+    return external.slice(5)
+  }
+  return external
+    .replace(/[@|/-](\w)/g, (_, $1) => $1.toUpperCase())
+}

package/src/rollup/utils/withMinify.ts

@@ -0,0 +1,18 @@
+import terser from '@rollup/plugin-terser'
+import type { OutputOptions, OutputPlugin } from 'rollup'
+
+export default function(
+  output: OutputOptions & {
+    entryFileNames?: string
+    plugins?: OutputPlugin[]
+  }
+): OutputOptions[] {
+  return [
+    output,
+    {
+      ...output,
+      entryFileNames: output.entryFileNames?.replace(/(\.[cm]?js)$/, '.min$1'),
+      plugins: [...(output.plugins ?? []), terser()]
+    }
+  ]
+}

package/src/utils/filterSupport.ts

@@ -0,0 +1,84 @@
+import fs from 'node:fs'
+import { createRequire } from 'node:module'
+import path from 'node:path'
+
+import { filterPackagesFromDir } from '@pnpm/filter-workspace-packages'
+import { program } from 'commander'
+import { load } from 'js-yaml'
+
+import { getRoot } from './getRoot'
+import { getWD } from './getWD'
+
+export let type = ''
+
+try {
+  const require = createRequire(import.meta.url)
+  require.resolve('@pnpm/filter-workspace-packages')
+  type = 'pnpm'
+} catch { /* empty */ }
+if (type !== '') {
+  program
+    .option('-f, --filter <filter>', 'filter packages')
+}
+
+interface ProjectsGraph {
+  wd: string
+  root: string
+  value?: Record<string, {
+    name?: string
+    type?: string
+    exports?: string | string[] | Record<string, unknown>
+  }>
+}
+
+export async function getSelectedProjectsGraph(): Promise<ProjectsGraph> {
+  let filter = program.getOptionValue('filter')
+  const root = getRoot()
+  const { wd, notWorkspace } = getWD()
+  if (!notWorkspace && type === 'pnpm') {
+    const pnpmWorkspaceFilePath = path.resolve(wd, 'pnpm-workspace.yaml')
+    const pnpmWorkspaceFileContent = fs.readFileSync(pnpmWorkspaceFilePath, 'utf-8')
+    const pnpmWorkspace = load(pnpmWorkspaceFileContent) as {
+      packages: string[]
+    }
+    if (root === wd && !filter) {
+      throw new Error('root path is workspace root, please provide a filter')
+      // TODO inquirer prompt support user select packages
+    }
+    if (root !== wd && !filter) {
+      const packageJSONIsExist = fs.existsSync(path.resolve(root, 'package.json'))
+      if (!packageJSONIsExist) {
+        throw new Error('root path is not workspace root, please provide a filter')
+      }
+      const packageJSON = JSON.parse(fs.readFileSync(path.resolve(root, 'package.json'), 'utf-8'))
+      if (!packageJSON.name) {
+        throw new Error('root path is not workspace root, please provide a filter')
+      }
+      filter = packageJSON.name
+    }
+    const { selectedProjectsGraph } = await filterPackagesFromDir(wd, [{
+      filter: filter ?? '',
+      followProdDepsOnly: true
+    }], {
+      prefix: root,
+      workspaceDir: wd,
+      patterns: pnpmWorkspace.packages
+    })
+    return {
+      wd,
+      root,
+      value: Object.entries(selectedProjectsGraph)
+        .reduce((acc, [key, value]) => {
+          acc[key] = value.package.manifest
+          return acc
+        }, {} as NonNullable<ProjectsGraph['value']>)
+    }
+  }
+  return {
+    wd,
+    root,
+    value: {
+      [wd]: JSON.parse(fs.readFileSync(path.resolve(wd, 'package.json'), 'utf-8'))
+    }
+  }
+}