jiek 2.3.1 → 2.3.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jiek",
   "type": "module",
-  "version": "2.3.1",
+  "version": "2.3.3",
   "description": "A lightweight toolkit for compiling and managing libraries based on `package.json` metadata and suitable for `Monorepo`.",
   "author": "YiJie <yijie4188@gmail.com>",
   "homepage": "https://github.com/NWYLZW/jiek/tree/master/packages/jiek#readme",
@@ -35,6 +35,11 @@
       "jiek/__source__": "./src/rollup/index.ts",
       "require": "./dist/rollup/index.cjs",
       "default": "./dist/rollup/index.js"
+    },
+    "./rollup-plugin-utils": {
+      "jiek/__source__": "./src/rollup-plugin-utils.ts",
+      "require": "./dist/rollup-plugin-utils.cjs",
+      "default": "./dist/rollup-plugin-utils.js"
     }
   },
   "imports": {
@@ -51,6 +56,7 @@
     "jb": "bin/build.cjs"
   },
   "peerDependencies": {
+    "@ast-grep/napi": "^0.32.3",
     "@pnpm/filter-workspace-packages": "^7.2.13||^8.0.0||^9.0.0||^10.0.0||>=1000.0.0",
     "@rollup/plugin-terser": "^0.4.4",
     "esbuild-register": "^3.5.0",
@@ -74,14 +80,15 @@
     "js-yaml": "^4.1.0",
     "jsonc-parser": "^3.2.1",
     "koa": "^2.15.3",
+    "magic-string": "^0.30.17",
     "rollup": "^4.0.0",
     "@jiek/pkger": "^0.2.2",
     "@jiek/utils": "^0.2.3"
   },
-  "publishConfig": {
-    "directory": "./dist/.internal"
-  },
   "peerDependenciesMeta": {
+    "@ast-grep/napi": {
+      "optional": true
+    },
     "@pnpm/filter-workspace-packages": {
       "optional": true
     },

package/rollup-plugin-utils/package.json

@@ -0,0 +1 @@
+{"type":"module","module":"../dist/rollup-plugin-utils.js","main":"../dist/rollup-plugin-utils.cjs"}

package/src/rollup/base.ts

@@ -1,4 +1,5 @@
 import type { InputPluginOption, OutputOptions } from 'rollup'
+import { ReplaceOptions, Replacements } from './plugins/replace'
 
 export type Mapping2ROO<K extends keyof OutputOptions> = OutputOptions[K] | {
   js?: OutputOptions[K]
@@ -134,4 +135,18 @@ export interface TemplateOptions {
    * ```
    */
   injects?: Record<string, string | [string, string]>
+  /**
+   * Replace the specified content in the code.
+   *
+   * @example
+   * ```js
+   * {
+   *   'process.env.DEBUG': 'false',
+   *   'process.env.NODE_ENV': JSON.stringify('production'),
+   *   'process.env.BUILD_PATH': ctx => JSON.stringify(ctx.id)
+   * }
+   * ```
+   */
+  replacements?: Replacements
+  replacementsOptions?: Pick<ReplaceOptions, 'mode' | 'include' | 'exclude'>
 }

package/src/rollup/index.ts

@@ -27,6 +27,7 @@ import { getCompilerOptionsByFilePath } from '#~/utils/ts'
 import type { ConfigGenerateContext, TemplateOptions } from './base'
 import createRequire, { CREATE_REQUIRE_VIRTUAL_MODULE_NAME } from './plugins/create-require'
 import progress from './plugins/progress'
+import replace from './plugins/replace'
 import skip from './plugins/skip'
 import withExternal from './plugins/with-external.ts'
 import type { PackageJSON } from './utils/externalResolver'
@@ -423,7 +424,14 @@ const generateConfigs = (
   const { js: jsOutput, dts: dtsOutput } = resolveOutputControls(context, build.output)
   const rollupOptions: RollupOptions[] = []
 
-  const commonPlugins: InputPluginOption[] = [
+  const commonPlugins = (
+    { sourcemap }: { sourcemap?: string | boolean }
+  ): InputPluginOption[] => [
+    replace({
+      ...build.replacementsOptions,
+      sourcemap: sourcemap === 'hidden' ? false : !!sourcemap,
+      values: build.replacements
+    }),
     ...inputCommonPlugins,
     withExternal(),
     !disableCollectInternalModule && {
@@ -570,7 +578,7 @@ const generateConfigs = (
         )
       ],
       plugins: [
-        ...commonPlugins,
+        ...commonPlugins({ sourcemap }),
         nodeResolvePluginInstance,
         import('rollup-plugin-postcss')
           .then(({ default: postcss }) =>
@@ -630,7 +638,7 @@ const generateConfigs = (
         }
       ],
       plugins: [
-        ...commonPlugins,
+        ...commonPlugins({ sourcemap }),
         skip({ patterns: [STYLE_REGEXP] }),
         dts({
           respectExternal: true,

package/src/rollup/plugins/replace.ts

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

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