@quilted/rollup 0.2.3 → 0.2.5

package/source/features/react.ts

@@ -0,0 +1,26 @@
+import type {Plugin} from 'rollup';
+
+export function react() {
+  return {
+    name: '@quilted/react',
+    options(options) {
+      return {
+        ...options,
+        onLog(level, log, handler) {
+          if (
+            log.code === 'MODULE_LEVEL_DIRECTIVE' &&
+            /['"]use client['"]/.test(log.message)
+          ) {
+            return;
+          }
+
+          if (options.onLog) {
+            options.onLog(level, log, handler);
+          } else {
+            handler(level, log);
+          }
+        },
+      };
+    },
+  } satisfies Plugin;
+}

package/source/features/typescript.ts

@@ -1,7 +1,7 @@
 import * as path from 'path';
 import * as fs from 'fs';
 
-export async function createTSConfigAliasPlugin({
+export async function tsconfigAliases({
   root = process.cwd(),
 }: {root?: string} = {}) {
   const [{default: alias}, tsconfig] = await Promise.all([

package/source/index.ts

@@ -1,7 +1,9 @@
 export {
-  quiltApp,
+  quiltAppOptions,
   quiltAppBrowser,
+  quiltAppBrowserOptions,
   quiltAppServer,
+  quiltAppServerOptions,
   type AppOptions,
   type AppBaseOptions,
   type AppBrowserOptions,

package/source/module.ts

@@ -1,14 +1,11 @@
-import * as path from 'path';
-import {Plugin, type RollupOptions} from 'rollup';
-import {glob} from 'glob';
+import {type InputPluginOption, type RollupOptions} from 'rollup';
 
-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}` : '';
 
@@ -86,29 +83,34 @@ export async function quiltModule({
     {visualizer},
     {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: Plugin[] = [
+  const plugins: InputPluginOption[] = [
     ...nodePlugins,
     replaceProcessEnv({mode}),
     magicModuleEnv({...resolveEnvOption(env), mode}),
     sourceCode({mode, targets: browserGroup.browsers}),
+    tsconfigAliases({root: project.root}),
+    monorepoPackageAliases({root: project.root}),
     esnext({mode, targets: browserGroup.browsers}),
-    removeBuildFiles(['build/assets', 'build/reports'], {root}),
+    react(),
+    removeBuildFiles(['build/assets', 'build/reports'], {root: project.root}),
   ];
 
   if (graphql) {
@@ -126,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`,
       ),
     }),
@@ -136,18 +137,6 @@ export async function quiltModule({
   return {
     input: 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: 'esm',
       dir: outputDirectory,
@@ -167,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 {Plugin, type RollupOptions} from 'rollup';
-import {glob} from 'glob';
+import {type InputPluginOption, type RollupOptions} from 'rollup';
 
+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';
@@ -107,6 +105,8 @@ export interface ServerOutputOptions
   format?: 'esmodules' | 'esm' | 'es' | 'commonjs' | 'cjs';
 }
 
+export {MAGIC_MODULE_ENTRY, MAGIC_MODULE_REQUEST_ROUTER};
+
 export async function quiltServer({
   root: rootPath = process.cwd(),
   entry,
@@ -117,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;
@@ -131,34 +131,41 @@ export async function quiltServer({
     {visualizer},
     {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'
       ? MAGIC_MODULE_ENTRY
       : serverEntry ?? MAGIC_MODULE_ENTRY;
 
-  const plugins: Plugin[] = [
+  const plugins: InputPluginOption[] = [
     ...nodePlugins,
     replaceProcessEnv({mode}),
     magicModuleEnv({...resolveEnvOption(env), mode}),
     sourceCode({mode, targets: ['current node']}),
+    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') {
@@ -190,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`),
     }),
   );
 
@@ -198,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',
@@ -224,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/browserslist.ts

@@ -30,7 +30,9 @@ export async function getBrowserGroupTargetDetails(
       return config[targetName] ?? ['defaults'];
     })());
 
-  return {name: targets.name, browsers: browserslist(targetBrowsers)};
+  const browsers = browserslist(targetBrowsers);
+
+  return {name: targets.name, browsers};
 }
 
 export interface BrowserGroups {