vite-plugin-builder/dist/index.cjs

A Vite plugin that creates a dual compilation setup for SSR (Server-Side Rendering) and CSR (Client-Side Rendering) to build both server and client entry points in one project.

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var index_exports = {};
__export(index_exports, {
  builder: () => builder,
  default: () => index_default,
  pluginBuilder: () => pluginBuilder
});
module.exports = __toCommonJS(index_exports);

// src/utils.ts
var import_deepmerge = __toESM(require("deepmerge"), 1);
function assertBuilderConfig(opts) {
  const base = {
    mode: "server-first",
    serverEntry: "server.js",
    serverConfig: {
      external: [],
      noExternal: [],
      output: {
        format: "es",
        entryFileNames: "app.js",
        chunkFileNames: "bin/[name]-[hash].js",
        assetFileNames: "assets/[name]-[hash].[ext]"
      },
      minify: false,
      target: "esnext",
      outDir: "dist",
      emptyOutDir: true,
      privateDir: "private",
      define: {}
    },
    serverBuild: (config) => config,
    serverPlugins: [],
    clientEntry: {
      main: "index.html"
    },
    clientConfig: {
      external: () => false,
      output: {
        entryFileNames: "assets/[name]-[hash].js",
        chunkFileNames: "chunks/[name]-[hash].js",
        assetFileNames: "assets/[name]-[hash].[ext]"
      },
      minify: true,
      target: "modules",
      outDir: "dist/public",
      emptyOutDir: true,
      publicDir: "public",
      define: {}
    },
    clientBuild: (config) => config,
    clientPlugins: []
  };
  return (0, import_deepmerge.default)(base, opts);
}
var ENTRY_NONE = "____.html";

// src/index.ts
var import_vite = require("vite");
var doBuildServer = async (buildConfig) => {
  const {
    serverEntry,
    serverBuild,
    serverConfig: {
      privateDir,
      define,
      outDir,
      minify,
      emptyOutDir,
      target,
      external,
      noExternal,
      output
    },
    serverPlugins
  } = buildConfig;
  const viteServer = await serverBuild({
    publicDir: privateDir,
    define,
    ssr: {
      external,
      noExternal
    },
    build: {
      outDir,
      ssr: serverEntry,
      write: true,
      minify,
      target,
      emptyOutDir,
      rollupOptions: {
        output
      }
    },
    plugins: serverPlugins
  });
  await (0, import_vite.build)(viteServer);
};
var doBuildClient = async (buildConfig) => {
  const {
    clientEntry,
    clientBuild,
    clientConfig: {
      publicDir,
      define,
      outDir,
      minify,
      emptyOutDir,
      target,
      external,
      output
    },
    clientPlugins
  } = buildConfig;
  const viteClient = await clientBuild({
    define,
    publicDir,
    build: {
      outDir,
      write: true,
      minify,
      emptyOutDir,
      target,
      rollupOptions: {
        input: clientEntry,
        external,
        output
      }
    },
    plugins: clientPlugins
  });
  await (0, import_vite.build)(viteClient);
};
var builder = (opts) => {
  const buildConfig = assertBuilderConfig(opts);
  const isSkip = buildConfig.mode === "skip";
  return [
    {
      name: "vite-plugin-builder:skip",
      enforce: "pre",
      apply: "build",
      config: () => {
        if (process.env.IS_BUILDER || isSkip) return {};
        return {
          build: {
            copyPublicDir: false,
            write: false,
            rollupOptions: {
              input: {
                main: ENTRY_NONE
              }
            }
          }
        };
      },
      resolveId: (id) => {
        if (id === ENTRY_NONE) {
          return id;
        }
        return null;
      },
      load: (id) => {
        if (id === ENTRY_NONE) {
          return "";
        }
        return null;
      }
    },
    {
      name: "vite-plugin-builder",
      enforce: "pre",
      apply: "build",
      buildStart: async () => {
        if (isSkip || process.env.IS_BUILDER) return;
        process.env.IS_BUILDER = "true";
        const { mode } = buildConfig;
        if (mode === "server-first") {
          await doBuildServer(buildConfig);
          await doBuildClient(buildConfig);
        } else if (mode === "client-first") {
          await doBuildClient(buildConfig);
          await doBuildServer(buildConfig);
        } else if (mode === "parallel") {
          await Promise.all([
            doBuildServer(buildConfig),
            doBuildClient(buildConfig)
          ]);
        }
      }
    }
  ];
};
var pluginBuilder = builder;
var index_default = builder;
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  builder,
  pluginBuilder
});