@quilted/rollup 0.1.19 → 0.2.0

package/build/esm/features/source-code.mjs

@@ -6,46 +6,72 @@ const require = createRequire(import.meta.url);
 function sourceCode({
   mode,
   targets,
+  react = true,
   babel: useBabel = true
 }) {
   if (!useBabel) {
     return esbuild({
       // Support very modern features
-      target: 'es2022',
-      jsx: 'automatic',
-      jsxImportSource: 'react',
-      exclude: 'node_modules/**'
+      target: "es2022",
+      jsx: "automatic",
+      jsxImportSource: "react",
+      exclude: "node_modules/**"
     });
   }
-  return babel({
+  const babelOverride = typeof useBabel === "boolean" ? {} : useBabel;
+  const useBuiltIns = babelOverride.useBuiltIns;
+  let babelOptions = {
     envName: mode,
     configFile: false,
     babelrc: false,
-    presets: [require.resolve('@babel/preset-typescript'), [require.resolve('@babel/preset-react'), {
-      runtime: 'automatic',
-      importSource: 'react',
-      development: mode === 'development'
-    }], [require.resolve('@babel/preset-env'), {
-      useBuiltIns: false,
-      bugfixes: true,
-      shippedProposals: true
-      // I thought I wanted this, but it seems to break the `targets` option
-      // passed as a root argument.
-      // ignoreBrowserslistConfig: targets != null,
-    }]],
-
-    plugins: [[require.resolve('@babel/plugin-proposal-decorators'), {
-      version: '2023-01'
-    }]],
-    extensions: ['.ts', '.tsx', '.mts', '.mtsx', '.js', '.jsx', '.es6', '.es', '.mjs'],
-    exclude: 'node_modules/**',
-    babelHelpers: 'bundled',
+    presets: [
+      require.resolve("@babel/preset-typescript"),
+      [
+        require.resolve("@babel/preset-react"),
+        {
+          runtime: "automatic",
+          importSource: typeof react === "string" ? react : "react",
+          development: mode === "development"
+        }
+      ],
+      [
+        require.resolve("@babel/preset-env"),
+        {
+          bugfixes: true,
+          shippedProposals: true,
+          useBuiltIns,
+          corejs: useBuiltIns ? 3 : void 0
+          // I thought I wanted this, but it seems to break the `targets` option
+          // passed as a root argument.
+          // ignoreBrowserslistConfig: targets != null,
+        }
+      ]
+    ],
+    plugins: [
+      [
+        require.resolve("@babel/plugin-proposal-decorators"),
+        { version: "2023-01" }
+      ]
+    ],
+    extensions: [
+      ".ts",
+      ".tsx",
+      ".mts",
+      ".mtsx",
+      ".js",
+      ".jsx",
+      ".es6",
+      ".es",
+      ".mjs"
+    ],
+    exclude: "node_modules/**",
+    babelHelpers: "bundled",
     skipPreflightCheck: true,
     // Babel doesn’t like this option being set to `undefined`.
-    ...(targets ? {
-      targets
-    } : {})
-  });
+    ...targets ? { targets } : {}
+  };
+  babelOptions = babelOverride.options?.(babelOptions) ?? babelOptions;
+  return babel(babelOptions);
 }
 
 export { sourceCode };

package/build/esm/features/system-js.mjs

@@ -1,28 +1,23 @@
 import { readFile } from 'node:fs/promises';
 import { createRequire } from 'node:module';
 
-function systemJS({
-  minify = false
-} = {}) {
+function systemJS({ minify = false } = {}) {
   return {
-    name: '@quilted/system-js',
+    name: "@quilted/system-js",
     async renderChunk(_, chunk, options) {
-      if (options.format !== 'system' || !chunk.isEntry) return null;
+      if (options.format !== "system" || !chunk.isEntry)
+        return null;
       const require = createRequire(import.meta.url);
-      const systemjs = minify ? require.resolve('systemjs/dist/s.min.js') : require.resolve('systemjs/dist/s.js');
-
-      // We write the systemjs loader to a dedicated file, and we make it the
-      // "first import" of the chunk so that it is the first file listed in
-      // the manifest.
+      const systemjs = minify ? require.resolve("systemjs/dist/s.min.js") : require.resolve("systemjs/dist/s.js");
       const fileHandle = this.emitFile({
-        type: 'asset',
-        name: 'loader.js',
-        source: (await readFile(systemjs, {
-          encoding: 'utf8'
-        })).replace(
-        // Remove the source map comment, if it is present, because we don’t upload the
-        // sourcemap for this file.
-        /\n?[/][/]# sourceMappingURL=s.*\.map\n?$/, '')
+        type: "asset",
+        name: "loader.js",
+        source: (await readFile(systemjs, { encoding: "utf8" })).replace(
+          // Remove the source map comment, if it is present, because we don’t upload the
+          // sourcemap for this file.
+          /\n?[/][/]# sourceMappingURL=s.*\.map\n?$/,
+          ""
+        )
       });
       chunk.imports.unshift(this.getFileName(fileHandle));
       return null;

package/build/esm/features/typescript.mjs

@@ -4,30 +4,33 @@ import * as fs from 'node:fs';
 async function createTSConfigAliasPlugin({
   root = process.cwd()
 } = {}) {
-  const [{
-    default: alias
-  }, tsconfig] = await Promise.all([import('@rollup/plugin-alias'), getTSConfig(root)]);
+  const [{ default: alias }, tsconfig] = await Promise.all([
+    import('@rollup/plugin-alias'),
+    getTSConfig(root)
+  ]);
   const tsconfigPaths = tsconfig?.compilerOptions?.paths;
-  if (tsconfigPaths == null) return undefined;
+  if (tsconfigPaths == null)
+    return void 0;
   return alias({
     entries: Object.entries(tsconfigPaths).map(([name, aliases]) => {
       return {
-        find: name.includes('*') ? new RegExp(`^${name.replace(/\*/, '(.*)')}$`) : name,
-        replacement: aliases[0].replace('*', '$1')
+        find: name.includes("*") ? new RegExp(`^${name.replace(/\*/, "(.*)")}$`) : name,
+        replacement: aliases[0].replace("*", "$1")
       };
     })
   });
 }
 async function getTSConfig(root) {
-  const tsconfigPath = path.join(root, 'tsconfig.json');
+  const tsconfigPath = path.join(root, "tsconfig.json");
   if (!fs.existsSync(tsconfigPath)) {
-    return undefined;
+    return void 0;
   }
   try {
-    const tsconfig = JSON.parse(await fs.promises.readFile(tsconfigPath, 'utf8'));
+    const tsconfig = JSON.parse(
+      await fs.promises.readFile(tsconfigPath, "utf8")
+    );
     return tsconfig;
   } catch {
-    // intentional noop
   }
 }
 

package/build/esm/features/workers.mjs

@@ -0,0 +1,173 @@
+import { posix } from 'node:path';
+import { URLSearchParams } from 'node:url';
+import { rollup } from 'rollup';
+import { multiline } from '../shared/strings.mjs';
+
+const PREFIX = "\0quilt-worker:";
+const ENTRY_PREFIX = "\0quilt-worker-entry:";
+const MAGIC_MODULE_WORKER = "quilt:module/worker.js";
+function workers({
+  write = false,
+  baseURL,
+  contentForWorker = defaultContentForWorker,
+  plugins = defaultPlugins,
+  inputOptions = {},
+  outputOptions = {},
+  onIncludeFile
+} = {}) {
+  let parentInputOptions;
+  const workerMap = /* @__PURE__ */ new Map();
+  return {
+    name: "@quilted/workers",
+    buildStart(inputOptions2) {
+      parentInputOptions = inputOptions2;
+    },
+    async resolveId(source, importer) {
+      if (!source.startsWith(PREFIX))
+        return null;
+      const { workerId, wrapper } = getWorkerRequest(source.replace(PREFIX, ""));
+      const resolvedWorker = await this.resolve(workerId, importer, {
+        skipSelf: true
+      });
+      if (resolvedWorker == null)
+        return null;
+      return `${PREFIX}${resolvedWorker.id}${wrapperToSearchString(wrapper)}`;
+    },
+    async load(id) {
+      if (!id.startsWith(PREFIX))
+        return null;
+      const { workerId, wrapper } = getWorkerRequest(id.replace(PREFIX, ""));
+      const workerContext = { module: workerId, wrapper };
+      const workerPlugins = [
+        {
+          name: "@quilted/workers/magic-modules",
+          resolveId(source) {
+            if (source.startsWith(ENTRY_PREFIX)) {
+              return { id: source };
+            }
+            if (source === MAGIC_MODULE_WORKER) {
+              return { id: workerId };
+            }
+            return null;
+          },
+          async load(id2) {
+            if (!id2.startsWith(ENTRY_PREFIX))
+              return null;
+            const { wrapper: wrapper2, workerId: workerId2 } = getWorkerRequest(
+              id2.replace(ENTRY_PREFIX, "")
+            );
+            const context = { module: workerId2, wrapper: wrapper2 };
+            const content = typeof contentForWorker === "function" ? await contentForWorker(context) : contentForWorker;
+            return content ?? defaultContentForWorker(context);
+          }
+        },
+        ...typeof plugins === "function" ? await plugins(
+          [
+            ...parentInputOptions.plugins?.filter(
+              (plugin) => Boolean(plugin)
+            ) ?? []
+          ],
+          workerContext
+        ) : plugins
+      ];
+      const workerInput = `${ENTRY_PREFIX}${workerId}${wrapperToSearchString(
+        wrapper
+      )}`;
+      const baseInputOptions = {
+        ...parentInputOptions,
+        input: workerInput,
+        plugins: workerPlugins
+      };
+      const workerInputOptions = typeof inputOptions === "function" ? await inputOptions(baseInputOptions, workerContext) : baseInputOptions;
+      const baseOutputOptions = {
+        format: "iife",
+        inlineDynamicImports: true
+      };
+      const workerOutputOptions = typeof outputOptions === "function" ? await outputOptions(baseOutputOptions, workerContext) : { ...baseOutputOptions, ...outputOptions };
+      const shouldWrite = typeof write === "function" ? await write(workerContext) : write;
+      const bundle = await rollup(workerInputOptions);
+      const result = await (shouldWrite ? bundle.write(workerOutputOptions) : bundle.generate(workerOutputOptions));
+      const firstChunk = result.output.find(
+        (output) => output.type === "chunk"
+      );
+      if (firstChunk == null) {
+        workerMap.delete(workerId);
+        return null;
+      }
+      workerMap.set(workerId, firstChunk);
+      for (const module of Object.keys(firstChunk.modules)) {
+        onIncludeFile?.(module, id);
+        this.addWatchFile(module);
+      }
+      const filename = firstChunk.fileName;
+      let resolvedBaseURL = filename;
+      if (typeof baseURL === "string") {
+        resolvedBaseURL = posix.join(baseURL, filename);
+      } else if (typeof baseURL === "function") {
+        const returnedBaseURL = await baseURL({
+          ...workerContext,
+          filename,
+          chunk: firstChunk,
+          outputOptions: workerOutputOptions
+        });
+        if (returnedBaseURL) {
+          resolvedBaseURL = posix.join(returnedBaseURL, filename);
+        }
+      }
+      return `export default ${JSON.stringify(resolvedBaseURL)};`;
+    },
+    generateBundle(_, bundle) {
+      if (write)
+        return;
+      for (const chunk of workerMap.values()) {
+        if (chunk.fileName in bundle)
+          continue;
+        bundle[chunk.fileName] = chunk;
+      }
+    }
+  };
+}
+function getWorkerRequest(id) {
+  const [workerId, searchString] = id.split("?");
+  const searchParams = new URLSearchParams(searchString);
+  const wrapperModule = searchParams.get("module");
+  const wrapperFunction = searchParams.get("function");
+  return {
+    workerId,
+    wrapper: { module: wrapperModule, function: wrapperFunction }
+  };
+}
+const workerFunctionContent = (pkg) => /* @__PURE__ */ new Map([
+  ["createWorker", `import ${JSON.stringify(MAGIC_MODULE_WORKER)};`],
+  [
+    "createThreadWorker",
+    multiline`
+        import {createThreadFromWebWorker} from ${JSON.stringify(pkg)};
+        import * as expose from ${JSON.stringify(MAGIC_MODULE_WORKER)};
+
+        createThreadFromWebWorker(self, {expose});
+      `
+  ]
+]);
+const KNOWN_WRAPPER_MODULES = /* @__PURE__ */ new Map([
+  ["@quilted/workers", workerFunctionContent("@quilted/workers")],
+  ["@quilted/react-workers", workerFunctionContent("@quilted/react-workers")],
+  ["@quilted/quilt/threads", workerFunctionContent("@quilted/quilt/threads")]
+]);
+function defaultContentForWorker({ wrapper }) {
+  const content = KNOWN_WRAPPER_MODULES.get(wrapper.module)?.get(
+    wrapper.function
+  );
+  if (content == null) {
+    throw new Error(`Unknown worker wrapper: ${JSON.stringify(wrapper)}`);
+  }
+  return content;
+}
+function defaultPlugins(mainBuildPlugins) {
+  return mainBuildPlugins.filter((plugin) => plugin.name !== "serve");
+}
+function wrapperToSearchString(wrapper) {
+  return `?${new URLSearchParams(Object.entries(wrapper)).toString()}`;
+}
+
+export { workers };

package/build/esm/index.mjs

@@ -1,3 +1,4 @@
-export { quiltAppBrowser, quiltAppServer } from './app.mjs';
+export { quiltApp, quiltAppBrowser, quiltAppServer } from './app.mjs';
 export { quiltModule } from './module.mjs';
-export { quiltPackageESModules, quiltPackageESNext } from './package.mjs';
+export { quiltPackage, quiltPackageESModules, quiltPackageESNext } from './package.mjs';
+export { quiltServer } from './server.mjs';

package/build/esm/module.mjs

@@ -1,99 +1,106 @@
 import * as path from 'node:path';
 import { glob } from 'glob';
-import { fileURLToPath } from 'node:url';
+import { resolveRoot } from './shared/path.mjs';
 import { getNodePlugins, removeBuildFiles } from './shared/rollup.mjs';
 import { loadPackageJSON } from './shared/package-json.mjs';
-import { getBrowserTargetDetails } from './shared/browserslist.mjs';
+import { getBrowserGroupTargetDetails, rollupGenerateOptionsForBrowsers } from './shared/browserslist.mjs';
+import { resolveEnvOption } from './features/env.mjs';
 
 async function quiltModule({
   root: rootPath = process.cwd(),
+  entry,
   env,
   assets,
   graphql = true
 } = {}) {
-  const root = typeof rootPath === 'string' ? rootPath : fileURLToPath(rootPath);
-  const mode = (typeof env === 'object' ? env?.mode : undefined) ?? 'production';
-  const outputDirectory = path.join(root, 'build/assets');
+  const root = resolveRoot(rootPath);
+  const mode = (typeof env === "object" ? env?.mode : env) ?? "production";
+  const outputDirectory = path.join(root, "build/assets");
   const minify = assets?.minify ?? true;
-  const hash = assets?.hash ?? 'async-only';
-  const browserTarget = await getBrowserTargetDetails(assets?.targets, {
+  const hash = assets?.hash ?? "async-only";
+  const bundle = assets?.bundle ?? true;
+  const browserGroup = await getBrowserGroupTargetDetails(assets?.targets, {
     root
   });
-  const targetFilenamePart = browserTarget.name ? `.${browserTarget.name}` : '';
-  const [{
-    visualizer
-  }, {
-    magicModuleEnv,
-    replaceProcessEnv
-  }, {
-    sourceCode
-  }, nodePlugins, packageJSON] = await Promise.all([import('rollup-plugin-visualizer'), import('./features/env.mjs'), import('./features/source-code.mjs'), getNodePlugins(), loadPackageJSON(root)]);
-  const source = await sourceForModule(root, packageJSON);
-  const plugins = [...nodePlugins, replaceProcessEnv({
-    mode
-  }), magicModuleEnv({
-    ...env,
-    mode
-  }), sourceCode({
-    mode: 'production',
-    targets: browserTarget.browsers
-  }), removeBuildFiles(['build/assets', 'build/reports'], {
-    root
-  })];
+  const targetFilenamePart = browserGroup.name ? `.${browserGroup.name}` : "";
+  const [
+    { visualizer },
+    { magicModuleEnv, replaceProcessEnv },
+    { sourceCode },
+    { esnext },
+    nodePlugins,
+    packageJSON
+  ] = await Promise.all([
+    import('rollup-plugin-visualizer'),
+    import('./features/env.mjs'),
+    import('./features/source-code.mjs'),
+    import('./features/esnext.mjs'),
+    getNodePlugins({ bundle }),
+    loadPackageJSON(root)
+  ]);
+  const finalEntry = entry ? path.resolve(root, entry) : await sourceForModule(root, packageJSON);
+  const plugins = [
+    ...nodePlugins,
+    replaceProcessEnv({ mode }),
+    magicModuleEnv({ ...resolveEnvOption(env), mode }),
+    sourceCode({ mode, targets: browserGroup.browsers }),
+    esnext({ mode, targets: browserGroup.browsers }),
+    removeBuildFiles(["build/assets", "build/reports"], { root })
+  ];
   if (graphql) {
-    const {
-      graphql
-    } = await import('./features/graphql.mjs');
-    plugins.push(graphql({
-      manifest: false
-    }));
+    const { graphql: graphql2 } = await import('./features/graphql.mjs');
+    plugins.push(graphql2({ manifest: false }));
   }
   if (minify) {
-    const {
-      minify
-    } = await import('rollup-plugin-esbuild');
-    plugins.push(minify());
+    const { minify: minify2 } = await import('rollup-plugin-esbuild');
+    plugins.push(minify2());
   }
-  plugins.push(visualizer({
-    template: 'treemap',
-    open: false,
-    brotliSize: true,
-    filename: path.resolve(root, `build/reports/bundle-visualizer${targetFilenamePart}.html`)
-  }));
+  plugins.push(
+    visualizer({
+      template: "treemap",
+      open: false,
+      brotliSize: true,
+      filename: path.resolve(
+        root,
+        `build/reports/bundle-visualizer${targetFilenamePart}.html`
+      )
+    })
+  );
   return {
-    input: source,
+    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)) {
+      if (warning.code === "MODULE_LEVEL_DIRECTIVE" && /['"]use client['"]/.test(warning.message)) {
         return;
       }
       defaultWarn(warning);
     },
     output: {
-      format: 'esm',
+      format: "esm",
       dir: outputDirectory,
-      entryFileNames: `[name]${targetFilenamePart}${hash === true ? `.[hash]` : ''}.js`,
-      chunkFileNames: `[name]${targetFilenamePart}${hash === true || hash === 'async-only' ? `.[hash]` : ''}.js`,
-      assetFileNames: `[name]${targetFilenamePart}${hash === true ? `.[hash]` : ''}.[ext]`
+      entryFileNames: `[name]${targetFilenamePart}${hash === true ? `.[hash]` : ""}.js`,
+      chunkFileNames: `[name]${targetFilenamePart}${hash === true || hash === "async-only" ? `.[hash]` : ""}.js`,
+      assetFileNames: `[name]${targetFilenamePart}${hash === true ? `.[hash]` : ""}.[ext]`,
+      generatedCode: await rollupGenerateOptionsForBrowsers(
+        browserGroup.browsers
+      )
     }
   };
 }
 async function sourceForModule(root, packageJSON) {
-  const {
-    main,
-    exports
-  } = packageJSON;
-  const entryFromPackageJSON = main ?? exports?.['.'];
+  const { main, exports } = packageJSON;
+  const entryFromPackageJSON = main ?? exports?.["."];
   if (entryFromPackageJSON) {
     return path.resolve(root, entryFromPackageJSON);
   }
-  const possibleSourceFiles = await glob('{index,module,entry,input}.{ts,tsx,mjs,js,jsx}', {
-    cwd: root,
-    nodir: true,
-    absolute: true
-  });
+  const possibleSourceFiles = await glob(
+    "{index,module,entry,input}.{ts,tsx,mjs,js,jsx}",
+    {
+      cwd: root,
+      nodir: true,
+      absolute: true
+    }
+  );
   return possibleSourceFiles[0];
 }