init-loaders.js

// This script was created to initialize and create the loaders for the Plone registry.
// Nowadays it is not used in the build process, but it's still needed for initialize
// the unit tests before they run.
// It was used when React Router was evaluating `routes.ts` before running vite build.
// See https://github.com/remix-run/react-router/issues/13078#issuecomment-2863445977
import fs from 'fs';
import path from 'path';
import cryptoRandomString from 'crypto-random-string';
import { createServer } from 'vite';
import { pathToFileURL } from 'node:url';
import { AddonRegistry } from '@plone/registry/addon-registry';
import { createAddonsLoader } from '@plone/registry/create-addons-loader';
import { createAddonsServerLoader } from '@plone/registry/create-addons-loader-server';
import { createAddonsStyleLoader } from '@plone/registry/create-addons-styles-loader';
import { createAddonsLocalesLoader } from '@plone/registry/create-addons-locales-loader';
import { PloneRegistryVitePlugin } from '@plone/registry/vite-plugin';
import config from '@plone/registry';
import { buildSlotTree } from './slot-tree.js';

const titleCase = (w) => w.slice(0, 1).toUpperCase() + w.slice(1, w.length);

function nameFromPath(filePath) {
  const normalizedPath =
    filePath.replace(/[@~./\\:\s-]/gi, '') ||
    cryptoRandomString({ length: 10, characters: 'abcdefghijk' });

  return normalizedPath
    .split('-')
    .map((w, i) => (i > 0 ? titleCase(w) : w))
    .join('');
}

function getAddonViteExtenders(registry) {
  return registry
    .getAddons()
    .map((addon) => {
      const base = path.dirname(addon.packageJson);
      const viteExtendJs = path.resolve(`${base}/vite.extend.js`);
      const viteExtendTs = path.resolve(`${base}/vite.extend.ts`);

      if (fs.existsSync(viteExtendJs)) return viteExtendJs;
      if (fs.existsSync(viteExtendTs)) return viteExtendTs;
      return null;
    })
    .filter(Boolean);
}

function createViteLoader(extenders) {
  const viteLoaderPath = path.join(process.cwd(), '.plone', 'vite.loader.js');

  let code = `/*
Don't change this file manually.
It is autogenerated by @plone/registry.
Instead, change the "addons" registration in the app.
*/\n`;

  const extendersToLoad = [];

  extenders.forEach((extenderPath) => {
    const defaultImport = nameFromPath(extenderPath);
    const fileUrl = pathToFileURL(extenderPath).href;
    code += `import ${defaultImport} from '${fileUrl}';\n`;
    extendersToLoad.push(defaultImport);
  });

  code += `
const safeWrapper = (func) => (config, context) => {
  const res = func(config, context);
  if (typeof res === 'undefined') {
    throw new Error("Vite extension function doesn't return config");
  }
  return res;
};

const load = (config, context = {}) => {
  const addonLoaders = [${extendersToLoad.join(', ')}];
  if (!addonLoaders.every((el) => typeof el === 'function')) {
    throw new TypeError(
      'Each addon has to provide a function applying its Vite extension to the app configuration.',
    );
  }
  return addonLoaders.reduce(
    (acc, apply) => safeWrapper(apply)(acc, context),
    config,
  );
};
export default load;
`;

  fs.writeFileSync(viteLoaderPath, code);
  return viteLoaderPath;
}

async function evaluateAddons(addonsLoaderPath) {
  const projectRootPath = path.resolve('.');

  const ploneDir = path.join(projectRootPath, '.plone');

  const server = await createServer({
    root: projectRootPath,
    configFile: false,
    server: { middlewareMode: true },
    plugins: [PloneRegistryVitePlugin()],
  });

  try {
    const { default: loader, addonsInfo } =
      await server.ssrLoadModule(addonsLoaderPath);

    const populatedConfig = loader(config);

    fs.writeFileSync(
      path.join(ploneDir, 'registry.routes.json'),
      JSON.stringify(populatedConfig.routes, null, 2),
    );
    fs.writeFileSync(
      path.join(ploneDir, 'registry.addonsInfo.json'),
      JSON.stringify(addonsInfo, null, 2),
    );
    await buildSlotTree(populatedConfig, ploneDir, server);
  } finally {
    await server.close();
  }
}

async function initPloneRegistryLoaders() {
  const projectRootPath = path.resolve('.');
  const { registry, shadowAliases } = AddonRegistry.init(projectRootPath);

  const ploneDir = path.join(projectRootPath, '.plone');
  if (!fs.existsSync(ploneDir)) {
    fs.mkdirSync(ploneDir, { recursive: true });
  }

  const addonsLoaderPath = createAddonsLoader(
    registry.getAddonDependencies(),
    registry.getAddons(),
    { tempInProject: true },
  );

  await evaluateAddons(addonsLoaderPath);

  createAddonsServerLoader(
    registry.getAddonDependencies(),
    registry.getAddons(),
  );
  createViteLoader(getAddonViteExtenders(registry));
  createAddonsStyleLoader(registry);
  createAddonsLocalesLoader(registry);

  return { registry, shadowAliases, addonsLoaderPath };
}

initPloneRegistryLoaders();