@quilted/rollup 0.2.4 → 0.2.5

package/source/features/node.ts

@@ -0,0 +1,74 @@
+import {realpathSync} from 'fs';
+
+import {Project, sourceEntriesForProject} from '../shared/project.ts';
+
+export async function monorepoPackageAliases({
+  root = process.cwd(),
+}: {root?: string} = {}) {
+  const project = Project.load(root);
+  const seenDependencies = new Set<string>();
+  const seenProjects = new Set<Project>();
+
+  function processProject(project: Project) {
+    const {dependencies, devDependencies} = project.packageJSON.raw;
+
+    for (const pkg of Object.keys({...dependencies, ...devDependencies})) {
+      if (seenDependencies.has(pkg)) continue;
+
+      seenDependencies.add(pkg);
+
+      let packageRoot: string | undefined;
+
+      try {
+        packageRoot = realpathSync(project.resolve('node_modules', pkg));
+      } catch {
+        // intentional noop
+      }
+
+      if (
+        packageRoot == null ||
+        packageRoot.includes('node_modules') ||
+        packageRoot === root
+      ) {
+        continue;
+      }
+
+      const packageProject = Project.load(packageRoot);
+      if (seenProjects.has(packageProject)) continue;
+
+      seenProjects.add(packageProject);
+      processProject(packageProject);
+    }
+  }
+
+  processProject(project);
+
+  const [{default: alias}, projectsWithEntries] = await Promise.all([
+    import('@rollup/plugin-alias'),
+    Promise.all(
+      Array.from(seenProjects, async (project) => {
+        const entries = await sourceEntriesForProject(project);
+        return {project, entries};
+      }),
+    ),
+  ]);
+
+  const aliases: import('@rollup/plugin-alias').Alias[] = [];
+
+  for (const {project, entries} of projectsWithEntries) {
+    const {name} = project;
+
+    for (const [entry, source] of Object.entries(entries)) {
+      const entryName = entry === '.' ? name : `${name}/${entry}`;
+
+      aliases.push({
+        find: new RegExp(`^${entryName}$`),
+        replacement: source,
+      });
+    }
+  }
+
+  return alias({
+    entries: aliases,
+  });
+}

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,
     },