jiek 2.3.2 → 2.3.4

package/src/rollup/plugins/create-require.ts

@@ -1,23 +0,0 @@
-import type { Plugin } from 'rollup'
-
-export const CREATE_REQUIRE_VIRTUAL_MODULE_NAME = 'jiek:create-require'
-
-const INSERT_STR = (isESM: boolean) =>
-  `
-${isESM ? `import { createRequire } from 'node:module'` : ''}
-export default ${isESM ? '/* @__PURE__ */ createRequire(import.meta.url)' : 'require'}
-`.trim()
-
-export default (isEsm: boolean): Plugin => ({
-  name: 'create-require',
-  resolveId: id => (
-    id === CREATE_REQUIRE_VIRTUAL_MODULE_NAME
-      ? id
-      : null
-  ),
-  load: id => (
-    id === CREATE_REQUIRE_VIRTUAL_MODULE_NAME
-      ? INSERT_STR(isEsm)
-      : null
-  )
-})

package/src/rollup/plugins/progress.ts

@@ -1,26 +0,0 @@
-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/replace.ts

@@ -1,96 +0,0 @@
-import type { FilterOptions } from 'jiek/rollup-plugin-utils'
-import { createFilter, definePlugin } from 'jiek/rollup-plugin-utils'
-import MagicString from 'magic-string'
-
-export interface ReplacementFuncCtx {
-  type: 'transform' | 'renderChunk'
-  id: string
-  code: string
-  start: number
-  end: number
-}
-
-export type ReplacementFunc = (ctx: ReplacementFuncCtx) => string
-
-export type Replacements = Record<
-  string,
-  string | ReplacementFunc
->
-
-export type Options =
-  & FilterOptions
-  & {
-    sourcemap?: boolean
-    values?: Replacements
-  }
-
-export default definePlugin((options: Options = {}) => {
-  const {
-    include = [/\.[cm]?[tj]sx?$/],
-    exclude = [/node_modules/],
-    values = {},
-    sourcemap
-  } = options
-  const allValues = { ...values }
-  const allKeys = Object.keys(allValues)
-  const filter = createFilter({ include, exclude })
-
-  const replaceAll = (ctx: Pick<ReplacementFuncCtx, 'type' | 'id'>, code: string) => {
-    const ms = new MagicString(code)
-    allKeys.forEach(key => {
-      const reg = new RegExp(key, 'g')
-      let match
-      // eslint-disable-next-line no-cond-assign
-      while ((match = reg.exec(code))) {
-        const start = match.index
-        const end = start + key.length
-        ms.overwrite(
-          match.index,
-          match.index + key.length,
-          typeof allValues[key] === 'function'
-            ? allValues[key]({
-              ...ctx,
-              code,
-              start,
-              end
-            })
-            : allValues[key]
-        )
-      }
-    })
-    return ms
-  }
-
-  return {
-    name: 'jiek:replace',
-    transform: {
-      order: 'pre',
-      handler(code, id) {
-        if (allKeys.length === 0) return
-        if (filter(id)) return
-        const ms = replaceAll({ type: 'transform', id }, code)
-        if (ms == null) return
-
-        return {
-          code: ms.toString(),
-          map: sourcemap ? ms.generateMap({ hires: true }) : null
-        }
-      }
-    },
-    renderChunk: {
-      order: 'post',
-      handler(code, { fileName: id }) {
-        if (allKeys.length === 0) return
-        if (filter(id)) return
-
-        const ms = replaceAll({ type: 'renderChunk', id }, code)
-        if (ms == null) return
-
-        return {
-          code: ms.toString(),
-          map: sourcemap ? ms.generateMap({ hires: true }) : null
-        }
-      }
-    }
-  }
-})

package/src/rollup/plugins/skip.ts

@@ -1,21 +0,0 @@
-import type { PluginImpl } from 'rollup'
-
-interface Options {
-  patterns?: (string | RegExp)[]
-}
-
-export default ((options = {}) => ({
-  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/plugins/with-external.ts

@@ -1,23 +0,0 @@
-import type { PluginImpl } from 'rollup'
-
-export default (() => ({
-  name: 'jiek:with-external',
-  resolveId: {
-    order: 'pre',
-    handler: (source, _, { attributes }) => {
-      if (
-        'external' in attributes || 'bundle' in attributes
-      ) {
-        delete attributes.external
-        delete attributes.bundle
-        return {
-          id: source,
-          external: attributes.external === 'true'
-            ? true
-            : attributes.bundle !== 'true',
-          attributes
-        }
-      }
-    }
-  }
-})) as PluginImpl<{}>

package/src/rollup/utils/commonOptions.ts

@@ -1,9 +0,0 @@
-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

@@ -1,47 +0,0 @@
-import fs from 'node:fs'
-import { builtinModules } from 'node:module'
-import process from 'node:process'
-
-const EXCLUDE_SUFFIX = [
-  'te?xt',
-  'json',
-  '(css|s[ac]ss|less|styl)'
-]
-
-export interface PackageJSON {
-  name: string
-  type?: string
-  bin?: string | Record<string, string>
-  exports?: Record<string, unknown> | string | string[]
-  imports?: Record<string, unknown>
-  dependencies?: Record<string, unknown>
-  peerDependencies?: Record<string, unknown>
-  optionalDependencies?: Record<string, unknown>
-}
-
-export default function(json: PackageJSON): (string | RegExp)[]
-export default function(path?: string): (string | RegExp)[]
-export default function(jsonOrPath: string | PackageJSON = process.cwd()): (string | RegExp)[] {
-  const pkg: PackageJSON = typeof jsonOrPath === 'string'
-    ? fs.existsSync(`${jsonOrPath}/package.json`)
-      ? JSON.parse(fs.readFileSync(`${jsonOrPath}/package.json`, 'utf-8')) as PackageJSON
-      : {} as PackageJSON
-    : jsonOrPath
-  const { name, dependencies = {}, peerDependencies = {}, optionalDependencies = {} } = pkg
-  if (name == null) {
-    throw new Error('package.json must have a name field')
-  }
-
-  const external = (<(string | RegExp)[]> [])
-    .concat(Object.keys(dependencies))
-    .concat(Object.keys(peerDependencies))
-    .concat(Object.keys(optionalDependencies))
-    .concat(builtinModules)
-
-  return [...new Set(external)]
-    .map(dep => new RegExp(`^${dep}(/.*)?$`))
-    .concat([
-      new RegExp(`^${name}(/.*)?(?<!${EXCLUDE_SUFFIX.map(suffix => `\\.${suffix}`).join('|')})$`),
-      /^node:/
-    ])
-}

package/src/rollup/utils/globalResolver.ts

@@ -1,13 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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/rollup-plugin-utils.ts

@@ -1,32 +0,0 @@
-import { isMatch } from 'micromatch'
-import type { PluginImpl } from 'rollup'
-
-export const definePlugin = <O extends object>(plugin: PluginImpl<O>) => plugin
-
-export interface FilterOptions {
-  include?: string | RegExp | (string | RegExp)[]
-  exclude?: string | RegExp | (string | RegExp)[]
-}
-
-export function createFilter(options: FilterOptions) {
-  const { include = [], exclude = [] } = options
-
-  const resolvedInclude = Array.isArray(include) ? include : [include]
-  const resolvedExclude = Array.isArray(exclude) ? exclude : [exclude]
-
-  return (id: string) => {
-    if (typeof id !== 'string') return false
-    const isInclude = resolvedInclude.length === 0 || resolvedInclude.some(filter => {
-      return filter instanceof RegExp
-        ? filter.test(id)
-        : isMatch(id, filter)
-    })
-    const isExclude = resolvedExclude.length > 0 && resolvedExclude.some(filter => {
-      return filter instanceof RegExp
-        ? filter.test(id)
-        : isMatch(id, filter)
-    })
-
-    return !isInclude || isExclude
-  }
-}

package/src/server.ts

@@ -1,30 +0,0 @@
-import Koa from 'koa'
-
-export const createServer = (port: number, host: string) => {
-  const app = new Koa()
-  app.listen(port, host)
-  const streams = new Map<string, string>()
-  app.use(async (ctx) => {
-    let stream = streams.get(ctx.path)
-    if (stream == null) {
-      const maybeKey = streams
-        .keys()
-        .find(p => ctx.path.startsWith(p))
-      stream = maybeKey != null
-        ? streams.get(maybeKey)
-        : undefined
-    }
-    if (stream != null) {
-      ctx.body = stream
-    }
-  })
-  // noinspection HttpUrlsUsage
-  return {
-    port,
-    host,
-    rootUrl: `http://${host}:${port}`,
-    renderTo: async (path: string, stream: string) => {
-      streams.set(path, stream)
-    }
-  }
-}

package/src/utils/checkDependency.ts

@@ -1,26 +0,0 @@
-import { execSync } from 'node:child_process'
-import process from 'node:process'
-
-import { confirm } from '@inquirer/prompts'
-
-import { getWD } from '#~/utils/getWD'
-
-export async function checkDependency(dependency: string) {
-  try {
-    require.resolve(dependency)
-  } catch {
-    console.error(`The package '${dependency}' is not installed, please install it first.`)
-    const { notWorkspace } = getWD()
-    const command = `pnpm add -${notWorkspace ? '' : 'w'}D ${dependency}`
-    if (await confirm({ message: `Do you want to add it now? (${command})` })) {
-      execSync(command, {
-        stdio: 'inherit',
-        cwd: process.cwd(),
-        env: process.env
-      })
-    } else {
-      console.warn(`You can run the command '${command}' to install it manually.`)
-      process.exit(1)
-    }
-  }
-}

package/src/utils/filterSupport.ts

@@ -1,90 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import process from 'node:process'
-
-import { program } from 'commander'
-import { load } from 'js-yaml'
-
-import { getRoot } from '#~/utils/getRoot'
-import { getWD } from '#~/utils/getWD'
-
-export let type = ''
-
-try {
-  require.resolve('@pnpm/filter-workspace-packages')
-  type = 'pnpm'
-} catch { /* empty */ }
-
-export interface Manifest {
-  name?: string
-  type?: string
-  exports?: string | string[] | Record<string, unknown>
-  imports?: Record<string, unknown>
-}
-
-export interface ProjectsGraph {
-  root?: string
-  value?: Record<string, Manifest>
-}
-
-export async function filterPackagesGraph(filters: string[]): Promise<ProjectsGraph[]> {
-  return Promise.all(filters.map(async filter => getSelectedProjectsGraph(filter)))
-}
-
-export async function getSelectedProjectsGraph(
-  filter = program.getOptionValue('filter') as string | undefined
-): Promise<ProjectsGraph> {
-  const { wd, notWorkspace } = getWD()
-  let root = getRoot()
-  if (notWorkspace) {
-    return {
-      root,
-      value: {
-        [wd]: JSON.parse(fs.readFileSync(path.resolve(wd, 'package.json'), 'utf-8')) as Manifest
-      }
-    }
-  }
-  if (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 == null)) {
-      throw new Error('root path is workspace root, please provide a filter')
-      // TODO inquirer prompt support user select packages
-    }
-    if (root === undefined) {
-      root = process.cwd()
-    }
-    if (root !== wd && (filter == null)) {
-      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')) as Manifest
-      if (packageJSON.name == null) {
-        throw new Error('root path is not workspace root, please provide a filter')
-      }
-      filter = packageJSON.name
-    }
-    const { filterPackagesFromDir } = await import('@pnpm/filter-workspace-packages')
-    const { selectedProjectsGraph } = await filterPackagesFromDir(wd, [{
-      filter: filter ?? '',
-      followProdDepsOnly: true
-    }], {
-      prefix: root,
-      workspaceDir: wd,
-      patterns: pnpmWorkspace.packages
-    })
-    return {
-      root,
-      value: Object.entries(selectedProjectsGraph)
-        .reduce((acc, [key, value]) => {
-          acc[key] = value.package.manifest
-          return acc
-        }, {} as NonNullable<ProjectsGraph['value']>)
-    }
-  }
-  throw new Error(`not supported package manager ${type}`)
-}

package/src/utils/getInternalModuleName.ts

@@ -1,5 +0,0 @@
-export const getInternalModuleName = (pkgName: string) => (`${
-  (
-    pkgName.startsWith('@') ? pkgName : `@${pkgName}`
-  ).replace('/', '+')
-}/__internal__`)

package/src/utils/getRoot.ts

@@ -1,14 +0,0 @@
-import path from 'node:path'
-
-let root: string | undefined
-export function getRoot() {
-  if (root) return root
-
-  const rootOption = process.env.JIEK_ROOT
-  root = rootOption
-    ? path.isAbsolute(rootOption)
-      ? rootOption
-      : path.resolve(process.cwd(), rootOption)
-    : undefined
-  return root
-}

package/src/utils/getWD.ts

@@ -1,31 +0,0 @@
-import { getWorkspaceDir, isWorkspaceDir } from '@jiek/utils/getWorkspaceDir'
-
-import { type } from './filterSupport'
-import { getRoot } from './getRoot'
-
-let wd: string
-let notWorkspace = false
-
-export function getWD() {
-  if (wd) return { wd, notWorkspace }
-
-  const root = getRoot()
-  if (root !== undefined) {
-    const isWorkspace = isWorkspaceDir(root, type)
-    notWorkspace = !isWorkspace
-    wd = root
-    return { wd, notWorkspace }
-  }
-  try {
-    wd = getWorkspaceDir(type)
-  } catch (e) {
-    // @ts-ignore
-    if ('message' in e && e.message === 'workspace root not found') {
-      wd = root ?? process.cwd()
-      notWorkspace = true
-    } else {
-      throw e
-    }
-  }
-  return { wd, notWorkspace }
-}

package/src/utils/intersection.ts

@@ -1 +0,0 @@
-export const intersection = <T>(a: Iterable<T>, b: Set<T>) => new Set([...a].filter(i => b.has(i)))

package/src/utils/loadConfig.ts

@@ -1,108 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-
-import { program } from 'commander'
-import type { Config } from 'jiek'
-import { load } from 'js-yaml'
-
-import { getWD } from './getWD'
-import { tsRegisterName } from './tsRegister'
-
-let configName = 'jiek.config'
-
-function getConfigPath(root: string, dir?: string) {
-  const isSupportTsLoader = !!tsRegisterName
-  function configWithExtIsExist(ext: string) {
-    const filenames = [
-      path.resolve(process.cwd(), `${configName}.${ext}`),
-      path.resolve(process.cwd(), `.${configName}.${ext}`),
-      path.resolve(root, `${configName}.${ext}`),
-      path.resolve(root, `.${configName}.${ext}`)
-    ]
-    if (dir) {
-      filenames.unshift(...[
-        path.resolve(dir, `${configName}.${ext}`),
-        path.resolve(dir, `.${configName}.${ext}`)
-      ])
-    }
-    for (const filename of filenames) {
-      if (
-        fs.existsSync(filename)
-        && fs.lstatSync(filename)
-          .isFile()
-      ) {
-        return filename
-      }
-    }
-    return
-  }
-  configName = configWithExtIsExist('js') ?? configName
-  configName = configWithExtIsExist('json') ?? configName
-  configName = configWithExtIsExist('yaml') ?? configName
-  if (isSupportTsLoader) {
-    configName = configWithExtIsExist('ts') ?? configName
-  }
-  return path.resolve(root, configName)
-}
-
-interface LoadConfigOptions {
-  dir?: string
-  root?: string
-}
-
-export function loadConfig(options?: LoadConfigOptions): Config
-export function loadConfig(dir?: string): Config
-export function loadConfig(dirOrOptions?: string | LoadConfigOptions): Config {
-  let dir: string | undefined
-  let root: string
-  if (typeof dirOrOptions === 'object') {
-    dir = dirOrOptions.dir
-    root = dirOrOptions.root ?? getWD().wd
-  } else {
-    dir = dirOrOptions
-    root = getWD().wd
-  }
-
-  let configPath = program.getOptionValue('configPath')
-
-  if (!configPath) {
-    configPath = getConfigPath(root, dir)
-  } else {
-    if (!fs.existsSync(configPath)) {
-      throw new Error(`config file not found: ${configPath}`)
-    }
-    if (!path.isAbsolute(configPath)) {
-      configPath = path.resolve(root, configPath)
-    }
-  }
-  const ext = path.extname(configPath)
-
-  let module: any
-  switch (ext) {
-    case '.js':
-      module = require(configPath)
-      break
-    case '.json':
-      return require(configPath)
-    case '.yaml':
-      return load(fs.readFileSync(configPath, 'utf-8')) as Config
-    case '.ts':
-      if (tsRegisterName) {
-        require(tsRegisterName)
-        module = require(configPath)
-        break
-      }
-      throw new Error(
-        'ts config file is not supported without ts register, '
-          + 'please install esbuild-register or set JIEK_TS_REGISTER env for custom ts register'
-      )
-    case '.config':
-      module = {}
-      break
-    default:
-      throw new Error(`unsupported config file type: ${ext}`)
-  }
-  if (!module) throw new Error('config file is empty')
-
-  return module.default ?? module
-}

package/src/utils/recursiveListFiles.ts

@@ -1,13 +0,0 @@
-import fs from 'node:fs'
-import { resolve } from 'node:path'
-
-export const recursiveListFiles = (dir: string): string[] =>
-  fs.readdirSync(dir).reduce((acc, file) => {
-    const filePath = resolve(dir, file)
-    if (fs.statSync(filePath).isDirectory()) {
-      if (filePath.endsWith('/node_modules')) return acc
-
-      return [...acc, ...recursiveListFiles(filePath)]
-    }
-    return [...acc, filePath]
-  }, [] as string[])