Skip to content

A platform for community discussion. Free, open, simple.

8.3 KB
Raw Blame
import BabelTransformTypescript from "@babel/plugin-transform-typescript";
import BabelPresetEnv from "@babel/preset-env";
import { rollup } from "@rollup/browser";
import { babel, getBabelOutputPlugin } from "@rollup/plugin-babel";
import HTMLBarsInlinePrecompile from "babel-plugin-ember-template-compilation";
import DecoratorTransforms from "decorator-transforms";
import colocatedBabelPlugin from "ember-cli-htmlbars/lib/colocated-babel-plugin";
import { precompile } from "ember-source/ember-template-compiler/index.js";
import StripTestSelectorsPlugin from "strip-test-selectors/src/strip-test-selectors";
import { browsers } from "../discourse/config/targets.js";
import babelTransformModuleRenames from "../discourse/lib/babel-transform-module-renames.js";
import discourseSourceImports from "../discourse/lib/discourse-source-imports.mjs";
import AddThemeGlobals from "./add-theme-globals.js";
import BabelResolveCoreImports from "./babel-resolve-core-imports.js";
import BabelResolvePluginImports from "./babel-resolve-plugin-imports.js";
import discourseColocation from "./rollup-plugins/discourse-colocation.js";
import discourseExternalLoader from "./rollup-plugins/discourse-external-loader.js";
import discourseFileSearch from "./rollup-plugins/discourse-file-search.js";
import discourseGjs from "./rollup-plugins/discourse-gjs.js";
import discourseHbs from "./rollup-plugins/discourse-hbs.js";
import discourseRegisterComponents from "./rollup-plugins/discourse-register-components.js";
import discourseRouteMaps from "./rollup-plugins/discourse-route-maps.js";
import discourseTerser from "./rollup-plugins/discourse-terser.js";
import discourseVirtualLoader from "./rollup-plugins/discourse-virtual-loader.js";
import { labelFor, routeNamesFor } from "./rollup-virtual-imports.js";
import { urlTableFor } from "./route-map-parser.js";
import buildEmberTemplateManipulatorPlugin from "./theme-hbs-ast-transforms.js";
import buildThisFallbackPlugin from "./this-fallback.js";
import transformActionSyntax from "./transform-action-syntax.js";
import createVirtualFs from "./virtual-fs.js";

let caches = new Map();

async function performRollup(modules, opts) {
  let basePath = opts.pluginName
    ? `discourse/plugins/${opts.pluginName}/`
    : `theme-${opts.themeId}/`;

  const inputConfig = {};

  for (const key of Object.keys(opts.entrypoints)) {
    inputConfig[key] = `virtual:entrypoint:${key}`;
  }

  const fs = createVirtualFs(modules, basePath);

  // Filled in by `discourse-route-maps` before the entrypoint is generated from it.
  const routeTables = { bundleByRoute: {}, derived: [] };
  opts.routeTables = routeTables;

  const cache = opts.pluginName ? caches.get(opts.pluginName) : false;

  const result = await rollup({
    input: inputConfig,
    logLevel: "info",
    fs,
    cache,
    onLog(level, message) {
      if (String(message).startsWith("Circular dependency")) {
        return;
      }
      // eslint-disable-next-line no-console
      console.info(level, message);
    },
    plugins: [
      discourseRouteMaps({
        modules,
        label: labelFor(opts),
        tables: routeTables,
        staticModules: !!opts.frontendConfig?.staticModules,
      }),
      discourseSourceImports({ fs }),
      discourseFileSearch(),
      discourseVirtualLoader({
        isTheme: !!opts.themeId,
        basePath,
        entrypoints: opts.entrypoints,
        opts,
      }),
      discourseExternalLoader({ basePath }),
      discourseColocation({ basePath }),
      getBabelOutputPlugin({
        plugins: [BabelResolveCoreImports, BabelResolvePluginImports],
        compact: false,
      }),
      babel({
        extensions: [".js", ".gjs", ".ts", ".gts", ".hbs"],
        babelHelpers: "bundled",
        compact: false,
        // Support `import ... with { ... }` for cross-plugin imports
        parserOpts: { plugins: ["importAttributes"] },
        overrides: [
          {
            test: /\.(gts|ts|mts|cts)$/,
            plugins: [[BabelTransformTypescript, { allowDeclareFields: true }]],
          },
        ],
        plugins: [
          [DecoratorTransforms, { runEarly: true }],
          opts.themeId ? AddThemeGlobals : null,
          babelTransformModuleRenames,
          colocatedBabelPlugin,
          [
            HTMLBarsInlinePrecompile,
            {
              compiler: { precompile },
              enableLegacyModules: [
                "ember-cli-htmlbars",
                "ember-cli-htmlbars-inline-precompile",
                "htmlbars-inline-precompile",
              ],
              transforms: [
                buildThisFallbackPlugin(),
                buildEmberTemplateManipulatorPlugin(opts.themeId),
                transformActionSyntax,
                ...(opts.minify ? [StripTestSelectorsPlugin] : []),
              ],
            },
          ],
        ].filter(Boolean),
        presets: [
          [
            BabelPresetEnv,
            {
              modules: false,
              targets: { browsers },
            },
          ],
        ],
      }),
      discourseHbs(),
      discourseGjs(),
      discourseRegisterComponents({ basePath }),
      discourseTerser({ opts }),
    ],
  });

  const bundle = await result.generate({
    format: "es",
    sourcemap: "hidden",
    importAttributesKey: "with",
    entryFileNames: `${opts.filenamePrefix ?? ""}[name].[hash:6]${opts.filenameSuffix ?? ""}.js`,
    // One chunk per test file exceeds what a 6-character hash allows in larger plugins.
    chunkFileNames: `${opts.filenamePrefix ?? ""}chunk.[hash:8]${opts.filenameSuffix ?? ""}.js`,
  });

  if (opts.pluginName) {
    caches.set(opts.pluginName, result.cache);
  }

  const externalPluginImports = [
    ...new Set(
      bundle.output
        .flatMap((c) => c.imports ?? [])
        .filter((i) => i.startsWith("discourse/plugins/"))
        .map((i) => i.split("/")[2])
    ),
  ];

  const routeVirtualPrefix = `${basePath}virtual:route:`;

  // Keyed by the qualified `<entrypoint>:<bundle>` from the module id, because two entrypoints
  // can each have a bundle of the same name.
  const bundleNameByFile = {};
  for (const chunk of bundle.output) {
    if (chunk.facadeModuleId?.startsWith(routeVirtualPrefix)) {
      bundleNameByFile[chunk.fileName] = chunk.facadeModuleId.slice(
        routeVirtualPrefix.length
      );
    }
  }

  // Rollup may hoist the entrypoint module into a shared chunk, so find where it landed.
  function routeBundlesForEntry(entryName) {
    const entrypointModuleId = `${basePath}virtual:entrypoint:${entryName}`;

    const owner = bundle.output.find((chunk) =>
      chunk.moduleIds?.includes(entrypointModuleId)
    );

    const fileNameByBundle = {};

    for (const fileName of owner?.dynamicImports ?? []) {
      const qualified = bundleNameByFile[fileName];

      if (qualified?.startsWith(`${entryName}:`)) {
        fileNameByBundle[qualified.slice(entryName.length + 1)] = fileName;
      }
    }

    // A bundle name means a different bundle in each entrypoint.
    const owned = routeNamesFor(
      opts.entrypoints[entryName].modules,
      routeTables.bundleByRoute
    );
    const urls = urlTableFor(
      routeTables.derived.filter((route) => owned.has(route.name))
    );

    // Already ordered most specific first, which is the order Ruby matches them in.
    return urls
      .filter(({ bundleName }) => fileNameByBundle[bundleName])
      .map(({ bundleName, url }) => ({
        url,
        fileName: fileNameByBundle[bundleName],
      }));
  }

  const chunks = Object.fromEntries(
    bundle.output
      .filter((c) => c.code)
      .map((chunk) => {
        return [
          chunk.fileName,
          {
            code: chunk.code,
            map: JSON.stringify(chunk.map),
            name: chunk.name,
            isEntry: chunk.isEntry,
            imports: chunk.imports.filter((i) =>
              bundle.output.find((c) => c.fileName === i)
            ),
            modules: Object.entries(chunk.modules)
              .map(([id, m]) => ({
                id: id.startsWith(basePath) ? id.slice(basePath.length) : id,
                renderedLength: m.renderedLength,
              }))
              .sort((a, b) => b.renderedLength - a.renderedLength),
            routeBundles: chunk.isEntry
              ? routeBundlesForEntry(chunk.name)
              : undefined,
            externalPluginImports,
          },
        ];
      })
  );

  return chunks;
}

globalThis.rollup = performRollup;