@quilted/rollup 0.2.4 → 0.2.6

package/source/module.ts

@@ -1,14 +1,11 @@
-import * as path from 'path';
 import {type InputPluginOption, type RollupOptions} from 'rollup';
-import {glob} from 'glob';
 
-import {resolveRoot} from './shared/path.ts';
+import {Project} from './shared/project.ts';
 import {
   RollupNodePluginOptions,
   getNodePlugins,
   removeBuildFiles,
 } from './shared/rollup.ts';
-import {loadPackageJSON, type PackageJSON} from './shared/package-json.ts';
 import {
   getBrowserGroupTargetDetails,
   rollupGenerateOptionsForBrowsers,
@@ -63,22 +60,22 @@ export interface ModuleAssetsOptions
 }
 
 export async function quiltModule({
-  root: rootPath = process.cwd(),
+  root = process.cwd(),
   entry,
   env,
   assets,
   graphql = true,
 }: ModuleOptions = {}) {
-  const root = resolveRoot(rootPath);
+  const project = Project.load(root);
   const mode = (typeof env === 'object' ? env?.mode : env) ?? 'production';
-  const outputDirectory = path.join(root, 'build/assets');
+  const outputDirectory = project.resolve('build/assets');
 
   const minify = assets?.minify ?? true;
   const hash = assets?.hash ?? 'async-only';
   const bundle = assets?.bundle ?? true;
 
   const browserGroup = await getBrowserGroupTargetDetails(assets?.targets, {
-    root,
+    root: project.root,
   });
   const targetFilenamePart = browserGroup.name ? `.${browserGroup.name}` : '';
 
@@ -87,34 +84,33 @@ export async function quiltModule({
     {magicModuleEnv, replaceProcessEnv},
     {sourceCode},
     {tsconfigAliases},
+    {monorepoPackageAliases},
     {react},
     {esnext},
     nodePlugins,
-    packageJSON,
   ] = await Promise.all([
     import('rollup-plugin-visualizer'),
     import('./features/env.ts'),
     import('./features/source-code.ts'),
     import('./features/typescript.ts'),
+    import('./features/node.ts'),
     import('./features/react.ts'),
     import('./features/esnext.ts'),
     getNodePlugins({bundle}),
-    loadPackageJSON(root),
   ]);
 
-  const finalEntry = entry
-    ? path.resolve(root, entry)
-    : await sourceForModule(root, packageJSON);
+  const finalEntry = await resolveModuleEntry(entry, project);
 
   const plugins: InputPluginOption[] = [
     ...nodePlugins,
     replaceProcessEnv({mode}),
     magicModuleEnv({...resolveEnvOption(env), mode}),
     sourceCode({mode, targets: browserGroup.browsers}),
-    tsconfigAliases({root}),
+    tsconfigAliases({root: project.root}),
+    monorepoPackageAliases({root: project.root}),
     esnext({mode, targets: browserGroup.browsers}),
     react(),
-    removeBuildFiles(['build/assets', 'build/reports'], {root}),
+    removeBuildFiles(['build/assets', 'build/reports'], {root: project.root}),
   ];
 
   if (graphql) {
@@ -132,8 +128,7 @@ export async function quiltModule({
       template: 'treemap',
       open: false,
       brotliSize: true,
-      filename: path.resolve(
-        root,
+      filename: project.resolve(
         `build/reports/bundle-visualizer${targetFilenamePart}.html`,
       ),
     }),
@@ -161,19 +156,22 @@ export async function quiltModule({
   } satisfies RollupOptions;
 }
 
-async function sourceForModule(root: string, packageJSON: PackageJSON) {
-  const {main, exports} = packageJSON;
+async function resolveModuleEntry(entry: string | undefined, project: Project) {
+  if (entry) {
+    return project.resolve(entry);
+  }
+
+  const {main, exports} = project.packageJSON.raw;
 
   const entryFromPackageJSON = main ?? (exports as any)?.['.'];
 
   if (entryFromPackageJSON) {
-    return path.resolve(root, entryFromPackageJSON);
+    return project.resolve(entryFromPackageJSON);
   }
 
-  const possibleSourceFiles = await glob(
+  const possibleSourceFiles = await project.glob(
     '{index,module,entry,input}.{ts,tsx,mjs,js,jsx}',
     {
-      cwd: root,
       nodir: true,
       absolute: true,
     },

package/source/package.ts

@@ -4,16 +4,14 @@ import {exec as execCommand} from 'child_process';
 import {promisify} from 'util';
 
 import {Plugin, type RollupOptions, type OutputOptions} from 'rollup';
-import {glob} from 'glob';
 
 import {multiline} from './shared/strings.ts';
-import {resolveRoot} from './shared/path.ts';
+import {Project, sourceEntriesForProject} from './shared/project.ts';
 import {
   getNodePlugins,
   removeBuildFiles,
   type RollupNodePluginOptions,
 } from './shared/rollup.ts';
-import {loadPackageJSON, type PackageJSON} from './shared/package-json.ts';
 import {
   getBrowserGroupTargetDetails,
   rollupGenerateOptionsForBrowsers,
@@ -128,7 +126,7 @@ export interface PackageOptions extends PackageESModuleOptions {
 }
 
 export async function quiltPackage({
-  root: rootPath = process.cwd(),
+  root = process.cwd(),
   commonjs = false,
   esnext: explicitESNext,
   entries,
@@ -138,10 +136,8 @@ export async function quiltPackage({
   graphql = true,
   customize,
 }: PackageOptions = {}) {
-  const root = resolveRoot(rootPath);
-  const packageJSON = await loadPackageJSON(root);
-  const resolvedEntries =
-    entries ?? (await sourceEntriesForPackage(root, packageJSON));
+  const project = Project.load(root);
+  const resolvedEntries = entries ?? (await sourceEntriesForProject(project));
 
   const includeESNext =
     explicitESNext ?? Object.keys(resolvedEntries).length > 0;
@@ -173,37 +169,39 @@ export async function quiltPackage({
 }
 
 export async function quiltPackageESModules({
-  root: rootPath = process.cwd(),
+  root = process.cwd(),
   commonjs = false,
   entries,
   executable = {},
-  react,
+  react: useReact,
   bundle,
   graphql = true,
   customize,
 }: PackageESModuleOptions = {}) {
-  const root = resolveRoot(rootPath);
-  const outputDirectory = path.resolve(root, 'build/esm');
+  const project = Project.load(root);
+  const outputDirectory = project.resolve('build/esm');
   const hasExecutables = Object.keys(executable).length > 0;
 
-  const [{sourceCode}, {esnext}, nodePlugins, packageJSON, browserGroup] =
+  const [{sourceCode}, {react}, {esnext}, nodePlugins, browserGroup] =
     await Promise.all([
       import('./features/source-code.ts'),
+      import('./features/react.ts'),
       import('./features/esnext.ts'),
       getNodePlugins({bundle}),
-      loadPackageJSON(root),
-      getBrowserGroupTargetDetails({name: 'default'}, {root}),
+      getBrowserGroupTargetDetails({name: 'default'}, {root: project.root}),
     ]);
 
-  const resolvedEntries =
-    entries ?? (await sourceEntriesForPackage(root, packageJSON));
+  const resolvedEntries = entries ?? (await sourceEntriesForProject(project));
   const hasEntries = Object.keys(resolvedEntries).length > 0;
 
-  const source = sourceForEntries({...resolvedEntries, ...executable}, {root});
+  const source = sourceForEntries(
+    {...resolvedEntries, ...executable},
+    {root: project.root},
+  );
 
   const plugins: Plugin[] = [
     ...nodePlugins,
-    sourceCode({mode: 'production', react}),
+    sourceCode({mode: 'production', react: useReact}),
     esnext({mode: 'production', babel: false}),
     removeBuildFiles(
       [
@@ -211,12 +209,16 @@ export async function quiltPackageESModules({
         ...(commonjs ? ['build/cjs'] : []),
         ...(hasExecutables ? ['bin'] : []),
       ],
-      {root},
+      {root: project.root},
     ),
   ];
 
+  if (useReact) {
+    plugins.push(react());
+  }
+
   if (hasExecutables) {
-    plugins.push(packageExecutables(executable, {root}));
+    plugins.push(packageExecutables(executable, {root: project.root}));
   }
 
   if (graphql) {
@@ -261,18 +263,6 @@ export async function quiltPackageESModules({
   const options = {
     input: source.files,
     plugins,
-    onwarn(warning, defaultWarn) {
-      // Removes annoying warnings for React-focused libraries that
-      // include 'use client' directives.
-      if (
-        warning.code === 'MODULE_LEVEL_DIRECTIVE' &&
-        /['"]use client['"]/.test(warning.message)
-      ) {
-        return;
-      }
-
-      defaultWarn(warning);
-    },
     output,
   } satisfies RollupOptions;
 
@@ -319,35 +309,38 @@ export async function quiltPackageESModules({
  * ```
  */
 export async function quiltPackageESNext({
-  root: rootPath = process.cwd(),
-  react,
+  root = process.cwd(),
+  react: useReact,
   graphql = true,
   entries,
   bundle,
   customize,
 }: PackageBaseOptions = {}) {
-  const root = resolveRoot(rootPath);
-  const outputDirectory = path.join(root, 'build/esnext');
+  const project = Project.load(root);
+  const outputDirectory = project.resolve('build/esnext');
 
-  const [{sourceCode}, {esnext}, nodePlugins, packageJSON] = await Promise.all([
+  const [{sourceCode}, {react}, {esnext}, nodePlugins] = await Promise.all([
     import('./features/source-code.ts'),
+    import('./features/react.ts'),
     import('./features/esnext.ts'),
     getNodePlugins({bundle}),
-    loadPackageJSON(root),
   ]);
 
-  const resolvedEntries =
-    entries ?? (await sourceEntriesForPackage(root, packageJSON));
+  const resolvedEntries = entries ?? (await sourceEntriesForProject(project));
 
-  const source = sourceForEntries(resolvedEntries, {root});
+  const source = sourceForEntries(resolvedEntries, {root: project.root});
 
   const plugins: Plugin[] = [
     ...nodePlugins,
-    sourceCode({mode: 'production', babel: false, react}),
+    sourceCode({mode: 'production', babel: false, react: useReact}),
     esnext({mode: 'production', babel: false}),
-    removeBuildFiles(['build/esnext'], {root}),
+    removeBuildFiles(['build/esnext'], {root: project.root}),
   ];
 
+  if (useReact) {
+    plugins.push(react());
+  }
+
   if (graphql) {
     const {graphql} = await import('./features/graphql.ts');
     plugins.push(graphql({manifest: false}));
@@ -505,68 +498,3 @@ function sourceForEntries(
 
   return {root: sourceRoot, files: sourceEntryFiles};
 }
-
-async function sourceEntriesForPackage(root: string, packageJSON: PackageJSON) {
-  const {main, exports} = packageJSON;
-
-  const entries: Record<string, string> = {};
-
-  if (typeof main === 'string') {
-    entries['.'] = await resolveTargetFileAsSource(main, root);
-  }
-
-  if (typeof exports === 'string') {
-    entries['.'] = await resolveTargetFileAsSource(exports, root);
-    return entries;
-  } else if (exports == null || typeof exports !== 'object') {
-    return entries;
-  }
-
-  for (const [exportPath, exportCondition] of Object.entries(
-    exports as Record<string, null | string | Record<string, string>>,
-  )) {
-    let targetFile: string | null | undefined = null;
-
-    if (exportCondition == null) continue;
-
-    if (typeof exportCondition === 'string') {
-      targetFile = exportCondition;
-    } else {
-      targetFile ??=
-        exportCondition['source'] ??
-        exportCondition['quilt:source'] ??
-        exportCondition['quilt:esnext'] ??
-        Object.values(exportCondition).find(
-          (condition) =>
-            typeof condition === 'string' && condition.startsWith('./build/'),
-        );
-    }
-
-    if (targetFile == null) continue;
-
-    const sourceFile = await resolveTargetFileAsSource(targetFile, root);
-
-    entries[exportPath] = sourceFile;
-  }
-
-  return entries;
-}
-
-async function resolveTargetFileAsSource(file: string, root: string) {
-  const sourceFile = file.includes('/build/')
-    ? (
-        await glob(
-          file
-            .replace(/[/]build[/][^/]+[/]/, '/*/')
-            .replace(/(\.d\.ts|\.[\w]+)$/, '.*'),
-          {
-            cwd: root,
-            absolute: true,
-            ignore: [path.resolve(root, file)],
-          },
-        )
-      )[0]!
-    : path.resolve(root, file);
-
-  return sourceFile;
-}

package/source/server.ts

@@ -1,14 +1,12 @@
-import * as path from 'path';
 import {type InputPluginOption, type RollupOptions} from 'rollup';
-import {glob} from 'glob';
 
+import {Project} from './shared/project.ts';
 import {
   RollupNodePluginOptions,
   getNodePlugins,
   removeBuildFiles,
 } from './shared/rollup.ts';
-import {resolveRoot} from './shared/path.ts';
-import {loadPackageJSON, type PackageJSON} from './shared/package-json.ts';
+
 import {magicModuleRequestRouterEntry} from './features/request-router.ts';
 import {resolveEnvOption, type MagicModuleEnvOptions} from './features/env.ts';
 import {MAGIC_MODULE_ENTRY, MAGIC_MODULE_REQUEST_ROUTER} from './constants.ts';
@@ -119,10 +117,10 @@ export async function quiltServer({
   port,
   host,
 }: ServerOptions = {}) {
-  const root = resolveRoot(rootPath);
+  const project = Project.load(rootPath);
   const mode =
     (typeof env === 'object' ? env?.mode : undefined) ?? 'production';
-  const outputDirectory = path.join(root, 'build/server');
+  const outputDirectory = project.resolve('build/server');
 
   const minify = output?.minify ?? false;
   const bundle = output?.bundle;
@@ -134,24 +132,24 @@ export async function quiltServer({
     {magicModuleEnv, replaceProcessEnv},
     {sourceCode},
     {tsconfigAliases},
+    {monorepoPackageAliases},
     {react},
     {esnext},
     nodePlugins,
-    packageJSON,
   ] = await Promise.all([
     import('rollup-plugin-visualizer'),
     import('./features/env.ts'),
     import('./features/source-code.ts'),
     import('./features/typescript.ts'),
+    import('./features/node.ts'),
     import('./features/react.ts'),
     import('./features/esnext.ts'),
     getNodePlugins({bundle}),
-    loadPackageJSON(root),
   ]);
 
   const serverEntry = entry
-    ? path.resolve(root, entry)
-    : await sourceForServer(root, packageJSON);
+    ? project.resolve(entry)
+    : await sourceForServer(project);
 
   const finalEntry =
     format === 'request-router'
@@ -163,10 +161,11 @@ export async function quiltServer({
     replaceProcessEnv({mode}),
     magicModuleEnv({...resolveEnvOption(env), mode}),
     sourceCode({mode, targets: ['current node']}),
-    tsconfigAliases({root}),
+    tsconfigAliases({root: project.root}),
+    monorepoPackageAliases({root: project.root}),
     react(),
     esnext({mode, targets: ['current node']}),
-    removeBuildFiles(['build/server', 'build/reports'], {root}),
+    removeBuildFiles(['build/server', 'build/reports'], {root: project.root}),
   ];
 
   if (format === 'request-router') {
@@ -198,7 +197,7 @@ export async function quiltServer({
       template: 'treemap',
       open: false,
       brotliSize: true,
-      filename: path.resolve(root, `build/reports/bundle-visualizer.html`),
+      filename: project.resolve(`build/reports/bundle-visualizer.html`),
     }),
   );
 
@@ -206,18 +205,6 @@ export async function quiltServer({
     input:
       finalEntry === MAGIC_MODULE_ENTRY ? {server: finalEntry} : finalEntry,
     plugins,
-    onwarn(warning, defaultWarn) {
-      // Removes annoying warnings for React-focused libraries that
-      // include 'use client' directives.
-      if (
-        warning.code === 'MODULE_LEVEL_DIRECTIVE' &&
-        /['"]use client['"]/.test(warning.message)
-      ) {
-        return;
-      }
-
-      defaultWarn(warning);
-    },
     output: {
       format:
         outputFormat === 'commonjs' || outputFormat === 'cjs' ? 'cjs' : 'esm',
@@ -232,19 +219,18 @@ export async function quiltServer({
   } satisfies RollupOptions;
 }
 
-async function sourceForServer(root: string, packageJSON: PackageJSON) {
-  const {main, exports} = packageJSON;
+async function sourceForServer(project: Project) {
+  const {main, exports} = project.packageJSON.raw;
 
   const entryFromPackageJSON = main ?? (exports as any)?.['.'];
 
   if (entryFromPackageJSON) {
-    return path.resolve(root, entryFromPackageJSON);
+    return project.resolve(entryFromPackageJSON);
   }
 
-  const possibleSourceFiles = await glob(
+  const possibleSourceFiles = await project.glob(
     '{index,server,service,backend,entry,input}.{ts,tsx,mjs,js,jsx}',
     {
-      cwd: root,
       nodir: true,
       absolute: true,
     },

package/source/shared/magic-module.ts

@@ -11,24 +11,30 @@ export function createMagicModulePlugin({
   sideEffects = false,
 }: {
   readonly name: string;
-  readonly alias?: string;
+  readonly alias?: string | (() => string | Promise<string>);
   readonly module: string;
   readonly sideEffects?: boolean;
   source?(this: PluginContext): string | Promise<string>;
 }) {
+  const virtualModuleAlias = `${VIRTUAL_MODULE_PREFIX}${module}${VIRTUAL_MODULE_POSTFIX}`;
+
   return {
     name,
-    resolveId(id) {
+    async resolveId(id) {
       if (id !== module) return null;
 
+      const resolved =
+        (typeof alias === 'function' ? await alias() : alias) ??
+        virtualModuleAlias;
+
       return {
-        id: alias,
+        id: resolved,
         moduleSideEffects: sideEffects ? 'no-treeshake' : undefined,
       };
     },
     load: getSource
       ? async function load(source) {
-          if (source !== alias) return null;
+          if (source !== virtualModuleAlias) return null;
 
           const code = await getSource.call(this);
 

package/source/shared/project.ts

@@ -0,0 +1,150 @@
+import * as path from 'path';
+import {readFileSync} from 'fs';
+import {fileURLToPath} from 'url';
+
+import {glob, type GlobOptions} from 'glob';
+
+const PROJECT_CACHE = new Map<string, Project>();
+
+export class Project {
+  static load(root: string | URL) {
+    const resolvedRoot = resolveRoot(root);
+
+    let project = PROJECT_CACHE.get(resolvedRoot);
+
+    if (project == null) {
+      project = new Project(resolvedRoot);
+      PROJECT_CACHE.set(resolvedRoot, project);
+    }
+
+    return project;
+  }
+
+  readonly root: string;
+
+  get path() {
+    return this.root;
+  }
+
+  get name() {
+    return this.packageJSON.name;
+  }
+
+  #packageJSON: PackageJSON | undefined;
+  get packageJSON() {
+    this.#packageJSON ??= new PackageJSON(this.root);
+    return this.#packageJSON;
+  }
+
+  constructor(root: string | URL) {
+    this.root = resolveRoot(root);
+  }
+
+  resolve(...segments: string[]) {
+    return path.resolve(this.root, ...segments);
+  }
+
+  glob(pattern: string | string[], options?: GlobOptions) {
+    return glob(pattern, {
+      ...options,
+      absolute: true,
+      cwd: this.root,
+    }) as Promise<string[]>;
+  }
+}
+
+export interface PackageJSONRaw {
+  name: string;
+  main?: string;
+  private?: boolean;
+  exports?: Record<string, string | Record<string, string>>;
+  dependencies?: Record<string, string>;
+  peerDependencies?: Record<string, string>;
+  peerDependenciesMeta?: Record<string, {optional?: boolean}>;
+  devDependencies?: Record<string, string>;
+  [key: string]: unknown;
+}
+
+export class PackageJSON {
+  readonly raw: PackageJSONRaw;
+  readonly path: string;
+
+  get name() {
+    return this.raw.name;
+  }
+
+  constructor(rootOrPath: string) {
+    this.path = rootOrPath.endsWith('package.json')
+      ? rootOrPath
+      : path.join(rootOrPath, 'package.json');
+    this.raw = JSON.parse(readFileSync(this.path, 'utf8'));
+  }
+}
+
+function resolveRoot(root: string | URL) {
+  return typeof root === 'string' ? root : fileURLToPath(root);
+}
+
+export async function sourceEntriesForProject(project: Project) {
+  const {main, exports} = project.packageJSON.raw;
+
+  const entries: Record<string, string> = {};
+
+  if (typeof main === 'string') {
+    entries['.'] = await resolveTargetFileAsSource(main, project);
+  }
+
+  if (typeof exports === 'string') {
+    entries['.'] = await resolveTargetFileAsSource(exports, project);
+    return entries;
+  } else if (exports == null || typeof exports !== 'object') {
+    return entries;
+  }
+
+  for (const [exportPath, exportCondition] of Object.entries(
+    exports as Record<string, null | string | Record<string, string>>,
+  )) {
+    let targetFile: string | null | undefined = null;
+
+    if (exportCondition == null) continue;
+
+    if (typeof exportCondition === 'string') {
+      targetFile = exportCondition;
+    } else {
+      targetFile ??=
+        exportCondition['source'] ??
+        exportCondition['quilt:source'] ??
+        exportCondition['quilt:esnext'] ??
+        Object.values(exportCondition).find(
+          (condition) =>
+            typeof condition === 'string' && condition.startsWith('./build/'),
+        );
+    }
+
+    if (targetFile == null) continue;
+
+    const sourceFile = await resolveTargetFileAsSource(targetFile, project);
+
+    entries[exportPath] = sourceFile;
+  }
+
+  return entries;
+}
+
+async function resolveTargetFileAsSource(file: string, project: Project) {
+  const sourceFile = file.includes('/build/')
+    ? (
+        await project.glob(
+          file
+            .replace(/[/]build[/][^/]+[/]/, '/*/')
+            .replace(/(\.d\.ts|\.[\w]+)$/, '.*'),
+          {
+            absolute: true,
+            ignore: [project.resolve(file)],
+          },
+        )
+      )[0]!
+    : project.resolve(file);
+
+  return sourceFile;
+}

package/build/esm/shared/package-json.mjs

@@ -1,16 +0,0 @@
-import * as path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { readFile } from 'node:fs/promises';
-
-async function loadPackageJSON(root) {
-  const file = await readFile(
-    path.join(
-      typeof root === "string" ? root : fileURLToPath(root),
-      "package.json"
-    ),
-    "utf8"
-  );
-  return JSON.parse(file);
-}
-
-export { loadPackageJSON };