jiek 2.3.3 → 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,185 +0,0 @@
-import { extname } from 'node:path'
-
-import type { Lang, SgNode } from '@ast-grep/napi'
-import type { FilterOptions } from 'jiek/rollup-plugin-utils'
-import { createFilter, definePlugin } from 'jiek/rollup-plugin-utils'
-import MagicString from 'magic-string'
-
-export type Mode = 'string' | 'ast-grep'
-
-export type ReplacementFuncCtx =
-  & {
-    type: 'transform' | 'renderChunk'
-    id: string
-    code: string
-    mode: Mode
-  }
-  & (
-    | {
-      mode?: 'string'
-      start: number
-      end: number
-    }
-    | {
-      mode?: 'ast-grep'
-      $:
-        & ((name: string) => string | undefined)
-        & ((template: { raw: readonly string[] }) => string | undefined)
-      node: SgNode
-      lang: Lang
-    }
-  )
-
-type Falsy = false | null | undefined
-
-export type ReplacementFunc = (ctx: ReplacementFuncCtx) => string | Falsy
-
-export type Replacements = Record<
-  string,
-  string | Falsy | ReplacementFunc
->
-
-export type ReplaceOptions =
-  & FilterOptions
-  & {
-    /**
-     * @default 'string'
-     */
-    mode?: Mode
-    sourcemap?: boolean
-    values?: Replacements
-  }
-
-export default definePlugin((options: ReplaceOptions = {}) => {
-  const {
-    include = [/\.[cm]?[tj]sx?$/],
-    exclude = [/node_modules/],
-    values = {},
-    sourcemap
-  } = options
-  let { mode = 'string' } = options
-  const allValues = { ...values }
-  const allKeys = Object.keys(allValues)
-  const filter = createFilter({ include, exclude })
-
-  const replaceAll = async (ctx: Pick<ReplacementFuncCtx, 'type' | 'id'>, code: string) => {
-    const ms = new MagicString(code)
-    if (mode === 'string') {
-      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
-          const value = typeof allValues[key] === 'function'
-            ? allValues[key]({
-              ...ctx,
-              code,
-              start,
-              end,
-              mode: 'string'
-            })
-            : allValues[key]
-          if (([null, undefined, false] as unknown[]).includes(value)) continue
-          ms.overwrite(
-            match.index,
-            match.index + key.length,
-            value as string
-          )
-        }
-      })
-    } else if (mode === 'ast-grep') {
-      const ext = extname(ctx.id)
-      const { parse, Lang } = await import('@ast-grep/napi')
-      let lang: Lang | undefined
-      if (/[cm]?tsx?/.test(ext)) {
-        lang = Lang.TypeScript
-      }
-      if (/[cm]?jsx?/.test(ext)) {
-        lang = Lang.JavaScript
-      }
-      if (/json?/.test(ext)) {
-        lang = Lang.Json
-      }
-      if (lang == null) return
-      const root = parse(lang, code).root()
-      allKeys.forEach(key => {
-        root
-          .findAll(key)
-          .forEach(node => {
-            const { start, end } = node.range()
-            const newValue = typeof allValues[key] === 'function'
-              ? allValues[key]({
-                ...ctx,
-                code,
-                mode: 'ast-grep',
-                node,
-                lang,
-                $: (input) => {
-                  if (typeof input === 'string') {
-                    return node.getMatch(input)?.text()
-                  }
-                  if ('raw' in input) {
-                    return node.getMatch(input.raw[0])?.text()
-                  }
-                }
-              })
-              : allValues[key]
-            if (([null, undefined, false] as unknown[]).includes(newValue)) return
-            ms.overwrite(
-              start.index,
-              end.index,
-              newValue as string
-            )
-          })
-      })
-    }
-    return ms
-  }
-
-  return {
-    name: 'jiek:replace',
-    buildStart() {
-      if (mode === 'ast-grep') {
-        try {
-          require.resolve('@ast-grep/napi')
-          this.warn(
-            'You are using `ast-grep` mode, please make sure you have installed `@ast-grep/napi`'
-          )
-        } catch {
-          mode = 'string'
-        }
-      }
-    },
-    transform: {
-      order: 'pre',
-      async handler(code, id) {
-        if (allKeys.length === 0) return
-        if (filter(id)) return
-        const ms = await replaceAll({ type: 'transform', id }, code)
-        if (ms == null) return
-
-        return {
-          code: ms.toString(),
-          map: sourcemap ? ms.generateMap({ hires: true }) : null
-        }
-      }
-    },
-    renderChunk: {
-      order: 'post',
-      async handler(code, { fileName: id }) {
-        if (allKeys.length === 0) return
-        if (filter(id)) return
-
-        const ms = await 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)))