done

Author: EqualMa

rollup.config.ts

@@ -1,7 +1,7 @@
-import { getEntryFiles } from "./src/rollup/entry";
-import { rollupNode } from "./src/rollup/node";
+import { rollupOptions } from "./src/rollup";
 
-export default Promise.all([
-  //
-  rollupNode({ input: getEntryFiles({ patterns: 2 }) }),
-]);
+export default rollupOptions({
+  node: true,
+  dts: true,
+  inputPatterns: 2,
+});

src/rollup/bundle.ts

@@ -13,6 +13,7 @@ import {
 } from "../util/resolvable";
 import { genOutputOptions, GenOutputOptions } from "./output";
 import { inferSingleEntry } from "./entry";
+import { joinPath } from "../util/path";
 
 const COMMON_OUTPUT_OPTIONS: OutputOptions = {
   sourcemap: true,
@@ -73,6 +74,8 @@ export interface RollupBundleOptions
   extends Partial<ResolvableDict<RollupBundleOutputConfig>> {
   input?: Resolvable<string | undefined>;
   output?: Resolvable<GenOutputOptions, [RollupBundleOutputConfig]>;
+  inputBaseDir?: string;
+  outputBaseDir?: string;
 }
 
 export function genBundleOutputOptions(
@@ -82,9 +85,11 @@ export function genBundleOutputOptions(
 }
 
 export async function rollupBundle({
-  input = inferSingleEntry,
+  inputBaseDir = "src",
+  outputBaseDir = "dist",
+  input,
   output: _output = genBundleOutputOptions,
-  outputRootDir = "dist/bundle",
+  outputRootDir = "bundle",
   min = false,
   globalNamespace = inferGlobalNamespace,
 }: RollupBundleOptions = {}): Promise<RollupOptions> {
@@ -95,12 +100,15 @@ export async function rollupBundle({
     globalNamespace,
   });
 
-  const genOutput = await resolve(_output, conf);
+  const genOutput = await resolve(_output, {
+    ...conf,
+    outputRootDir: joinPath(outputBaseDir, conf.outputRootDir),
+  });
 
   const output = genOutputOptions(genOutput, COMMON_OUTPUT_OPTIONS);
 
   return {
-    input: inputFile ?? (await inferSingleEntry()),
+    input: inputFile ?? (await inferSingleEntry({ baseDir: inputBaseDir })),
     output,
     plugins: [
       //

src/rollup/dts.ts

@@ -0,0 +1,37 @@
+import type { InputOption, RollupOptions } from "rollup";
+import { chunkFileNames } from "../util/common";
+import { getEntryFiles } from "./entry";
+import { Resolvable, resolve } from "../util/resolvable";
+
+export interface RollupDtsOptions {
+  inputBaseDir?: string;
+  outputBaseDir?: string;
+  input?: Resolvable<InputOption | undefined>;
+}
+
+export async function rollupDts({
+  inputBaseDir = "src",
+  outputBaseDir = "dist",
+  input,
+}: RollupDtsOptions = {}): Promise<RollupOptions> {
+  const dts = (await import("rollup-plugin-dts")).default;
+
+  const inputOption =
+    (await resolve(input)) ?? (await getEntryFiles({ baseDir: inputBaseDir }));
+
+  return {
+    input: inputOption,
+    output: {
+      dir: outputBaseDir,
+      format: "es",
+      // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+      chunkFileNames: (info) => {
+        const name = info.name.replace(/\.d$/, "");
+        return chunkFileNames
+          .replace(/\[name\]/g, name)
+          .replace(/\.js$/, ".d.ts");
+      },
+    },
+    plugins: [dts()],
+  };
+}

src/rollup/entry.ts

@@ -24,8 +24,10 @@ export type EntryFileFormatter = (
   | Promise<ReturnType<EntryFileFormatterSync>>
   | ReturnType<EntryFileFormatterSync>;
 
+export type MatchFilesPatterns = string | string[] | number;
+
 export interface MatchFilesOptions {
-  patterns: string | string[] | number;
+  patterns: MatchFilesPatterns;
   baseDir: string;
   ignore: string | string[];
 }
@@ -260,8 +262,16 @@ export async function getEntryFiles({
   return entryFiles;
 }
 
-export async function inferSingleEntry(): Promise<string> {
-  const files = await glob(`./src/index.{${DEFAULT_PATTERNS_EXT}}`);
+export interface InferSingleEntryOptions {
+  baseDir?: string;
+}
+
+export async function inferSingleEntry({
+  baseDir,
+}: InferSingleEntryOptions = {}): Promise<string> {
+  const files = await glob(`./index.{${DEFAULT_PATTERNS_EXT}}`, {
+    cwd: baseDir,
+  });
 
   if (!files || files.length === 0) {
     throw new Error("failed to infer entry file");
@@ -275,5 +285,6 @@ export async function inferSingleEntry(): Promise<string> {
     );
   }
 
-  return files[0];
+  const file = files[0];
+  return baseDir ? path.posix.join(baseDir, file) : file;
 }

src/rollup/index.ts

@@ -1,2 +1,5 @@
-export { rollupNode } from "./node";
-export { rollupBundle } from "./bundle";
+export * from "./bundle";
+export * from "./dts";
+export * from "./node";
+
+export * from "./options";

src/rollup/node.ts

@@ -4,9 +4,10 @@ import { compilePlugins } from "./common-plugins";
 import { getPkgJsonBaseContents } from "./gen-pkg";
 import { chunkFileNames } from "../util/common";
 import type { InputOption, OutputOptions, RollupOptions } from "rollup";
-import { getEntryFiles } from "./entry";
+import { getEntryFiles, MatchFilesPatterns } from "./entry";
 import { Resolvable, resolve } from "../util/resolvable";
 import { genOutputOptions, GenOutputOptions } from "./output";
+import { joinPath } from "../util/path";
 
 const commonOutputOptions: OutputOptions = {
   exports: "auto",
@@ -15,7 +16,10 @@ const commonOutputOptions: OutputOptions = {
 };
 
 export interface RollupNodeOptions {
+  inputBaseDir?: string;
+  inputPatterns?: MatchFilesPatterns;
   input?: Resolvable<InputOption | undefined>;
+  outputBaseDir?: string;
   output?: Resolvable<
     GenOutputOptions | undefined,
     [{ outputRootDir: string }]
@@ -24,11 +28,21 @@ export interface RollupNodeOptions {
 }
 
 export async function rollupNode({
-  input = getEntryFiles,
+  inputBaseDir = "src",
+  inputPatterns,
+  input,
+  outputBaseDir = "dist",
   output,
-  outputRootDir = "dist",
+  outputRootDir,
 }: RollupNodeOptions = {}): Promise<RollupOptions> {
-  const inputFiles = (await resolve(input)) ?? (await getEntryFiles());
+  const inputFiles =
+    (await resolve(input)) ??
+    (await getEntryFiles({
+      baseDir: inputBaseDir,
+      patterns: inputPatterns,
+    }));
+
+  outputRootDir = joinPath(outputBaseDir, outputRootDir || "");
 
   return {
     input: inputFiles,

src/rollup/options.ts

@@ -0,0 +1,66 @@
+import { InputOption, RollupOptions } from "rollup";
+import { rollupBundle, rollupNode } from ".";
+import { RollupBundleOptions } from "./bundle";
+import { rollupDts, RollupDtsOptions } from "./dts";
+import { getEntryFiles, MatchFilesPatterns } from "./entry";
+import { RollupNodeOptions } from "./node";
+
+export interface GenRollupOptions {
+  inputBaseDir?: string;
+  inputPatterns?: MatchFilesPatterns;
+  outputBaseDir?: string;
+  bundle?: boolean | RollupBundleOptions;
+  node?: boolean | RollupNodeOptions;
+  dts?: boolean | RollupDtsOptions;
+}
+
+export async function rollupOptions({
+  inputBaseDir,
+  outputBaseDir,
+  inputPatterns,
+  bundle,
+  node,
+  dts,
+}: GenRollupOptions = {}): Promise<RollupOptions[]> {
+  const bundleOptions: RollupBundleOptions | null = bundle
+    ? { outputBaseDir, inputBaseDir, ...(bundle === true ? null : bundle) }
+    : null;
+
+  let cachedInput: Promise<InputOption> | null = null;
+  const input = () => {
+    if (!cachedInput)
+      cachedInput = getEntryFiles({
+        baseDir: inputBaseDir,
+        patterns: inputPatterns,
+      });
+
+    return cachedInput;
+  };
+
+  const nodeOptions: RollupNodeOptions | null = node
+    ? {
+        input,
+        inputBaseDir,
+        inputPatterns,
+        outputBaseDir,
+        ...(node === true ? null : node),
+      }
+    : null;
+
+  const dtsOptions: RollupDtsOptions | null = dts
+    ? {
+        input,
+        inputBaseDir,
+        outputBaseDir,
+        ...(dts === true ? null : dts),
+      }
+    : null;
+
+  const options = [
+    bundleOptions && rollupBundle(bundleOptions),
+    nodeOptions && rollupNode(nodeOptions),
+    dtsOptions && rollupDts(dtsOptions),
+  ].filter((v): v is Promise<RollupOptions> => !!v);
+
+  return Promise.all(options);
+}

src/util/path.ts

@@ -0,0 +1,5 @@
+import { posix as pp } from "path";
+
+export function joinPath(...paths: string[]): string {
+  return pp.join(...paths);
+}

tsconfig.json

@@ -10,6 +10,7 @@
     "forceConsistentCasingInFileNames": true
   },
   "include": ["**/*.ts"],
+  "exclude": ["node_modules", "dist"],
   "ts-node": {
     "compilerOptions": {
       "skipLibCheck": true,