@reliverse/dler 1.2.0

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/build.js

@@ -0,0 +1,322 @@
+import { relinka } from "@reliverse/relinka";
+import { defu } from "defu";
+import { createHooks } from "hookable";
+import { createJiti } from "jiti";
+import { promises as fsp } from "node:fs";
+import Module from "node:module";
+import { isAbsolute, normalize, relative, resolve } from "pathe";
+import prettyBytes from "pretty-bytes";
+import prettyMilliseconds from "pretty-ms";
+import { glob } from "tinyglobby";
+import {
+  createPerfTimer,
+  getElapsedPerfTime
+} from "../../../utils/utils-perf.js";
+import { copyBuild } from "./copy/copy.js";
+import { mkdistBuild } from "./mkdist/mkdist.js";
+import { rollupBuild } from "./rollup/build.js";
+import { typesBuild } from "./untyped/index.js";
+import {
+  dumpObject,
+  inferPkgExternals,
+  removeExtension,
+  resolvePreset,
+  rmdir,
+  withTrailingSlash
+} from "./utils.js";
+import { validateDependencies, validatePackage } from "./validate.js";
+export async function build(rootDir, inputConfig, outDir, transpileStub = false) {
+  const resolvedRootDir = resolve(process.cwd(), rootDir || ".");
+  const jiti = createJiti(resolvedRootDir);
+  const _buildConfig = await jiti.import(inputConfig?.config || ".config/dler.ts", {
+    default: true,
+    try: !inputConfig.config
+  }) || {};
+  const buildConfigs = (Array.isArray(_buildConfig) ? _buildConfig : [_buildConfig]).filter(Boolean);
+  const pkg = await jiti.import("./package.json", {
+    default: true,
+    try: true
+  }) || {};
+  const cleanedDirs = [];
+  const _transpileWatchMode = inputConfig.transpileWatch === true;
+  const _transpileStubMode = !_transpileWatchMode && (transpileStub || inputConfig.transpileStub === true);
+  if (!_transpileWatchMode && !_transpileStubMode) {
+    Object.assign(pkg, pkg.publishConfig);
+  }
+  for (const buildConfig of buildConfigs) {
+    await _build(
+      resolvedRootDir,
+      inputConfig,
+      buildConfig,
+      pkg,
+      cleanedDirs,
+      _transpileStubMode,
+      _transpileWatchMode,
+      outDir,
+      inputConfig.showOutLog || true
+    );
+  }
+}
+async function _build(rootDir, inputConfig, buildConfig, pkg, cleanedDirs, _transpileStubMode, _transpileWatchMode, outDir, showOutLog) {
+  const timer = createPerfTimer();
+  const preset = await resolvePreset(
+    buildConfig.preset || pkg.dler?.preset || pkg.build?.preset || inputConfig.preset || "auto",
+    rootDir
+  );
+  const options = defu(
+    buildConfig,
+    pkg.dler || pkg.build,
+    inputConfig,
+    preset,
+    {
+      alias: {},
+      clean: true,
+      declaration: void 0,
+      dependencies: [],
+      devDependencies: [],
+      entries: [],
+      externals: [
+        ...Module.builtinModules,
+        ...Module.builtinModules.map((m) => `node:${m}`)
+      ],
+      failOnWarn: true,
+      name: (pkg?.name || "").split("/").pop() || "default",
+      outDir,
+      parallel: false,
+      peerDependencies: [],
+      replace: {},
+      rollup: {
+        alias: {},
+        cjsBridge: false,
+        commonjs: {
+          ignoreTryCatch: true
+        },
+        dts: {
+          compilerOptions: {
+            /**
+             * @see https://github.com/Swatinem/rollup-plugin-dts/issues/127
+             */
+            composite: false,
+            /**
+             * @see https://github.com/Swatinem/rollup-plugin-dts/issues/143
+             */
+            preserveSymlinks: false
+          },
+          respectExternal: true
+        },
+        emitCJS: false,
+        esbuild: { target: "esnext" },
+        inlineDependencies: false,
+        json: {
+          preferConst: true
+        },
+        output: {
+          /**
+           * @see https://v8.dev/features/import-attributes
+           */
+          importAttributesKey: "with"
+        },
+        preserveDynamicImports: true,
+        // Plugins
+        replace: {
+          preventAssignment: true
+        },
+        resolve: {
+          preferBuiltins: true
+        },
+        watch: false
+      },
+      rootDir,
+      showOutLog: true,
+      transpileSourcemap: false,
+      transpileStub: _transpileStubMode,
+      transpileStubOptions: {
+        /**
+         * @see https://github.com/unjs/jiti#%EF%B8%8F-options
+         */
+        jiti: {
+          alias: {},
+          interopDefault: true
+        }
+      },
+      transpileWatch: _transpileWatchMode,
+      transpileWatchOptions: _transpileWatchMode ? {
+        exclude: "node_modules/**",
+        include: "src/**"
+      } : void 0
+    }
+  );
+  options.outDir = resolve(options.rootDir, options.outDir);
+  const jiti = createJiti(options.rootDir, { interopDefault: true });
+  const ctx = {
+    buildEntries: [],
+    hooks: createHooks(),
+    jiti,
+    options,
+    pkg,
+    usedImports: /* @__PURE__ */ new Set(),
+    warnings: /* @__PURE__ */ new Set()
+  };
+  if (preset.hooks) {
+    ctx.hooks.addHooks(preset.hooks);
+  }
+  if (inputConfig.hooks) {
+    ctx.hooks.addHooks(inputConfig.hooks);
+  }
+  if (buildConfig.hooks) {
+    ctx.hooks.addHooks(buildConfig.hooks);
+  }
+  await ctx.hooks.callHook("build:prepare", ctx);
+  options.entries = options.entries.map(
+    (entry) => typeof entry === "string" ? { input: entry } : entry
+  );
+  for (const entry of options.entries) {
+    if (typeof entry.name !== "string") {
+      let relativeInput = isAbsolute(entry.input) ? relative(rootDir, entry.input) : normalize(entry.input);
+      if (relativeInput.startsWith("./")) {
+        relativeInput = relativeInput.slice(2);
+      }
+      entry.name = removeExtension(relativeInput.replace(/^src\//, ""));
+    }
+    if (!entry.input) {
+      throw new Error(`Missing entry input: ${dumpObject(entry)}`);
+    }
+    if (!entry.builder) {
+      entry.builder = entry.input.endsWith("/") ? "mkdist" : "rollup";
+    }
+    if (options.declaration !== void 0 && entry.declaration === void 0) {
+      entry.declaration = options.declaration;
+    }
+    entry.input = resolve(options.rootDir, entry.input);
+    entry.outDir = resolve(options.rootDir, entry.outDir || options.outDir);
+  }
+  options.dependencies = Object.keys(pkg.dependencies || {});
+  options.peerDependencies = Object.keys(pkg.peerDependencies || {});
+  options.devDependencies = Object.keys(pkg.devDependencies || {});
+  options.externals.push(...inferPkgExternals(pkg));
+  options.externals = [...new Set(options.externals)];
+  await ctx.hooks.callHook("build:before", ctx);
+  relinka(
+    "verbose",
+    `${options.transpileStub ? "Stubbing" : "[unified] Building"} ${options.name}`
+  );
+  if (process.env.DEBUG) {
+    relinka(
+      "info",
+      `Root dir: ${options.rootDir}
+Entries:
+${options.entries.map((entry) => `  ${dumpObject(entry)}`).join("\n  ")}
+`
+    );
+  }
+  if (options.clean) {
+    for (const dir of new Set(
+      options.entries.map((e) => e.outDir).filter((p) => !!p).sort()
+    )) {
+      if (dir === options.rootDir || options.rootDir.startsWith(withTrailingSlash(dir)) || cleanedDirs.some((c) => dir.startsWith(c))) {
+        continue;
+      }
+      cleanedDirs.push(dir);
+      relinka(
+        "info",
+        `Cleaning dist directory: \`./${relative(process.cwd(), dir)}\``
+      );
+      await rmdir(dir);
+      await fsp.mkdir(dir, { recursive: true });
+    }
+  }
+  const buildTasks = [
+    typesBuild,
+    // untyped
+    mkdistBuild,
+    // mkdist
+    rollupBuild,
+    // rollup
+    copyBuild
+    // copy
+  ];
+  if (options.parallel) {
+    await Promise.all(buildTasks.map((task) => task(ctx)));
+  } else {
+    for (const task of buildTasks) {
+      await task(ctx);
+    }
+  }
+  if (options.transpileStub || options.transpileWatch) {
+    await ctx.hooks.callHook("build:done", ctx);
+    return;
+  }
+  relinka("success", `Build succeeded for ${options.name}`);
+  const outFiles = await glob(["**"], { cwd: options.outDir });
+  for (const file of outFiles) {
+    let entry = ctx.buildEntries.find((e) => e.path === file);
+    if (!entry) {
+      entry = {
+        chunk: true,
+        path: file
+      };
+      ctx.buildEntries.push(entry);
+    }
+    if (!entry.bytes) {
+      const stat = await fsp.stat(resolve(options.outDir, file));
+      entry.bytes = stat.size;
+    }
+  }
+  const rPath = (p) => relative(process.cwd(), resolve(options.outDir, p));
+  if (showOutLog) {
+    for (const entry of ctx.buildEntries.filter((e) => !e.chunk)) {
+      let totalBytes = entry.bytes || 0;
+      for (const chunk of entry.chunks || []) {
+        totalBytes += ctx.buildEntries.find((e) => e.path === chunk)?.bytes || 0;
+      }
+      let line = `  ${rPath(entry.path)} (${[
+        totalBytes && `total size: ${prettyBytes(totalBytes)}`,
+        entry.bytes && `chunk size: ${prettyBytes(entry.bytes)}`,
+        entry.exports?.length && `exports: ${entry.exports.join(", ")}`
+      ].filter(Boolean).join(", ")})`;
+      if (entry.chunks?.length) {
+        line += `
+${entry.chunks.map((p) => {
+          const chunk = ctx.buildEntries.find((e) => e.path === p) || {};
+          return `  \u2514\u2500 ${rPath(p)}${chunk.bytes ? ` (${prettyBytes(chunk.bytes)})` : ""}`;
+        }).join("\n")}`;
+      }
+      if (entry.modules?.length) {
+        line += `
+${entry.modules.filter((m) => m.id.includes("node_modules")).sort((a, b) => (b.bytes || 0) - (a.bytes || 0)).map((m) => {
+          return `  \u{1F4E6} ${rPath(m.id)}${m.bytes ? ` (${prettyBytes(m.bytes)})` : ""}`;
+        }).join("\n")}`;
+      }
+      relinka("info", entry.chunk ? line : line);
+    }
+    const elapsedTime = getElapsedPerfTime(timer);
+    const transpileFormattedTime = prettyMilliseconds(elapsedTime, {
+      verbose: true
+    });
+    relinka(
+      "info",
+      "\u03A3 Total dist size:",
+      prettyBytes(ctx.buildEntries.reduce((a, e) => a + (e.bytes || 0), 0)),
+      `(build time: ${transpileFormattedTime})`
+    );
+  }
+  validateDependencies(ctx);
+  validatePackage(pkg, rootDir, ctx);
+  await ctx.hooks.callHook("build:done", ctx);
+  relinka("info", "");
+  if (ctx.warnings.size > 0) {
+    relinka(
+      "warn",
+      `Build is done with some warnings:
+
+${[...ctx.warnings].map((msg) => `- ${msg}`).join("\n")}`
+    );
+    if (ctx.options.failOnWarn) {
+      relinka(
+        "error",
+        "Exiting with code (1). You can change this behavior by setting `failOnWarn: false` ."
+      );
+      process.exit(1);
+    }
+  }
+}

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/copy/copy.js

@@ -0,0 +1,62 @@
+import { relinka } from "@reliverse/relinka";
+import { promises as fsp } from "node:fs";
+import { relative, resolve } from "pathe";
+import { glob } from "tinyglobby";
+import {
+  rmdir,
+  symlink,
+  warn
+} from "../utils.js";
+const copy = fsp.cp || fsp.copyFile;
+export async function copyBuild(ctx) {
+  const entries = ctx.options.entries.filter(
+    (e) => e.builder === "copy"
+  );
+  await ctx.hooks.callHook("copy:entries", ctx, entries);
+  for (const entry of entries) {
+    const distDir = entry.outDir || entry.input;
+    if (!distDir || !entry.input) {
+      warn(ctx, "Missing required outDir or input for copy entry");
+      continue;
+    }
+    if (ctx.options.transpileStub) {
+      await rmdir(distDir);
+      await symlink(entry.input, distDir);
+    } else {
+      const patterns = Array.isArray(entry.pattern) ? entry.pattern : [entry.pattern || "**"];
+      const paths = await glob(patterns, {
+        absolute: false,
+        cwd: resolve(ctx.options.rootDir, entry.input)
+      });
+      const outputList = await Promise.allSettled(
+        paths.map(async (path) => {
+          const src = resolve(ctx.options.rootDir, entry.input, path);
+          const dist = resolve(ctx.options.rootDir, distDir, path);
+          await copy(src, dist);
+          return dist;
+        })
+      );
+      for (const output of outputList) {
+        if (output.status === "rejected") {
+          warn(ctx, output.reason);
+        }
+      }
+      ctx.buildEntries.push({
+        chunks: outputList.filter(({ status }) => status === "fulfilled").map(
+          (p) => relative(
+            ctx.options.outDir,
+            p.value
+          )
+        ),
+        path: distDir
+      });
+    }
+  }
+  await ctx.hooks.callHook("copy:done", ctx);
+  if (entries.length > 0 && ctx.options.transpileWatch) {
+    relinka(
+      "warn",
+      "`untyped` builder does not support transpileWatch mode yet."
+    );
+  }
+}

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/mkdist/mkdist.js

@@ -0,0 +1,57 @@
+import { relinka } from "@reliverse/relinka";
+import { mkdist } from "mkdist";
+import { relative } from "pathe";
+import {
+  rmdir,
+  symlink,
+  warn
+} from "../utils.js";
+export async function mkdistBuild(ctx) {
+  const entries = ctx.options.entries.filter(
+    (e) => e.builder === "mkdist"
+  );
+  await ctx.hooks.callHook("mkdist:entries", ctx, entries);
+  for (const entry of entries) {
+    const distDir = entry.outDir || entry.input;
+    if (ctx.options.transpileStub) {
+      await rmdir(distDir);
+      await symlink(entry.input, distDir);
+    } else {
+      const mkdistOptions = {
+        cleanDist: false,
+        distDir,
+        rootDir: ctx.options.rootDir,
+        srcDir: entry.input,
+        ...entry
+      };
+      await ctx.hooks.callHook(
+        "mkdist:entry:options",
+        ctx,
+        entry,
+        mkdistOptions
+      );
+      const output = await mkdist(mkdistOptions);
+      ctx.buildEntries.push({
+        chunks: output.writtenFiles.map((p) => relative(ctx.options.outDir, p)),
+        path: distDir
+      });
+      await ctx.hooks.callHook("mkdist:entry:build", ctx, entry, output);
+      if (output.errors) {
+        for (const error of output.errors) {
+          warn(
+            ctx,
+            `mkdist build failed for \`${relative(ctx.options.rootDir, error.filename)}\`:
+${error.errors.map((e) => `  - ${e}`).join("\n")}`
+          );
+        }
+      }
+    }
+  }
+  await ctx.hooks.callHook("mkdist:done", ctx);
+  if (entries.length > 0 && ctx.options.transpileWatch) {
+    relinka(
+      "warn",
+      "`mkdist` builder does not support transpileWatch mode yet."
+    );
+  }
+}

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/rollup/build.js

@@ -0,0 +1,104 @@
+import { relinka } from "@reliverse/relinka";
+import { resolve } from "pathe";
+import { rollup } from "rollup";
+import dts from "rollup-plugin-dts";
+import { getRollupOptions } from "./config.js";
+import { fixCJSExportTypePlugin } from "./plugins/cjs.js";
+import { removeShebangPlugin } from "./plugins/shebang.js";
+import { rollupStub } from "./stub.js";
+import { getChunkFilename } from "./utils.js";
+import { rollupWatch } from "./watch.js";
+export async function rollupBuild(ctx) {
+  if (ctx.options.transpileStub) {
+    await rollupStub(ctx);
+    await ctx.hooks.callHook("rollup:done", ctx);
+    return;
+  }
+  const rollupOptions = getRollupOptions(ctx);
+  await ctx.hooks.callHook("rollup:options", ctx, rollupOptions);
+  if (Object.keys(rollupOptions.input).length === 0) {
+    await ctx.hooks.callHook("rollup:done", ctx);
+    return;
+  }
+  const buildResult = await rollup(rollupOptions);
+  await ctx.hooks.callHook("rollup:build", ctx, buildResult);
+  const allOutputOptions = rollupOptions.output;
+  for (const outputOptions of allOutputOptions) {
+    const { output } = await buildResult.write(outputOptions);
+    const chunkFileNames = /* @__PURE__ */ new Set();
+    const outputChunks = output.filter((e) => e.type === "chunk");
+    for (const entry of outputChunks) {
+      chunkFileNames.add(entry.fileName);
+      for (const id of entry.imports) {
+        ctx.usedImports.add(id);
+      }
+      if (entry.isEntry) {
+        ctx.buildEntries.push({
+          bytes: Buffer.byteLength(entry.code, "utf8"),
+          chunks: entry.imports.filter(
+            (i) => outputChunks.find((c) => c.fileName === i)
+          ),
+          exports: entry.exports,
+          modules: Object.entries(entry.modules).map(([id, mod]) => ({
+            bytes: mod.renderedLength,
+            id
+          })),
+          path: entry.fileName
+        });
+      }
+    }
+    for (const chunkFileName of chunkFileNames) {
+      ctx.usedImports.delete(chunkFileName);
+    }
+  }
+  if (ctx.options.transpileWatch) {
+    rollupWatch(rollupOptions);
+    if (ctx.options.declaration && ctx.options.transpileWatch) {
+      relinka(
+        "warn",
+        "`rollup` DTS builder does not support transpileWatch mode yet."
+      );
+    }
+    return;
+  }
+  if (ctx.options.declaration) {
+    const plugins = [
+      dts(ctx.options.rollup.dts),
+      removeShebangPlugin(),
+      ctx.options.rollup.emitCJS && fixCJSExportTypePlugin(ctx)
+    ].filter(
+      (plugin) => (
+        /**
+         * Issue: #396
+         * rollup-plugin-dts conflicts with rollup-plugin-commonjs:
+         * https://github.com/Swatinem/rollup-plugin-dts#what-to-expect
+         */
+        !!plugin && (!("name" in plugin) || plugin.name !== "commonjs")
+      )
+    );
+    rollupOptions.plugins = plugins;
+    await ctx.hooks.callHook("rollup:dts:options", ctx, rollupOptions);
+    const typesBuild = await rollup(rollupOptions);
+    await ctx.hooks.callHook("rollup:dts:build", ctx, typesBuild);
+    if (ctx.options.rollup.emitCJS) {
+      await typesBuild.write({
+        chunkFileNames: (chunk) => getChunkFilename(ctx, chunk, "d.cts"),
+        dir: resolve(ctx.options.rootDir, ctx.options.outDir),
+        entryFileNames: "[name].d.cts"
+      });
+    }
+    await typesBuild.write({
+      chunkFileNames: (chunk) => getChunkFilename(ctx, chunk, "d.mts"),
+      dir: resolve(ctx.options.rootDir, ctx.options.outDir),
+      entryFileNames: "[name].d.mts"
+    });
+    if (ctx.options.declaration === true || ctx.options.declaration === "compatible") {
+      await typesBuild.write({
+        chunkFileNames: (chunk) => getChunkFilename(ctx, chunk, "d.ts"),
+        dir: resolve(ctx.options.rootDir, ctx.options.outDir),
+        entryFileNames: "[name].d.ts"
+      });
+    }
+  }
+  await ctx.hooks.callHook("rollup:done", ctx);
+}

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/rollup/config.js

@@ -0,0 +1,124 @@
+import { parseNodeModulePath } from "mlly";
+import { isAbsolute, resolve } from "pathe";
+import { resolveAlias } from "pathe/utils";
+import {
+  arrayIncludes,
+  getpkg,
+  warn
+} from "../utils.js";
+import { cjsPlugin } from "./plugins/cjs.js";
+import { esbuild } from "./plugins/esbuild.js";
+import { JSONPlugin } from "./plugins/json.js";
+import { rawPlugin } from "./plugins/raw.js";
+import { shebangPlugin } from "./plugins/shebang.js";
+import {
+  DEFAULT_EXTENSIONS,
+  getChunkFilename,
+  resolveAliases
+} from "./utils.js";
+const replaceModule = await import("@rollup/plugin-replace");
+const replace = replaceModule.default || replaceModule;
+const aliasModule = await import("@rollup/plugin-alias");
+const alias = aliasModule.default || aliasModule;
+const commonjsModule = await import("@rollup/plugin-commonjs");
+const commonjs = commonjsModule.default || commonjsModule;
+const nodeResolveModule = await import("@rollup/plugin-node-resolve");
+const nodeResolve = nodeResolveModule.nodeResolve || nodeResolveModule.default || nodeResolveModule;
+export function getRollupOptions(ctx) {
+  const _aliases = resolveAliases(ctx);
+  return {
+    external(originalId) {
+      const resolvedId = resolveAlias(originalId, _aliases);
+      const pkgName = parseNodeModulePath(resolvedId)?.name || parseNodeModulePath(originalId)?.name || getpkg(originalId);
+      if (arrayIncludes(ctx.options.externals, pkgName) || arrayIncludes(ctx.options.externals, originalId) || arrayIncludes(ctx.options.externals, resolvedId)) {
+        return true;
+      }
+      for (const id of [originalId, resolvedId]) {
+        if (id.startsWith(".") || isAbsolute(id) || /src[/\\]/.test(id) || ctx.pkg.name && id.startsWith(ctx.pkg.name)) {
+          return false;
+        }
+      }
+      if (ctx.options.rollup.inlineDependencies === true || Array.isArray(ctx.options.rollup.inlineDependencies) && (arrayIncludes(ctx.options.rollup.inlineDependencies, pkgName) || arrayIncludes(ctx.options.rollup.inlineDependencies, originalId) || arrayIncludes(ctx.options.rollup.inlineDependencies, resolvedId))) {
+        return false;
+      }
+      warn(ctx, `Implicitly bundling "${originalId}"`);
+      return false;
+    },
+    input: Object.fromEntries(
+      ctx.options.entries.filter((entry) => entry.builder === "rollup").map((entry) => [
+        entry.name,
+        resolve(ctx.options.rootDir, entry.input)
+      ])
+    ),
+    onwarn(warning, rollupWarn) {
+      if (!warning.code || !["CIRCULAR_DEPENDENCY"].includes(warning.code)) {
+        rollupWarn(warning);
+      }
+    },
+    output: [
+      ctx.options.rollup.emitCJS && {
+        chunkFileNames: (chunk) => getChunkFilename(ctx, chunk, "cjs"),
+        dir: resolve(ctx.options.rootDir, ctx.options.outDir),
+        entryFileNames: "[name].cjs",
+        exports: "auto",
+        externalLiveBindings: false,
+        format: "cjs",
+        freeze: false,
+        generatedCode: { constBindings: true },
+        interop: "compat",
+        sourcemap: ctx.options.transpileSourcemap,
+        ...ctx.options.rollup.output
+      },
+      {
+        chunkFileNames: (chunk) => getChunkFilename(ctx, chunk, "mjs"),
+        dir: resolve(ctx.options.rootDir, ctx.options.outDir),
+        entryFileNames: "[name].mjs",
+        exports: "auto",
+        externalLiveBindings: false,
+        format: "esm",
+        freeze: false,
+        generatedCode: { constBindings: true },
+        sourcemap: ctx.options.transpileSourcemap,
+        ...ctx.options.rollup.output
+      }
+    ].filter(Boolean),
+    plugins: [
+      ctx.options.rollup.replace && replace({
+        ...ctx.options.rollup.replace,
+        values: {
+          ...ctx.options.replace,
+          ...ctx.options.rollup.replace.values
+        }
+      }),
+      ctx.options.rollup.alias && alias({
+        ...ctx.options.rollup.alias,
+        entries: _aliases
+      }),
+      ctx.options.rollup.resolve && nodeResolve({
+        exportConditions: ["production"],
+        extensions: DEFAULT_EXTENSIONS,
+        ...ctx.options.rollup.resolve
+      }),
+      ctx.options.rollup.json && JSONPlugin({
+        ...ctx.options.rollup.json
+      }),
+      shebangPlugin(),
+      ctx.options.rollup.esbuild && esbuild({
+        sourcemap: ctx.options.transpileSourcemap,
+        ...ctx.options.rollup.esbuild
+      }),
+      ctx.options.rollup.commonjs && commonjs({
+        extensions: DEFAULT_EXTENSIONS,
+        ...ctx.options.rollup.commonjs
+      }),
+      ctx.options.rollup.preserveDynamicImports && {
+        name: "dler=preserve-dynamic-imports",
+        renderDynamicImport() {
+          return { left: "import(", right: ")" };
+        }
+      },
+      ctx.options.rollup.cjsBridge && cjsPlugin(),
+      rawPlugin()
+    ].filter((p) => !!p)
+  };
+}