modular-library 0.0.1

package/.github/FUNDING.yml

@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: [alfredosalzillo]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

package/.github/dependabot.yml

@@ -0,0 +1,9 @@
+version: 2
+updates:
+- package-ecosystem: npm
+  directory: "/"
+  schedule:
+    interval: weekly
+    time: "04:00"
+  open-pull-requests-limit: 10
+  target-branch: dev

package/.github/workflows/ci.yml

@@ -0,0 +1,32 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        node-version: [22, 23, 24, 25]
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: npm
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Build
+        run: npm run build
+
+      - name: Test
+        run: npm test

package/AGENTS.md

@@ -0,0 +1,58 @@
+# AGENTS.md
+
+This file provides context and instructions for AI coding agents working on this project.
+
+## Setup Commands
+
+-   Install dependencies: `npm install`
+-   Build the project: `npm run build`
+-   Run tests: `npm test`
+-   Run lint checks: `npm run lint`
+
+## Technology Stack
+
+-   **TypeScript**: Use TypeScript for all code changes. Follow the existing configuration in `tsconfig.json`.
+-   Keep this `AGENTS.md` technology stack section up to date whenever the project tech stack changes.
+
+## Development Workflow
+
+1.  **Keep changes minimal**: Implement the smallest safe change that resolves the issue.
+2.  **Build**: Before submitting, ensure the project compiles by running `npm run build`.
+3.  **Validate**: Run relevant tests with `npm test` when behavior changes.
+4.  **Code Style**: Follow the existing style and naming patterns in the codebase.
+5.  **GitHub Workflows**: To test workflows locally, use [`act`](https://nektosact.com/).
+
+## Temporary Files
+
+-   **Temporary Directory**: Always place temporary files in the `.ai-tmp` directory.
+
+## Commit Message Guidelines
+
+When creating commits, use **Conventional Commits**.
+
+### Format
+
+```text
+<type>(<scope>): <description>
+
+[optional body]
+
+[optional footer(s)]
+```
+
+### Types
+
+-   `feat`: A new feature (minor version update).
+-   `fix`: A bug fix (patch version update).
+-   `docs`: Documentation changes only.
+-   `style`: Changes that do not affect the meaning of the code (white-space, formatting, etc).
+-   `refactor`: A code change that neither fixes a bug nor adds a feature.
+-   `perf`: A code change that improves performance.
+-   `test`: Adding missing tests or correcting existing tests.
+-   `build`: Changes that affect the build system or external dependencies.
+-   `ci`: Changes to CI configuration files and scripts.
+-   `chore`: Other changes that don't modify src or test files.
+
+### Breaking Changes
+
+Breaking changes must be indicated by a `!` after the type/scope or by including `BREAKING CHANGE:` in the footer.

package/README.md

@@ -0,0 +1,128 @@
+# modular-library
+
+`modular-library` is a utility library for generating modular libraries.
+
+## What is a modular library?
+
+A **modular library** is a library split into small, focused modules instead of one large, monolithic package.
+
+This approach helps you:
+
+- keep each part of the library easier to understand and maintain,
+- reuse modules independently across projects,
+- reduce coupling between features,
+- improve scalability as the codebase grows,
+- be tree-shakeable so consumers only bundle what they import,
+- expose clear entry points for each public feature or component.
+
+Typical examples of modular libraries include:
+
+- UI libraries exposing per-component entries (for example `@acme/ui/button`, `@acme/ui/modal`),
+- utility libraries exposing per-domain modules (for example `@acme/utils/date`, `@acme/utils/string`),
+- SDKs exposing feature-based modules (for example `@acme/sdk/auth`, `@acme/sdk/storage`).
+
+With `modular-library`, the goal is to make the creation of this kind of modular architecture faster and more consistent.
+
+## Installation
+
+> **Node.js requirement:** This library supports only Node.js `22` or newer.
+
+```bash
+npm install modular-library
+```
+
+## Usage
+
+`modular-library` provides dedicated plugins for `vite`, `rollup`, and `rolldown`.
+
+### Vite
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import modularLibrary from "modular-library/vite";
+
+export default defineConfig({
+  plugins: [modularLibrary()],
+  build: {
+    lib: {
+      entry: ["src/**/*.ts"],
+      formats: ["es"],
+    },
+  },
+});
+```
+
+### Rollup
+
+```ts
+// rollup.config.ts
+import modularLibrary from "modular-library/rollup";
+
+export default {
+  input: ["src/**/*.ts"],
+  output: {
+    dir: "dist",
+    format: "es",
+  },
+  plugins: [modularLibrary()],
+};
+```
+
+### Rolldown
+
+```ts
+// rolldown.config.ts
+import modularLibrary from "modular-library/rolldown";
+
+export default {
+  input: ["src/**/*.ts"],
+  output: {
+    dir: "dist",
+    format: "es",
+  },
+  plugins: [modularLibrary()],
+};
+```
+
+### Options
+
+All plugin variants support the same options:
+
+- `relative` (default: `"src/"`): base path removed from generated output keys.
+- `glob`: [`fs.globSync`](https://nodejs.org/api/fs.html#fsglobsyncpattern-options) options.
+- `transformOutputPath(outputPath, inputPath)`: customize each generated output path.
+
+Example with options:
+
+```ts
+import modularLibrary from "modular-library/rollup";
+
+export default {
+  input: ["src/**/*.ts"],
+  output: {
+    dir: "dist",
+    format: "es",
+  },
+  plugins: [
+    modularLibrary({
+      relative: "src/",
+      transformOutputPath: (outputPath) => `modules/${outputPath}`,
+    }),
+  ],
+};
+```
+
+## Development
+
+```bash
+npm install
+npm run build
+npm test
+```
+
+To test GitHub workflows locally, you can use [`act`](https://nektosact.com/).
+
+## License
+
+ISC

package/biome.json

@@ -0,0 +1,40 @@
+{
+  "$schema": "https://biomejs.dev/schemas/2.4.6/schema.json",
+  "vcs": {
+    "enabled": true,
+    "clientKind": "git",
+    "useIgnoreFile": true
+  },
+  "files": {
+    "ignoreUnknown": true,
+    "includes": ["**", "!node_modules", "!.next", "!dist", "!build"]
+  },
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space",
+    "indentWidth": 2
+  },
+  "javascript": {
+    "formatter": {
+      "quoteStyle": "double"
+    }
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true
+    }
+  },
+  "assist": {
+    "actions": {
+      "source": {
+        "organizeImports": {
+          "level": "on",
+          "options": {
+            "groups": [":PACKAGE:", ":PATH:"]
+          }
+        }
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "modular-library",
+  "version": "0.0.1",
+  "private": false,
+  "exports": {
+    "./rollup": {
+      "types": "./dist/rollup/index.d.ts",
+      "import": "./dist/rollup/index.es.js",
+      "require": "./dist/rollup/index.cjs.js"
+    },
+    "./rolldown": {
+      "types": "./dist/rolldown/index.d.ts",
+      "import": "./dist/rolldown/index.es.js",
+      "require": "./dist/rolldown/index.cjs.js"
+    },
+    "./vite": {
+      "types": "./dist/vite/index.d.ts",
+      "import": "./dist/vite/index.es.js",
+      "require": "./dist/vite/index.cjs.js"
+    }
+  },
+  "scripts": {
+    "build": "vite build",
+    "lint": "biome check .",
+    "format": "biome format --write .",
+    "test": "vitest run --coverage"
+  },
+  "keywords": [
+    "modular-library",
+    "vite-plugin",
+    "rollup-plugin",
+    "rolldown-plugin",
+    "multi-entry",
+    "multi-input",
+    "tree-shaking",
+    "typescript",
+    "bundler"
+  ],
+  "author": "alfredo salzillo <alfredosalzillo93@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/alfredosalzillo/modular-library.git"
+  },
+  "bugs": {
+    "url": "https://github.com/alfredosalzillo/modular-library/issues"
+  },
+  "funding": {
+    "url": "https://github.com/sponsors/alfredosalzillo"
+  },
+  "homepage": "https://github.com/alfredosalzillo/modular-library#readme",
+  "description": "Plugins for Vite, Rollup, and Rolldown to build modular multi-entry TypeScript libraries.",
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.11",
+    "@rollup/plugin-json": "^6.1.0",
+    "@types/node": "^25.6.0",
+    "@vitejs/plugin-react": "^6.0.1",
+    "@vitest/coverage-v8": "^4.1.4",
+    "rolldown": "^1.0.0-rc.15",
+    "rollup": "^4.60.1",
+    "typescript": "^6.0.2",
+    "unplugin-dts": "^1.0.0-beta.6",
+    "vite": "^8.0.8",
+    "vitest": "^4.1.4"
+  },
+  "volta": {
+    "node": "25.9.0"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  }
+}

package/src/createEntries.ts

@@ -0,0 +1,59 @@
+import { globSync, type GlobOptionsWithoutFileTypes } from "node:fs";
+import path from "node:path";
+
+const isString = (value: unknown): value is string => typeof value === "string";
+const outputFileName = (filePath: string) =>
+  filePath.replace(/\.[^/.]+$/, "").replace(/\\/g, "/");
+
+export type CreateEntryInput = string | string[] | Record<string, string>;
+type CreateEntriesGlobOptions = GlobOptionsWithoutFileTypes;
+
+export type CreateEntriesOptions = {
+  glob?: CreateEntriesGlobOptions;
+  relative?: string;
+  transformOutputPath?: (path: string, fileName: string) => string;
+};
+
+const defaultOptions = {
+  relative: `src/`,
+};
+const createEntries = (
+  input: CreateEntryInput,
+  options?: CreateEntriesOptions,
+) => {
+  // flat to enable input to be a string or an array
+  const inputs = [input].flat();
+  // separate globs inputs string from others to enable input to be a mixed array too
+  const globs = inputs.filter((value) => isString(value));
+  const others = inputs.filter((value) => !isString(value));
+  const normalizedGlobs = globs.map((glob) => glob.replace(/\\/g, "/"));
+
+  // get files from the strings and return as entries Object
+  const entries = globSync(normalizedGlobs, {
+    ...options?.glob,
+    withFileTypes: false,
+  }).map((name) => {
+    const filePath = path.relative(
+      options?.relative ?? defaultOptions.relative,
+      name,
+    );
+    const isRelative = !filePath.startsWith(`../`);
+    const relativeFilePath = isRelative ? filePath : path.relative(`./`, name);
+    return [
+      outputFileName(
+        options?.transformOutputPath
+          ? options.transformOutputPath(relativeFilePath, name)
+          : relativeFilePath,
+      ),
+      name,
+    ];
+  });
+  return Object.assign(
+    {},
+    Object.fromEntries(entries),
+    // add no globs input to the result
+    ...others,
+  );
+};
+
+export default createEntries;

package/src/rolldown/index.ts

@@ -0,0 +1,2 @@
+export * from "./plugin";
+export { default } from "./plugin";

package/src/rolldown/plugin.test.ts

@@ -0,0 +1,129 @@
+import type { InputOptions } from "rolldown";
+import modularLibrary from "./plugin";
+
+const expectedOutput = ["fixture/input1", "fixture/input2"].sort();
+
+const applyOptions = (
+  options: InputOptions,
+  pluginOptions?: Parameters<typeof modularLibrary>[0],
+) => {
+  const plugin = modularLibrary(pluginOptions);
+  if (!plugin.options) {
+    throw new Error("options hook is required");
+  }
+
+  const context = {
+    warn: vi.fn(),
+  };
+
+  const result = plugin.options.call(context as never, options);
+  return {
+    result,
+    warn: context.warn,
+  };
+};
+
+describe("modular-library/rolldown", () => {
+  it("should have name modular-library/rolldown", () => {
+    const plugin = modularLibrary({ relative: "./test" });
+    expect(plugin.name).toBe("modular-library/rolldown");
+  });
+
+  it("should resolve glob", () => {
+    const { result } = applyOptions(
+      {
+        input: ["test/fixture/**/*.js"],
+      },
+      { relative: "./test" },
+    );
+
+    expect(Object.keys(result.input as Record<string, string>).sort()).toEqual(
+      expectedOutput,
+    );
+  });
+
+  it("should accept a simple string as input", () => {
+    const { result } = applyOptions(
+      {
+        input: "test/fixture/**/*.js",
+      },
+      { relative: "./test" },
+    );
+
+    expect(Object.keys(result.input as Record<string, string>).sort()).toEqual(
+      expectedOutput,
+    );
+  });
+
+  it("should accept an array of strings as input", () => {
+    const { result } = applyOptions(
+      {
+        input: ["test/fixture/**/*.js"],
+      },
+      { relative: "./test" },
+    );
+
+    expect(Object.keys(result.input as Record<string, string>).sort()).toEqual(
+      expectedOutput,
+    );
+  });
+
+  it("should remove unresolved glob", () => {
+    const { result } = applyOptions(
+      {
+        input: ["test/fixture/**/*.js", "/not-found/file.js"],
+      },
+      { relative: "./test" },
+    );
+
+    expect(Object.keys(result.input as Record<string, string>).sort()).toEqual(
+      expectedOutput,
+    );
+  });
+
+  it("should resolve relative to src as default", () => {
+    const { result: outputFilesWithNoOptions } = applyOptions({
+      input: ["test/fixture/**/*.js"],
+    });
+    const { result: outputFilesWithNoRelativeOption } = applyOptions(
+      {
+        input: ["./test/fixture/**/*.js"],
+      },
+      {},
+    );
+
+    expect(
+      Object.keys(
+        outputFilesWithNoOptions.input as Record<string, string>,
+      ).sort(),
+    ).toEqual(["test/fixture/input1", "test/fixture/input2"]);
+    expect(
+      Object.keys(
+        outputFilesWithNoRelativeOption.input as Record<string, string>,
+      ).sort(),
+    ).toEqual(["test/fixture/input1", "test/fixture/input2"]);
+  });
+
+  it("should resolve output with transformOutputPath option", () => {
+    const { result } = applyOptions(
+      {
+        input: ["test/fixture/**/*.js"],
+      },
+      {
+        transformOutputPath: (output) => `dest/${output.split("/").at(-1)}`,
+      },
+    );
+
+    expect(Object.keys(result.input as Record<string, string>).sort()).toEqual([
+      "dest/input1",
+      "dest/input2",
+    ]);
+  });
+
+  it("should warn when input is missing", () => {
+    const { result, warn } = applyOptions({}, { relative: "./test" });
+
+    expect(warn).toHaveBeenCalledWith("At least one input is required");
+    expect(result).toEqual({});
+  });
+});

package/src/rolldown/plugin.ts

@@ -0,0 +1,34 @@
+import type { Plugin } from "rolldown";
+import createEntries, { type CreateEntriesOptions } from "@/createEntries";
+
+const pluginName = "modular-library/rolldown";
+
+export type RolldownModularLibraryOptions = CreateEntriesOptions;
+
+/**
+ * rolldownModularLibrary is a rolldown plugin to use multiple entry points and preserve the directory
+ * structure in the dist folder
+ */
+const rolldownModularLibrary = (
+  options?: RolldownModularLibraryOptions,
+): Plugin => {
+  return {
+    name: pluginName,
+    options(conf) {
+      if (!conf.input) {
+        if (this.warn) {
+          this.warn("At least one input is required");
+        }
+        return conf;
+      }
+
+      const input = createEntries(conf.input, options);
+      return {
+        ...conf,
+        input,
+      };
+    },
+  };
+};
+
+export default rolldownModularLibrary;

package/src/rollup/index.ts

@@ -0,0 +1,2 @@
+export * from "./plugin";
+export { default } from "./plugin";

package/src/rollup/plugin.test.ts

@@ -0,0 +1,114 @@
+import { rollup, RollupOptions } from "rollup";
+import importJson from "@rollup/plugin-json";
+import path from "node:path";
+import modularLibrary from "./plugin";
+
+const expectedOutput = ["fixture/input1.js", "fixture/input2.js"].sort();
+
+const externalDependencies = ["node:fs", "path"];
+
+describe.each([
+  ["rollup 4", rollup],
+])("modular-library/rollup using %s", (_, rollup) => {
+  const generateBundle = (options: RollupOptions) =>
+    rollup(options).then((bundle) =>
+      bundle.generate({
+        format: "cjs",
+      }),
+    );
+
+  const generateOutputFileNames = (options: RollupOptions) =>
+    generateBundle(options).then(({ output }) =>
+      output.map((module) => module.fileName).sort(),
+    );
+
+  it("should have name modular-library/rollup", async () => {
+    const plugin = modularLibrary({ relative: "./test" });
+    expect("name" in plugin).toBeTruthy();
+    expect(plugin.name).toBe("modular-library/rollup");
+  });
+  it("should resolve glob", async () => {
+    const outputFiles = await generateOutputFileNames({
+      input: ["test/fixture/**/*.js"],
+      plugins: [modularLibrary({ relative: "./test" })],
+    });
+    expect(outputFiles).toEqual(expectedOutput);
+  });
+  it("should accept a simple string as input", async () => {
+    const outputFiles = await generateOutputFileNames({
+      input: "test/fixture/**/*.js",
+      plugins: [modularLibrary({ relative: "./test" })],
+    });
+    expect(outputFiles).toEqual(expectedOutput);
+  });
+  it("should accept an array of strings as input", async () => {
+    const outputFiles = await generateOutputFileNames({
+      input: ["test/fixture/**/*.js"],
+      plugins: [modularLibrary({ relative: "./test" })],
+    });
+    expect(outputFiles).toEqual(expectedOutput);
+  });
+  it("should remove unresolved glob", async () => {
+    const outputFiles = await generateOutputFileNames({
+      input: ["test/fixture/**/*.js", "/not-found/file.js"],
+      plugins: [modularLibrary({ relative: "./test" })],
+    });
+    expect(outputFiles).toEqual(expectedOutput);
+  });
+  it("should preserve no string entries", async () => {
+    const bundle = generateBundle({
+      // @ts-expect-error
+      input: [
+        "test/fixture/**/*.js",
+        {
+          test: "path/to/test.js",
+        },
+      ],
+      plugins: [modularLibrary({ relative: "./test" })],
+    });
+    await expect(bundle).rejects.toThrow(/^Could not resolve entry module/);
+  });
+  it('should resolve relative to "src" as default', async () => {
+    const outputFilesWithNoOptions = await generateOutputFileNames({
+      input: ["test/fixture/**/*.js"],
+      plugins: [modularLibrary(), importJson()],
+      external: externalDependencies,
+    });
+    const outputFilesWithNoRelativeOption = await generateOutputFileNames({
+      input: ["./test/fixture/**/*.js"],
+      plugins: [modularLibrary({}), importJson()],
+      external: externalDependencies,
+    });
+    expect(outputFilesWithNoOptions).toEqual([
+      "test/fixture/input1.js",
+      "test/fixture/input2.js",
+    ]);
+    expect(outputFilesWithNoRelativeOption).toEqual([
+      "test/fixture/input1.js",
+      "test/fixture/input2.js",
+    ]);
+  });
+  it('should resolve non relative to "relative" options path to root', async () => {
+    const outputFiles = await generateOutputFileNames({
+      input: ["test/fixture/**/*.js"],
+      plugins: [modularLibrary(), importJson()],
+      external: ["node:fs", "path"],
+    });
+    expect(outputFiles).toEqual([
+      "test/fixture/input1.js",
+      "test/fixture/input2.js",
+    ]);
+  });
+  it('should resolve output to "dist" directory', async () => {
+    const outputFiles = await generateOutputFileNames({
+      input: ["test/fixture/**/*.js"],
+      plugins: [
+        modularLibrary({
+          transformOutputPath: (output) => `dest/${path.basename(output)}`,
+        }),
+      ],
+      external: ["node:fs", "path"],
+    });
+    expect(outputFiles).toEqual(["dest/input1.js", "dest/input2.js"]);
+  });
+});

package/src/rollup/plugin.ts

@@ -0,0 +1,34 @@
+import type { Plugin } from "rollup";
+import createEntries, { CreateEntriesOptions } from "@/createEntries";
+
+const pluginName = "modular-library/rollup";
+
+export type RollupModularLibraryOptions = CreateEntriesOptions;
+
+/**
+ *  modularLibrary is a rollup plugin to use multiple entry point and preserve the directory
+ *  structure in the dist folder
+ * */
+const rollupModularLibrary = (
+  options?: RollupModularLibraryOptions,
+): Plugin => {
+  return {
+    name: pluginName,
+    buildStart() {},
+    options(conf) {
+      if (!conf.input) {
+        if (this.warn) {
+          this.warn("At least one input is required");
+        }
+        return conf;
+      }
+      const input = createEntries(conf.input, options);
+      return {
+        ...conf,
+        input,
+      };
+    },
+  };
+};
+
+export default rollupModularLibrary;

package/src/vite/index.ts

@@ -0,0 +1,2 @@
+export * from "./plugin";
+export { default } from "./plugin";

package/src/vite/plugin.test.ts

@@ -0,0 +1,192 @@
+import type { UserConfig } from "vite";
+import modularLibrary from "./plugin";
+
+const expectedOutput = ["fixture/input1", "fixture/input2"].sort();
+
+const applyConfig = (
+  config: UserConfig,
+  pluginOptions?: Parameters<typeof modularLibrary>[0],
+) => {
+  const plugin = modularLibrary(pluginOptions);
+  if (!plugin.config) {
+    throw new Error("config hook is required");
+  }
+
+  const context = {
+    warn: vi.fn(),
+  };
+
+  // @ts-expect-error
+  const result = plugin.config.call(context as never, config);
+  return {
+    result,
+    warn: context.warn,
+  };
+};
+
+describe("modular-library/vite", () => {
+  it("should have name modular-library/vite", () => {
+    const plugin = modularLibrary({ relative: "./test" });
+    expect(plugin.name).toBe("modular-library/vite");
+    expect(plugin.apply).toBe("build");
+  });
+
+  it("should warn when build.lib is missing", () => {
+    const { result, warn } = applyConfig({});
+
+    expect(warn).toHaveBeenCalledWith("The build.lib option is required");
+    expect(result).toEqual({});
+  });
+
+  it("should warn when build.lib.entry is missing", () => {
+    const { result, warn } = applyConfig({
+      build: {
+        // @ts-expect-error
+        lib: {},
+      },
+    });
+
+    expect(warn).toHaveBeenCalledWith("At least one entry is required");
+    expect(result).toEqual({
+      build: {
+        lib: {},
+      },
+    });
+  });
+
+  it("should resolve glob", () => {
+    const { result } = applyConfig(
+      {
+        build: {
+          lib: {
+            entry: ["test/fixture/**/*.js"],
+          },
+        },
+      },
+      { relative: "./test" },
+    );
+
+    expect(
+      Object.keys(
+        (result.build?.lib as { entry: Record<string, string> }).entry,
+      ).sort(),
+    ).toEqual(expectedOutput);
+  });
+
+  it("should accept a simple string as input", () => {
+    const { result } = applyConfig(
+      {
+        build: {
+          lib: {
+            entry: "test/fixture/**/*.js",
+          },
+        },
+      },
+      { relative: "./test" },
+    );
+
+    expect(
+      Object.keys(
+        (result.build?.lib as { entry: Record<string, string> }).entry,
+      ).sort(),
+    ).toEqual(expectedOutput);
+  });
+
+  it("should accept an array of strings as input", () => {
+    const { result } = applyConfig(
+      {
+        build: {
+          lib: {
+            entry: ["test/fixture/**/*.js"],
+          },
+        },
+      },
+      { relative: "./test" },
+    );
+
+    expect(
+      Object.keys(
+        (result.build?.lib as { entry: Record<string, string> }).entry,
+      ).sort(),
+    ).toEqual(expectedOutput);
+  });
+
+  it("should remove unresolved glob", () => {
+    const { result } = applyConfig(
+      {
+        build: {
+          lib: {
+            entry: ["test/fixture/**/*.js", "/not-found/file.js"],
+          },
+        },
+      },
+      { relative: "./test" },
+    );
+
+    expect(
+      Object.keys(
+        (result.build?.lib as { entry: Record<string, string> }).entry,
+      ).sort(),
+    ).toEqual(expectedOutput);
+  });
+
+  it("should resolve relative to src as default", () => {
+    const { result: outputFilesWithNoOptions } = applyConfig({
+      build: {
+        lib: {
+          entry: ["test/fixture/**/*.js"],
+        },
+      },
+    });
+    const { result: outputFilesWithNoRelativeOption } = applyConfig(
+      {
+        build: {
+          lib: {
+            entry: ["./test/fixture/**/*.js"],
+          },
+        },
+      },
+      {},
+    );
+
+    expect(
+      Object.keys(
+        (
+          outputFilesWithNoOptions.build?.lib as {
+            entry: Record<string, string>;
+          }
+        ).entry,
+      ).sort(),
+    ).toEqual(["test/fixture/input1", "test/fixture/input2"]);
+    expect(
+      Object.keys(
+        (
+          outputFilesWithNoRelativeOption.build?.lib as {
+            entry: Record<string, string>;
+          }
+        ).entry,
+      ).sort(),
+    ).toEqual(["test/fixture/input1", "test/fixture/input2"]);
+  });
+
+  it("should resolve output with transformOutputPath option", () => {
+    const { result } = applyConfig(
+      {
+        build: {
+          lib: {
+            entry: ["test/fixture/**/*.js"],
+          },
+        },
+      },
+      {
+        transformOutputPath: (output) => `dest/${output.split("/").at(-1)}`,
+      },
+    );
+
+    expect(
+      Object.keys(
+        (result.build?.lib as { entry: Record<string, string> }).entry,
+      ).sort(),
+    ).toEqual(["dest/input1", "dest/input2"]);
+  });
+});

package/src/vite/plugin.ts

@@ -0,0 +1,40 @@
+import type { Plugin } from "vite";
+import createEntries, { type CreateEntriesOptions } from "@/createEntries";
+
+const pluginName = "modular-library/vite";
+
+export type ViteModularLibraryOptions = CreateEntriesOptions;
+
+/**
+ * viteModularLibrary is a vite plugin to use multiple entry points and preserve the directory
+ * structure in the dist folder
+ */
+const viteModularLibrary = (options?: ViteModularLibraryOptions): Plugin => {
+  return {
+    name: pluginName,
+    apply: "build",
+    config(config) {
+      if (!config.build?.lib) {
+        if (this.warn) {
+          this.warn("The build.lib option is required");
+        }
+        return config;
+      }
+      const entry = config.build?.lib?.entry;
+
+      if (!entry) {
+        if (this.warn) {
+          this.warn("At least one entry is required");
+        }
+
+        return config;
+      }
+
+      config.build.lib.entry = createEntries(entry, options);
+
+      return config;
+    },
+  };
+};
+
+export default viteModularLibrary;

package/test/fixture/input1.js

@@ -0,0 +1,2 @@
+// eslint-disable-next-line import/prefer-default-export
+export function doNothing() {}

package/test/fixture/input2.js

@@ -0,0 +1,2 @@
+// eslint-disable-next-line import/prefer-default-export
+export function doNothing() {}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "CommonJS",
+    "moduleResolution": "bundler",
+    "declaration": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "include": ["src", "node_modules/vitest/globals.d.ts"]
+}

package/vite.config.ts

@@ -0,0 +1,36 @@
+import react from "@vitejs/plugin-react";
+import dts from "unplugin-dts/vite";
+import { defineConfig } from "vite";
+import { resolve } from "node:path";
+
+export default defineConfig({
+  plugins: [
+    react(),
+    dts({
+      copyDtsFiles: true,
+      outDirs: ["dist"],
+      exclude: ["src/**/*.test.ts"],
+      beforeWriteFile: (filePath, content) => ({
+        filePath: filePath.replace(/([\\/])dist\1src\1/, "$1dist$1"),
+        content,
+      }),
+    }),
+  ],
+  build: {
+    lib: {
+      entry: {
+        "rolldown/index": resolve(__dirname, "src/rolldown/index.ts"),
+        "rollup/index": resolve(__dirname, "src/rollup/index.ts"),
+        "vite/index": resolve(__dirname, "src/vite/index.ts"),
+      },
+      formats: ["es", "cjs"],
+      fileName: (format, entryName) => `${entryName}.${format}.js`,
+    },
+    rolldownOptions: {
+      output: {
+        chunkFileNames: "chunks/[name].js",
+      },
+      external: ["node:path", "node:fs"],
+    },
+  },
+});

package/vitest.config.ts

@@ -0,0 +1,18 @@
+import { defineConfig } from "vitest/config";
+import { resolve } from "node:path";
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      "@": resolve(__dirname, "src"),
+    },
+  },
+  test: {
+    environment: "node",
+    globals: true,
+    coverage: {
+      provider: "v8",
+      reportsDirectory: "./coverage",
+    },
+  },
+});