@hzab/vite-config 0.0.2-alpha.0

package/dist/index.cjs

@@ -0,0 +1,631 @@
+'use strict';
+
+var basicSsl = require('@vitejs/plugin-basic-ssl');
+var react = require('@vitejs/plugin-react');
+var vite = require('vite');
+var vitePluginHtml = require('vite-plugin-html');
+var vitePluginStaticCopy = require('vite-plugin-static-copy');
+var child_process = require('child_process');
+var fs = require('fs');
+var path = require('path');
+var babel = require('@rolldown/plugin-babel');
+var fs2 = require('fs/promises');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var basicSsl__default = /*#__PURE__*/_interopDefault(basicSsl);
+var react__default = /*#__PURE__*/_interopDefault(react);
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var path__default = /*#__PURE__*/_interopDefault(path);
+var babel__default = /*#__PURE__*/_interopDefault(babel);
+var fs2__default = /*#__PURE__*/_interopDefault(fs2);
+
+// src/create-app-vite-config.ts
+function resolveCopyPluginOptions(options) {
+  return Array.isArray(options) ? { targets: options } : options;
+}
+function copyPlugin(options) {
+  return vitePluginStaticCopy.viteStaticCopy(resolveCopyPluginOptions(options));
+}
+var HASH_BUILD_DIR_PATTERN = /^(?:[0-9a-f]{12}|local)-(\d{4}-\d{2}-\d{2}-\d{2}-\d{2}-\d{2}|\d+)$/;
+function parseHashTimestamp(value) {
+  if (/^\d+$/.test(value)) return Number(value);
+  const [year = 0, month = 1, day = 1, hour = 0, minute = 0, second = 0] = value.split("-").map(Number);
+  return new Date(year, month - 1, day, hour, minute, second).getTime();
+}
+function padTwo(value) {
+  return String(value).padStart(2, "0");
+}
+function formatHashTimestamp(now, format = "epoch") {
+  if (format !== "datetime") return String(now);
+  const date = new Date(now);
+  return [
+    date.getFullYear(),
+    padTwo(date.getMonth() + 1),
+    padTwo(date.getDate()),
+    padTwo(date.getHours()),
+    padTwo(date.getMinutes()),
+    padTwo(date.getSeconds())
+  ].join("-");
+}
+function cleanupOldHashBuilds(deployRoot, currentBuildDir, keep) {
+  const oldBuilds = fs__default.default.readdirSync(deployRoot, { withFileTypes: true }).flatMap((entry) => {
+    if (!entry.isDirectory() || entry.name === currentBuildDir) return [];
+    const match = HASH_BUILD_DIR_PATTERN.exec(entry.name);
+    return match ? [{ name: entry.name, timestamp: parseHashTimestamp(match[1]) }] : [];
+  }).sort((left, right) => right.timestamp - left.timestamp || right.name.localeCompare(left.name));
+  for (const build of oldBuilds.slice(Math.max(keep - 1, 0))) {
+    fs__default.default.rmSync(path__default.default.join(deployRoot, build.name), { recursive: true });
+  }
+}
+function hashDeployPlugin(options) {
+  const { rootDir, buildDirStr, publicPath, cleanup } = options;
+  if (cleanup && (!Number.isInteger(cleanup.keep) || cleanup.keep < 1)) {
+    throw new Error("[hash-deploy] cleanup.keep must be an integer greater than or equal to 1.");
+  }
+  let outputDir;
+  let deployRoot;
+  return {
+    name: "hash-deploy",
+    enforce: "post",
+    configResolved(config) {
+      const resolvedRoot = path__default.default.resolve(config.root);
+      const expectedRoot = path__default.default.resolve(rootDir);
+      if (resolvedRoot !== expectedRoot) {
+        throw new Error(
+          `[hash-deploy] Vite root "${resolvedRoot}" must match rootDir "${expectedRoot}".`
+        );
+      }
+      const expectedBase = publicPath.startsWith("./") ? "./" : publicPath;
+      if (config.base !== expectedBase) {
+        throw new Error(
+          `[hash-deploy] Vite base "${config.base}" must remain "${expectedBase}" during hash deployment.`
+        );
+      }
+      outputDir = path__default.default.resolve(resolvedRoot, config.build.outDir);
+      if (path__default.default.basename(outputDir) !== buildDirStr) {
+        throw new Error(
+          `[hash-deploy] build.outDir "${config.build.outDir}" must end with the hash directory "${buildDirStr}".`
+        );
+      }
+      deployRoot = path__default.default.dirname(outputDir);
+    },
+    writeBundle: {
+      sequential: true,
+      order: "post",
+      handler() {
+        if (!outputDir || !deployRoot) {
+          throw new Error("[hash-deploy] Vite configuration was not resolved before writeBundle.");
+        }
+        const sourceIndex = path__default.default.join(outputDir, "index.html");
+        if (!fs__default.default.existsSync(sourceIndex)) {
+          throw new Error(`[hash-deploy] Generated entry was not found: "${sourceIndex}".`);
+        }
+        fs__default.default.mkdirSync(deployRoot, { recursive: true });
+        fs__default.default.writeFileSync(path__default.default.join(deployRoot, "hash.txt"), buildDirStr);
+        const sourceHtml = fs__default.default.readFileSync(sourceIndex, "utf8");
+        const rootHtml = publicPath.startsWith("./") ? sourceHtml.replace(/(\b(?:href|src)\s*=\s*["'])\.\//g, `$1${publicPath}`) : sourceHtml;
+        fs__default.default.writeFileSync(path__default.default.join(deployRoot, "index.html"), rootHtml);
+        if (cleanup) {
+          cleanupOldHashBuilds(deployRoot, buildDirStr, cleanup.keep);
+        }
+      }
+    }
+  };
+}
+function getCommitHash(repositoryRoot = process.cwd()) {
+  try {
+    return child_process.execFileSync("git", ["rev-parse", "HEAD"], {
+      cwd: repositoryRoot,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim().slice(0, 12);
+  } catch {
+    return "local";
+  }
+}
+function createHashBuildDirName(repositoryRootOrNowOrOptions, now = Date.now()) {
+  if (repositoryRootOrNowOrOptions != null && typeof repositoryRootOrNowOrOptions === "object") {
+    const {
+      repositoryRoot: repositoryRoot2,
+      now: optionsNow = Date.now(),
+      timestampFormat = "epoch"
+    } = repositoryRootOrNowOrOptions;
+    return `${getCommitHash(repositoryRoot2)}-${formatHashTimestamp(optionsNow, timestampFormat)}`;
+  }
+  const repositoryRoot = typeof repositoryRootOrNowOrOptions === "string" ? repositoryRootOrNowOrOptions : void 0;
+  const timestamp = typeof repositoryRootOrNowOrOptions === "number" ? repositoryRootOrNowOrOptions : now;
+  return `${getCommitHash(repositoryRoot)}-${formatHashTimestamp(timestamp)}`;
+}
+
+// src/plugins/less-tilde.ts
+function lessTildeResolutionPlugin() {
+  return {
+    install(less, pluginManager) {
+      class TildeFileManager extends less.FileManager {
+        supports(filename) {
+          return filename.startsWith("~");
+        }
+        loadFile(filename, currentDirectory, options, environment) {
+          return super.loadFile(filename.slice(1), currentDirectory, options, environment);
+        }
+      }
+      pluginManager.addFileManager(new TildeFileManager());
+    }
+  };
+}
+function buildLessOptions(less) {
+  const resolveTilde = less?.resolveTilde === true;
+  return {
+    ...less?.additionalData != null ? { additionalData: less.additionalData } : {},
+    ...less?.modifyVars != null ? { modifyVars: less.modifyVars } : {},
+    ...less?.javascriptEnabled != null ? { javascriptEnabled: less.javascriptEnabled } : {},
+    ...resolveTilde ? { plugins: [lessTildeResolutionPlugin()] } : {}
+  };
+}
+
+// src/plugins/lifecycle.ts
+function lifecyclePlugin(options = {}) {
+  const { onRun, onDone } = options;
+  return {
+    name: "build-lifecycle",
+    enforce: "post",
+    buildStart() {
+      if (typeof onRun === "function") {
+        onRun();
+      }
+    },
+    writeBundle: {
+      sequential: true,
+      order: "post",
+      async handler() {
+        if (typeof onDone === "function") {
+          await onDone();
+        }
+      }
+    }
+  };
+}
+
+// src/plugins/public-assets.ts
+function publicAssetsPlugin(options = {}) {
+  const { dir = "public" } = options;
+  return copyPlugin({
+    targets: [
+      {
+        src: `${dir}/**/*`,
+        dest: "."
+      }
+    ]
+  });
+}
+
+// src/plugins/public-config.ts
+function publicConfigPlugin(options) {
+  const { sourceGlob, dest = "config" } = options;
+  return copyPlugin({
+    targets: [
+      {
+        src: sourceGlob,
+        dest,
+        rename: {
+          stripBase: true
+        }
+      }
+    ]
+  });
+}
+function reactCompilerPlugin(options) {
+  const { command, mode = "build-only" } = options;
+  if (mode === false) return [];
+  const isBuild = command === "build";
+  const enabled = mode === true ? true : isBuild && process.env.REACT_COMPILER !== "false";
+  if (!enabled) return [];
+  return [babel__default.default({ presets: [react.reactCompilerPreset()] })];
+}
+var SVG_EXT_RE = /\.svg$/i;
+function isSvgReactId(id) {
+  const queryStart = id.indexOf("?");
+  if (queryStart === -1) return false;
+  const file = id.slice(0, queryStart);
+  if (!SVG_EXT_RE.test(file)) return false;
+  return /(?:^|&)react(?:&|$)/.test(id.slice(queryStart + 1));
+}
+function missingPeerError(pkg, cause) {
+  const error = new Error(
+    `[svg-react] "${pkg}" is required to transform *.svg?react. Install the optional peer or disable CreateAppViteConfigOptions.svgr.`
+  );
+  error.cause = cause;
+  return error;
+}
+async function resolveSvgrConfig(options) {
+  const merged = { svgo: true, ...options };
+  if (merged.plugins != null) return merged;
+  const plugins = [];
+  if (merged.svgo !== false) {
+    try {
+      plugins.push((await import('@svgr/plugin-svgo')).default);
+    } catch (cause) {
+      throw missingPeerError("@svgr/plugin-svgo", cause);
+    }
+  }
+  try {
+    plugins.push((await import('@svgr/plugin-jsx')).default);
+  } catch (cause) {
+    throw missingPeerError("@svgr/plugin-jsx", cause);
+  }
+  return { ...merged, plugins };
+}
+function svgReactPlugin(options = {}) {
+  return {
+    name: "ccc:svg-react",
+    enforce: "pre",
+    async load(id) {
+      if (!isSvgReactId(id)) return;
+      const filePath = id.slice(0, id.indexOf("?"));
+      const svg = await fs2__default.default.readFile(filePath, "utf8");
+      let transform;
+      try {
+        ({ transform } = await import('@svgr/core'));
+      } catch (cause) {
+        throw missingPeerError("@svgr/core", cause);
+      }
+      const componentCode = await transform(svg, await resolveSvgrConfig(options), { filePath });
+      const result = await vite.transformWithOxc(componentCode, `${filePath}.jsx`, {
+        lang: "jsx"
+      });
+      return { code: result.code, map: result.map };
+    }
+  };
+}
+
+// src/create-app-vite-config.ts
+var JS_PUBLIC_PATH_DEFINE_KEY = "import.meta.env.PUBLIC_PATH";
+function normalizeAssetBase(base) {
+  if (base == null) return void 0;
+  const trimmed = base.trim();
+  if (!trimmed) return void 0;
+  return trimmed.endsWith("/") ? trimmed : `${trimmed}/`;
+}
+function ensureTrailingSlash(value) {
+  return value.endsWith("/") ? value : `${value}/`;
+}
+function resolveJsPublicPath(isHash, publicPath, config) {
+  if (isHash) return publicPath;
+  if (typeof config.base === "string" && config.base.length > 0) {
+    return ensureTrailingSlash(config.base);
+  }
+  return publicPath || "/";
+}
+function applyJsPublicPathDefine(config, publicPath) {
+  config.define = {
+    ...config.define,
+    [JS_PUBLIC_PATH_DEFINE_KEY]: JSON.stringify(publicPath)
+  };
+  return config;
+}
+function createAppViteConfig(options) {
+  const {
+    rootDir,
+    repositoryRoot,
+    command,
+    mode,
+    alias,
+    useHttps = false,
+    openBrowser = true,
+    hashDeploy = false,
+    hashTimestamp = "epoch",
+    base: baseOption,
+    deployRoot: deployRootOption = "dist",
+    hashCleanup,
+    publicAssets,
+    publicConfig,
+    copy: copyOption,
+    htmlData,
+    devProxy,
+    reactCompiler = "build-only",
+    react: enableReact = true,
+    svgr: svgrOption = false,
+    less,
+    onRun,
+    onDone,
+    plugins: extraPlugins = [],
+    vite: viteOverride,
+    configure
+  } = options;
+  const isDev = command === "serve";
+  const isBuild = command === "build";
+  const isHash = isBuild && Boolean(hashDeploy) && mode !== "development";
+  const deployRoot = deployRootOption.replace(/\/+$/, "") || "dist";
+  const assetBase = normalizeAssetBase(baseOption);
+  const buildDirStr = isHash ? createHashBuildDirName({
+    repositoryRoot: repositoryRoot ?? rootDir,
+    timestampFormat: hashTimestamp
+  }) : "";
+  const publicPath = isHash ? `${assetBase ?? "./"}${buildDirStr}/` : isBuild ? assetBase ?? "./" : "";
+  const htmlPublicPath = isHash && publicPath.startsWith("./") ? "./" : publicPath;
+  const isAbsoluteAssetBase = assetBase != null && (assetBase.startsWith("https://") || assetBase.startsWith("http://") || assetBase.startsWith("/"));
+  const viteBase = isHash ? isAbsoluteAssetBase ? publicPath : "./" : isBuild ? publicPath : void 0;
+  const enablePublicAssets = publicAssets !== false;
+  const plugins = [
+    ...enablePublicAssets ? [publicAssetsPlugin(publicAssets && typeof publicAssets === "object" ? publicAssets : {})] : [],
+    ...svgrOption ? [svgReactPlugin(svgrOption === true ? {} : svgrOption)] : [],
+    ...enableReact ? [react__default.default()] : [],
+    ...reactCompilerPlugin({ command, mode: reactCompiler }),
+    ...publicConfig === false || publicConfig == null ? [] : [
+      publicConfigPlugin({
+        sourceGlob: publicConfig.sourceGlob ?? `config/public-config/${publicConfig.mode}/*`,
+        dest: publicConfig.dest
+      })
+    ],
+    ...copyOption ? [copyPlugin(copyOption)] : [],
+    vitePluginHtml.createHtmlPlugin({
+      minify: isBuild,
+      inject: {
+        data: {
+          ...htmlData,
+          PUBLIC_PATH: htmlPublicPath || ""
+        }
+      }
+    }),
+    ...isBuild && isHash ? [
+      hashDeployPlugin({
+        rootDir,
+        buildDirStr,
+        publicPath,
+        cleanup: hashCleanup
+      })
+    ] : [],
+    ...isDev && useHttps ? [basicSsl__default.default()] : [],
+    ...extraPlugins,
+    ...isBuild && (onRun || onDone) ? [lifecyclePlugin({ onRun, onDone })] : []
+  ];
+  const base = {
+    root: rootDir,
+    ...viteBase != null ? { base: viteBase } : {},
+    plugins,
+    ...enablePublicAssets ? { publicDir: false } : {},
+    resolve: {
+      alias
+    },
+    css: {
+      preprocessorOptions: {
+        less: buildLessOptions(less)
+      }
+    },
+    ...isDev ? {
+      server: {
+        https: useHttps ? {} : void 0,
+        host: true,
+        open: openBrowser,
+        ...devProxy ? { proxy: devProxy } : {}
+      }
+    } : {
+      build: {
+        outDir: isHash ? `${deployRoot}/${buildDirStr}/` : deployRoot,
+        assetsDir: "assets",
+        emptyOutDir: true
+      }
+    }
+  };
+  let merged = viteOverride ? vite.mergeConfig(base, viteOverride) : base;
+  if (configure) {
+    merged = configure(merged);
+  }
+  applyJsPublicPathDefine(merged, resolveJsPublicPath(isHash, publicPath, merged));
+  Object.defineProperty(merged, "buildDirHash", {
+    value: buildDirStr,
+    enumerable: false,
+    configurable: true
+  });
+  return merged;
+}
+
+// src/create-vite-config.ts
+function createViteConfig(options = {}) {
+  return createAppViteConfig({
+    rootDir: options.rootDir ?? process.cwd(),
+    command: options.command ?? "serve",
+    mode: options.mode ?? "development",
+    openBrowser: options.openBrowser ?? false,
+    reactCompiler: false,
+    ...options
+  });
+}
+var DEFAULT_LIBRARY_EXTERNALS = ["react", "react-dom"];
+var DEFAULT_LIBRARY_GLOBALS = {
+  react: "React",
+  "react-dom": "ReactDOM"
+};
+var DEFAULT_LIBRARY_FORMATS = ["umd"];
+function needsLibraryName(formats) {
+  return formats.includes("umd") || formats.includes("iife");
+}
+function resolveExternals(externals) {
+  if (externals === false) return [];
+  if (externals == null) return [...DEFAULT_LIBRARY_EXTERNALS];
+  return externals;
+}
+function resolveLibraryFileName(fileName, formats) {
+  if (fileName != null) return fileName;
+  if (formats.length === 1) {
+    return () => "index.js";
+  }
+  return (format) => format === "es" ? "index.js" : `index.${format}.js`;
+}
+function resolveLibraryGlobals(externals, globals) {
+  const inferred = {};
+  for (const ext of externals) {
+    if (typeof ext !== "string") continue;
+    inferred[ext] = DEFAULT_LIBRARY_GLOBALS[ext] ?? ext;
+  }
+  return { ...inferred, ...globals };
+}
+function matchLibraryExternal(id, externals) {
+  const source = id.split("?")[0] ?? id;
+  return externals.some((ext) => {
+    if (typeof ext === "string") {
+      return source === ext || source.startsWith(`${ext}/`);
+    }
+    return ext.test(source);
+  });
+}
+function resolveLibraryGlobalName(id, globals) {
+  const source = id.split("?")[0] ?? id;
+  if (globals[source]) return globals[source];
+  const matched = Object.keys(globals).find(
+    (key) => source === key || source.startsWith(`${key}/`)
+  );
+  return matched ? globals[matched] ?? source : source;
+}
+function createLibraryViteConfig(options) {
+  const {
+    rootDir,
+    command,
+    alias,
+    entry = "src/index.ts",
+    name,
+    outDir = "lib",
+    fileName,
+    cssFileName = "index",
+    formats = DEFAULT_LIBRARY_FORMATS,
+    externals: externalsOption,
+    globals: globalsOption,
+    useHttps = false,
+    openBrowser = true,
+    devProxy,
+    reactCompiler = "build-only",
+    react: enableReact = true,
+    svgr: svgrOption = false,
+    less,
+    previewHtml,
+    onRun,
+    onDone,
+    plugins: extraPlugins = [],
+    vite: viteOverride,
+    configure
+  } = options;
+  const isDev = command === "serve";
+  const isBuild = command === "build";
+  if (isBuild && needsLibraryName(formats) && (name == null || name.trim() === "")) {
+    throw new Error(
+      '[vite-config] createLibraryViteConfig: `name` is required when formats include "umd" or "iife".'
+    );
+  }
+  const plugins = [
+    ...svgrOption ? [svgReactPlugin(svgrOption === true ? {} : svgrOption)] : [],
+    ...enableReact ? [react__default.default()] : [],
+    ...reactCompilerPlugin({ command, mode: reactCompiler }),
+    ...isDev && previewHtml ? [
+      vitePluginHtml.createHtmlPlugin({
+        minify: false,
+        template: path__default.default.resolve(rootDir, previewHtml)
+      })
+    ] : [],
+    ...isDev && useHttps ? [basicSsl__default.default()] : [],
+    ...extraPlugins,
+    ...isBuild && (onRun || onDone) ? [lifecyclePlugin({ onRun, onDone })] : []
+  ];
+  const resolvedExternals = resolveExternals(externalsOption);
+  const resolvedGlobals = resolveLibraryGlobals(resolvedExternals, globalsOption);
+  const base = {
+    root: rootDir,
+    publicDir: false,
+    plugins,
+    resolve: {
+      alias
+    },
+    css: {
+      preprocessorOptions: {
+        less: buildLessOptions(less)
+      }
+    },
+    ...isDev ? {
+      server: {
+        https: useHttps ? {} : void 0,
+        host: true,
+        open: openBrowser,
+        ...devProxy ? { proxy: devProxy } : {}
+      }
+    } : {
+      build: {
+        outDir,
+        emptyOutDir: true,
+        lib: {
+          entry: path__default.default.resolve(rootDir, entry),
+          ...name != null && name.trim() !== "" ? { name } : {},
+          formats,
+          fileName: resolveLibraryFileName(fileName, formats),
+          cssFileName
+        },
+        rolldownOptions: {
+          external: (id) => matchLibraryExternal(id, resolvedExternals),
+          output: {
+            globals: (id) => resolveLibraryGlobalName(id, resolvedGlobals)
+          }
+        }
+      }
+    }
+  };
+  let merged = viteOverride ? vite.mergeConfig(base, viteOverride) : base;
+  if (configure) {
+    merged = configure(merged);
+  }
+  return merged;
+}
+
+// src/plugins/relative-base.ts
+function relativeBasePlugin(deployPath = "./") {
+  return {
+    name: "relative-base",
+    transformIndexHtml(html) {
+      return html.replace(/href="\.?\/assets\//g, `href="${deployPath}assets/`).replace(/src="\.?\/assets\//g, `src="${deployPath}assets/`);
+    },
+    transform(code, id) {
+      if (id.includes("node_modules")) return null;
+      return code.replace(/import\.meta\.env\.BASE_URL/g, `'${deployPath}'`);
+    }
+  };
+}
+
+// src/plugins/stub-less.ts
+var cssModuleStub = `
+const styles = new Proxy({}, {
+  get: (_target, property) => typeof property === "string" ? property : undefined,
+});
+export default styles;
+`;
+function stubLessPlugin() {
+  return {
+    name: "stub-less",
+    load(id) {
+      if (/\.module\.less(?:$|\?)/.test(id)) {
+        return cssModuleStub;
+      }
+      if (/\.less(?:$|\?)/.test(id)) {
+        return "";
+      }
+    }
+  };
+}
+
+exports.DEFAULT_LIBRARY_EXTERNALS = DEFAULT_LIBRARY_EXTERNALS;
+exports.DEFAULT_LIBRARY_GLOBALS = DEFAULT_LIBRARY_GLOBALS;
+exports.buildLessOptions = buildLessOptions;
+exports.copyPlugin = copyPlugin;
+exports.createAppViteConfig = createAppViteConfig;
+exports.createHashBuildDirName = createHashBuildDirName;
+exports.createLibraryViteConfig = createLibraryViteConfig;
+exports.createViteConfig = createViteConfig;
+exports.getCommitHash = getCommitHash;
+exports.hashDeployPlugin = hashDeployPlugin;
+exports.lessTildeResolutionPlugin = lessTildeResolutionPlugin;
+exports.lifecyclePlugin = lifecyclePlugin;
+exports.publicAssetsPlugin = publicAssetsPlugin;
+exports.publicConfigPlugin = publicConfigPlugin;
+exports.reactCompilerPlugin = reactCompilerPlugin;
+exports.relativeBasePlugin = relativeBasePlugin;
+exports.stubLessPlugin = stubLessPlugin;
+exports.svgReactPlugin = svgReactPlugin;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map