buner 1.0.4 → 1.0.6

package/{bin → dist}/buner.js

@@ -13,15 +13,15 @@ import { globby } from "globby";
 import { exec } from "node:child_process";
 import validateProjectName from "validate-npm-package-name";
 const name = "buner";
-const version = "1.0.4";
+const version = "1.0.6";
 const description = "Frontend build toolkit for Vite + React SSR projects — SCSS pipeline, prerender, SSR dev server, and backend integration.";
 const type = "module";
 const license = "MIT";
 const repository = { "type": "git", "url": "https://github.com/precise-alloy/buner.git" };
 const homepage = "https://www.npmjs.com/package/buner";
 const keywords = ["vite", "react", "ssr", "scss", "prerender", "frontend", "build-tool", "cli"];
-const bin = { "buner": "./bin/buner.js" };
-const files = ["bin", "cli", "xpack", "public", "server.ts", "prerender.ts", "integration.ts", "styles.ts", "scripts.ts", "states.ts", "migrate-scss.ts", "vite.config.ts", "index.html", "tsconfig.json", "eslint.config.mjs", "types.d.ts", ".env", ".env.development", ".env.eshn", "README.md"];
+const bin$1 = { "buner": "./dist/buner.js" };
+const files = ["dist", "xpack", "public", "vite.config.ts", "index.html", "tsconfig.json", "eslint.config.mjs", "types.d.ts", ".env", ".env.development", ".env.eshn", "README.md"];
 const scripts = { "start": "bun run dev", "predev": "bun upgrade", "dev": 'concurrently --kill-others "bun styles.ts --watch" "bun states.ts --watch" "cross-env scriptOnly=true vite build --mode development --watch" "bun server.ts --mode development"', "serve": "bun server.ts", "watch": "bun server.ts", "build": "bun run build:static && bun run build:server", "build:eshn": "bun run build:static:eshn && bun run build:server:eshn", "preview": "vite preview", "build:server": "vite build --ssr src/entry-server.tsx --outDir dist/server", "build:server:eshn": "vite build --ssr src/entry-server.tsx --outDir dist/server --mode eshn", "build:static": "vite build --outDir dist/static", "build:static:eshn": "vite build --outDir dist/static --mode eshn", "generate": "bun states.ts && bun run styles && bun run build && bun prerender.ts --add-hash", "eshn": "bun states.ts && bun run styles && bun run build:eshn && bun prerender.ts --add-hash --mode eshn", "inte": "bun run styles && bun run build && bun prerender.ts && bun integration.ts", "styles": "bun styles.ts", "format": "prettier --write .", "lint": "eslint --fix", "cli:start": "vite build -c vite.cli.config.ts --watch", "cli:build": "vite build -c vite.cli.config.ts" };
 const engines = { "node": ">=20.0.0" };
 const dependencies = { "@vitejs/plugin-react": "^5.1.4", "autoprefixer": "^10.4.27", "chalk": "^5.5.0", "cheerio": "^1.2.0", "chokidar": "^4.0.3", "commander": "^14.0.3", "concurrently": "^9.2.0", "cross-env": "^10.1.0", "cssnano": "^7.1.0", "debounce": "^3.0.0", "express": "^5.2.1", "glob": "^13.0.6", "globby": "^16.1.1", "js-beautify": "^1.15.4", "lodash": "^4.17.21", "magic-string": "^0.30.17", "node-fetch": "^3.3.2", "postcss": "^8.5.8", "prompts": "^2.4.2", "sass": "^1.89.2", "slash": "^5.1.0", "validate-npm-package-name": "^7.0.0", "vite": "^7.0.6" };
@@ -37,7 +37,7 @@ const packageJson = {
   repository,
   homepage,
   keywords,
-  bin,
+  bin: bin$1,
   files,
   scripts,
   engines,
@@ -430,8 +430,23 @@ function validateNpmName(name2) {
 }
 const { green, yellow, bold, cyan, red } = chalk;
 const packageName = "buner";
-const packageDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const packageDir = path.dirname(fileURLToPath(import.meta.url));
 const pkg = (file) => path.join(packageDir, file);
+const bin = (name2) => {
+  const ext = process.platform === "win32" ? ".cmd" : "";
+  const pkgRoot = path.resolve(packageDir, "..");
+  const local = path.join(pkgRoot, "node_modules", ".bin", name2 + ext);
+  try {
+    if (require("fs").existsSync(local)) return local;
+  } catch {
+  }
+  const consumerBin = path.join(process.cwd(), "node_modules", ".bin", name2 + ext);
+  try {
+    if (require("fs").existsSync(consumerBin)) return consumerBin;
+  } catch {
+  }
+  return name2;
+};
 const run = (cmd, args = [], options = {}) => {
   return new Promise((resolve, reject) => {
     const child = spawn(cmd, args, {
@@ -515,58 +530,62 @@ For example:
   await notifyUpdate();
 });
 program.command("dev").description("Start development mode with all watchers").action(async () => {
-  await run("npx", [
-    "concurrently",
+  const viteConfig = path.resolve(packageDir, "..", "vite.config.ts");
+  await run(bin("concurrently"), [
     "--kill-others",
-    `"bun ${pkg("styles.ts")} --watch"`,
-    `"bun ${pkg("states.ts")} --watch"`,
-    `"cross-env scriptOnly=true npx vite build --config ${pkg("vite.config.ts")} --mode development --watch"`,
-    `"bun ${pkg("server.ts")} --mode development"`
+    `"node ${pkg("styles.js")} --watch"`,
+    `"node ${pkg("states.js")} --watch"`,
+    `"${bin("cross-env")} scriptOnly=true ${bin("vite")} build --config ${viteConfig} --mode development --watch"`,
+    `"node ${pkg("server.js")} --mode development"`
   ]);
 });
 program.command("serve").description("Start the SSR dev server").option("--mode <mode>", "server mode", "development").action(async (opts) => {
-  await run("bun", [pkg("server.ts"), "--mode", opts.mode]);
+  await run("node", [pkg("server.js"), "--mode", opts.mode]);
 });
 program.command("build").description("Build the project (static + SSR)").action(async () => {
-  runSync(`npx vite build --config ${pkg("vite.config.ts")} --outDir dist/static`);
-  runSync(`npx vite build --config ${pkg("vite.config.ts")} --ssr src/entry-server.tsx --outDir dist/server`);
+  const viteConfig = path.resolve(packageDir, "..", "vite.config.ts");
+  runSync(`${bin("vite")} build --config ${viteConfig} --outDir dist/static`);
+  runSync(`${bin("vite")} build --config ${viteConfig} --ssr src/entry-server.tsx --outDir dist/server`);
 });
 program.command("generate").description("Full static site generation (states + styles + build + prerender)").option("--mode <mode>", "build mode", "production").action(async (opts) => {
-  runSync(`bun ${pkg("states.ts")}`);
-  runSync(`bun ${pkg("styles.ts")}`);
+  const viteConfig = path.resolve(packageDir, "..", "vite.config.ts");
+  runSync(`node ${pkg("states.js")}`);
+  runSync(`node ${pkg("styles.js")}`);
   if (opts.mode === "production") {
-    runSync(`npx vite build --config ${pkg("vite.config.ts")} --outDir dist/static`);
-    runSync(`npx vite build --config ${pkg("vite.config.ts")} --ssr src/entry-server.tsx --outDir dist/server`);
+    runSync(`${bin("vite")} build --config ${viteConfig} --outDir dist/static`);
+    runSync(`${bin("vite")} build --config ${viteConfig} --ssr src/entry-server.tsx --outDir dist/server`);
   } else {
-    runSync(`npx vite build --config ${pkg("vite.config.ts")} --outDir dist/static --mode ${opts.mode}`);
-    runSync(`npx vite build --config ${pkg("vite.config.ts")} --ssr src/entry-server.tsx --outDir dist/server --mode ${opts.mode}`);
+    runSync(`${bin("vite")} build --config ${viteConfig} --outDir dist/static --mode ${opts.mode}`);
+    runSync(`${bin("vite")} build --config ${viteConfig} --ssr src/entry-server.tsx --outDir dist/server --mode ${opts.mode}`);
   }
-  runSync(`bun ${pkg("prerender.ts")} --add-hash --mode ${opts.mode}`);
+  runSync(`node ${pkg("prerender.js")} --add-hash --mode ${opts.mode}`);
 });
 program.command("eshn").description("Generate with --mode eshn").action(async () => {
-  runSync(`bun ${pkg("states.ts")}`);
-  runSync(`bun ${pkg("styles.ts")}`);
-  runSync(`npx vite build --config ${pkg("vite.config.ts")} --outDir dist/static --mode eshn`);
-  runSync(`npx vite build --config ${pkg("vite.config.ts")} --ssr src/entry-server.tsx --outDir dist/server --mode eshn`);
-  runSync(`bun ${pkg("prerender.ts")} --add-hash --mode eshn`);
+  const viteConfig = path.resolve(packageDir, "..", "vite.config.ts");
+  runSync(`node ${pkg("states.js")}`);
+  runSync(`node ${pkg("styles.js")}`);
+  runSync(`${bin("vite")} build --config ${viteConfig} --outDir dist/static --mode eshn`);
+  runSync(`${bin("vite")} build --config ${viteConfig} --ssr src/entry-server.tsx --outDir dist/server --mode eshn`);
+  runSync(`node ${pkg("prerender.js")} --add-hash --mode eshn`);
 });
 program.command("inte").description("Build and integrate with backend (styles + build + prerender + integration)").action(async () => {
-  runSync(`bun ${pkg("styles.ts")}`);
-  runSync(`npx vite build --config ${pkg("vite.config.ts")} --outDir dist/static`);
-  runSync(`npx vite build --config ${pkg("vite.config.ts")} --ssr src/entry-server.tsx --outDir dist/server`);
-  runSync(`bun ${pkg("prerender.ts")}`);
-  runSync(`bun ${pkg("integration.ts")}`);
+  const viteConfig = path.resolve(packageDir, "..", "vite.config.ts");
+  runSync(`node ${pkg("styles.js")}`);
+  runSync(`${bin("vite")} build --config ${viteConfig} --outDir dist/static`);
+  runSync(`${bin("vite")} build --config ${viteConfig} --ssr src/entry-server.tsx --outDir dist/server`);
+  runSync(`node ${pkg("prerender.js")}`);
+  runSync(`node ${pkg("integration.js")}`);
 });
 program.command("styles").description("Compile SCSS").option("--watch", "Watch for changes").action(async (opts) => {
-  const args = [pkg("styles.ts")];
+  const args = [pkg("styles.js")];
   if (opts.watch) args.push("--watch");
-  await run("bun", args);
+  await run("node", args);
 });
 program.command("prerender").description("Pre-render HTML files").option("--add-hash", "Add content hashes to asset URLs").option("--mode <mode>", "build mode", "production").action(async (opts) => {
-  const args = [pkg("prerender.ts")];
+  const args = [pkg("prerender.js")];
   if (opts.addHash) args.push("--add-hash");
   args.push("--mode", opts.mode);
-  await run("bun", args);
+  await run("node", args);
 });
 program.parseAsync(process.argv).catch(async (error) => {
   console.log(red(error));

package/{integration.ts → dist/integration.js}

@@ -1,179 +1,130 @@
-/* eslint-disable no-console */
-import fs from 'fs';
-import path, { resolve } from 'path';
-import crypto from 'node:crypto';
-import nodeFs from 'node:fs';
-
-import slash from 'slash';
-import { glob } from 'glob';
-import { loadEnv } from 'vite';
-import chalk from 'chalk';
-
-interface CopyItem {
-  from: string;
-  to?: string;
-}
-
-interface FileExistCheck {
-  folder?: string;
-  fileName: string | RegExp;
-}
-
-const argvModeIndex = process.argv.indexOf('--mode');
-const mode =
-  argvModeIndex >= 0 && argvModeIndex < process.argv.length - 1 && !process.argv[argvModeIndex + 1].startsWith('-')
-    ? process.argv[argvModeIndex + 1]
-    : 'production';
+import fs from "fs";
+import path, { resolve } from "path";
+import crypto from "node:crypto";
+import fs$1 from "node:fs";
+import slash from "slash";
+import { glob } from "glob";
+import { loadEnv } from "vite";
+import chalk from "chalk";
+const argvModeIndex = process.argv.indexOf("--mode");
+const mode = argvModeIndex >= 0 && argvModeIndex < process.argv.length - 1 && !process.argv[argvModeIndex + 1].startsWith("-") ? process.argv[argvModeIndex + 1] : "production";
 const projectRoot = process.cwd();
 const xpackEnv = loadEnv(mode, projectRoot);
-const toAbsolute = (p: string) => slash(path.resolve(projectRoot, p));
+const toAbsolute = (p) => slash(path.resolve(projectRoot, p));
 const log = console.log.bind(console);
-
-const hashes: Map<string, string> = new Map();
-const staticBasePath = toAbsolute('dist/static');
-const srcBasePath = toAbsolute('dist/static/assets');
+const hashes = /* @__PURE__ */ new Map();
+const staticBasePath = toAbsolute("dist/static");
+const srcBasePath = toAbsolute("dist/static/assets");
 const destBasePath = toAbsolute(xpackEnv.VITE_INTE_ASSET_DIR);
-const patternPath = xpackEnv.VITE_INTE_PATTERN_DIR ? toAbsolute(xpackEnv.VITE_INTE_PATTERN_DIR) : undefined;
-
+const patternPath = xpackEnv.VITE_INTE_PATTERN_DIR ? toAbsolute(xpackEnv.VITE_INTE_PATTERN_DIR) : void 0;
 if (patternPath && fs.existsSync(patternPath)) {
   fs.rmSync(patternPath, { recursive: true, force: true });
-
   fs.mkdirSync(patternPath, { recursive: true });
 }
-
-const copyItems: CopyItem[] = [
-  { from: 'css' },
-  { from: 'fonts' },
-  { from: 'images' },
-  { from: 'js' },
-  { from: 'vendors' },
-  { from: 'hashes.json' },
-  { from: 'pages', to: patternPath },
+const copyItems = [
+  { from: "css" },
+  { from: "fonts" },
+  { from: "images" },
+  { from: "js" },
+  { from: "vendors" },
+  { from: "hashes.json" },
+  { from: "pages", to: patternPath }
 ];
-const hashItems: string[] = ['css', 'images', 'js'];
-
+const hashItems = ["css", "images", "js"];
 copyItems.forEach((item) => {
   const srcPath = slash(path.join(srcBasePath, item.from));
   const destPath = slash(item.to ?? path.join(destBasePath, item.from));
-
   if (!fs.existsSync(srcPath)) {
     return;
   }
-
   log(`Copy file ${srcPath} to ${destPath}`);
-
   if (fs.statSync(srcPath).isDirectory()) {
     if (fs.existsSync(destPath)) {
       fs.rmSync(destPath, { recursive: true, force: true });
     }
-
     fs.mkdirSync(destPath, { recursive: true });
-
     fs.cpSync(srcPath, destPath, { recursive: true, force: true });
   } else {
     const destDirPath = path.dirname(destPath);
-
     if (!fs.existsSync(destDirPath)) {
       fs.mkdirSync(destDirPath);
     }
-
     fs.copyFileSync(srcPath, destPath);
   }
 });
-
 hashItems.forEach((item) => {
   const srcPath = slash(path.join(srcBasePath, item));
-  const files = glob.sync(srcPath + '/**/*.{css,js,svg}');
-
+  const files = glob.sync(srcPath + "/**/*.{css,js,svg}");
   files.forEach((file) => {
     const relativePath = slash(file.substring(staticBasePath.length));
-
     if (!/\.0x[a-z0-9_-]{8,12}\.\w+$/gi.test(file)) {
       const content = fs.readFileSync(file);
-      const sha1Hash = crypto.createHash('sha1');
-
+      const sha1Hash = crypto.createHash("sha1");
       sha1Hash.update(content);
-      const hash = sha1Hash.digest('base64url').substring(0, 10);
-
+      const hash = sha1Hash.digest("base64url").substring(0, 10);
       hashes.set(relativePath, hash);
     } else {
-      hashes.set(relativePath, '');
+      hashes.set(relativePath, "");
     }
   });
 });
-
-const sortedHashes = Array.from(hashes)
-  .sort((a, b) => a[0].localeCompare(b[0]))
-  .reduce(
-    (obj, [key, value]) => {
-      obj[key] = value;
-
-      return obj;
-    },
-    {} as { [key: string]: string }
-  );
-
-fs.writeFileSync(path.join(destBasePath, 'hashes.json'), JSON.stringify(sortedHashes, null, '  '));
-
+const sortedHashes = Array.from(hashes).sort((a, b) => a[0].localeCompare(b[0])).reduce(
+  (obj, [key, value]) => {
+    obj[key] = value;
+    return obj;
+  },
+  {}
+);
+fs.writeFileSync(path.join(destBasePath, "hashes.json"), JSON.stringify(sortedHashes, null, "  "));
 if (patternPath) {
   fs.mkdirSync(patternPath, { recursive: true });
-  glob.sync('./dist/static/{atoms,molecules,organisms,templates,pages}/**/*.*').forEach((p) => {
-    let basename = '';
-    const segments = slash(p).split('/');
-
+  glob.sync("./dist/static/{atoms,molecules,organisms,templates,pages}/**/*.*").forEach((p) => {
+    let basename = "";
+    const segments = slash(p).split("/");
     if (segments.length < 4) return;
     switch (segments.length) {
       case 4:
-        basename = path.basename(slash(p).replaceAll(/(atoms|molecules|organisms|templates|pages)\/([\w._-]+)$/gi, '$1-$2'));
+        basename = path.basename(slash(p).replaceAll(/(atoms|molecules|organisms|templates|pages)\/([\w._-]+)$/gi, "$1-$2"));
         fs.copyFileSync(p, resolve(patternPath, basename));
         break;
       default:
         segments.splice(0, 2);
-        nodeFs.cpSync(p, resolve(patternPath, segments.join('-')), { recursive: true });
+        fs$1.cpSync(p, resolve(patternPath, segments.join("-")), { recursive: true });
         break;
     }
   });
-
-  glob.sync(slash(path.resolve(patternPath + '/**/*.{htm,html}'))).forEach((p) => {
-    const text = fs.readFileSync(p, 'utf-8');
-    const newText = text
-      .replaceAll(/react-loader\.0x[a-z0-9_-]{8,12}\.js/gi, 'react-loader.0x00000000.js')
-      .replaceAll(/\.svg\?v=[a-z0-9_-]+/gi, '.svg');
-
+  glob.sync(slash(path.resolve(patternPath + "/**/*.{htm,html}"))).forEach((p) => {
+    const text = fs.readFileSync(p, "utf-8");
+    const newText = text.replaceAll(/react-loader\.0x[a-z0-9_-]{8,12}\.js/gi, "react-loader.0x00000000.js").replaceAll(/\.svg\?v=[a-z0-9_-]+/gi, ".svg");
     if (text !== newText) {
       fs.writeFileSync(p, newText);
     }
   });
 }
-
-const checkExistFileList: FileExistCheck[] = [
-  { fileName: 'hashes.json' },
-  { fileName: /react-loader\.0x[a-z0-9_-]{8,12}\.js/gi, folder: 'js' },
-  { fileName: 'main.js', folder: 'js' },
+const checkExistFileList = [
+  { fileName: "hashes.json" },
+  { fileName: /react-loader\.0x[a-z0-9_-]{8,12}\.js/gi, folder: "js" },
+  { fileName: "main.js", folder: "js" }
 ];
 let isAllExist = true;
-
 checkExistFileList.forEach((file) => {
-  if (typeof file.fileName === 'string') {
-    const destPath = slash(path.join(destBasePath, file.folder ?? '', file.fileName.toString()));
-
+  if (typeof file.fileName === "string") {
+    const destPath = slash(path.join(destBasePath, file.folder ?? "", file.fileName.toString()));
     if (!fs.existsSync(destPath)) {
       log(chalk.yellow(`Cannot find: ${destPath}`));
       isAllExist = false;
     }
   } else {
     const fileName = file.fileName;
-    const folderFiles = slash(path.join(destBasePath, file.folder ?? ''));
+    const folderFiles = slash(path.join(destBasePath, file.folder ?? ""));
     const files = fs.readdirSync(folderFiles);
     const found = files.find((f) => fileName.test(f));
-
     if (!found) {
       log(chalk.yellow(`Cannot find: ${slash(path.join(folderFiles, fileName.toString()))}`));
       isAllExist = false;
     }
   }
 });
-
 if (!isAllExist) {
   process.exit(1);
 }

package/dist/migrate-scss.js

@@ -0,0 +1,33 @@
+import { execSync } from "child_process";
+import { glob } from "glob";
+const migration = async () => {
+  const usableFiles = ["./xpack/styles/root.scss"];
+  const forwardableFiles = [
+    "./src/assets/styles/style-base.scss",
+    "./src/assets/styles/style.all.scss",
+    "./src/assets/styles/00-abstracts/_abstracts.scss",
+    "./src/assets/styles/01-mixins/_mixins.scss",
+    "./src/assets/styles/02-base/_base.scss"
+  ];
+  for (const file of forwardableFiles) {
+    try {
+      console.log(`Migrating ${file}`);
+      execSync(`bunx sass-migrator --migrate-deps module --forward=all ${file}`, { stdio: "inherit" });
+    } catch (err) {
+      console.error(err.message);
+    }
+  }
+  const componentFiles = await glob(["./src/atoms/**/*.scss", "./src/molecules/**/*.scss", "./src/organisms/**/*.scss"], { nodir: true });
+  const allFiles = [...usableFiles, ...componentFiles];
+  for (const file of allFiles) {
+    try {
+      console.log(`Migrating ${file}`);
+      execSync(`bunx sass-migrator module --migrate-deps ${file}`, { stdio: "inherit" });
+    } catch (err) {
+      console.error(err.message);
+    }
+  }
+};
+migration().catch((err) => {
+  console.error("An error occurred during migration:", err.message);
+});

package/dist/prerender.js

@@ -0,0 +1,158 @@
+import fs from "fs";
+import path from "path";
+import { pathToFileURL } from "url";
+import crypto from "node:crypto";
+import jsBeautify from "js-beautify";
+import * as cheerio from "cheerio";
+import slash from "slash";
+import _ from "lodash";
+import { loadEnv } from "vite";
+import chalk from "chalk";
+const argvModeIndex = process.argv.indexOf("--mode");
+const mode = argvModeIndex >= 0 && argvModeIndex < process.argv.length - 1 && !process.argv[argvModeIndex + 1].startsWith("-") ? process.argv[argvModeIndex + 1] : "production";
+const projectRoot = process.cwd();
+const xpackEnv = loadEnv(mode, projectRoot);
+const toAbsolute = (p) => path.resolve(projectRoot, p);
+const log = console.log.bind(console);
+const template = fs.readFileSync(toAbsolute(process.env.VITE_TEMPLATE ?? "dist/static/index.html"), "utf-8");
+const { render, routesToPrerender } = await import(pathToFileURL(toAbsolute("./dist/server/entry-server.js")).href);
+const beautifyOptions = {
+  indent_size: 2,
+  indent_char: " ",
+  keep_array_indentation: false,
+  break_chained_methods: false,
+  indent_scripts: "normal",
+  brace_style: "collapse",
+  space_before_conditional: true,
+  unescape_strings: false,
+  jslint_happy: false,
+  end_with_newline: false,
+  wrap_line_length: 0,
+  indent_inner_html: false,
+  comma_first: false,
+  e4x: false,
+  indent_empty_lines: false,
+  wrap_attributes: "force",
+  max_preserve_newlines: 5,
+  preserve_newlines: true
+};
+const updateResourcePath = ($, tagName, attr, addHash) => {
+  $(tagName).each((_2, el) => {
+    const href = $(el).attr(attr);
+    if (href && href.startsWith("/")) {
+      let newPath = href;
+      if (process.env.VITE_DOMAIN) {
+        newPath = process.env.VITE_DOMAIN + newPath;
+      }
+      if (href.startsWith(xpackEnv.VITE_BASE_URL) && !href.startsWith(xpackEnv.VITE_BASE_URL + "assets/vendors/") && [".css", ".ico", ".js", ".webmanifest", ".svg"].includes(path.extname(href).toLowerCase()) && !/\.0x[a-z0-9]{8}\.\w+$/gi.test(href)) {
+        const path2 = toAbsolute("dist/static/" + href.substring(xpackEnv.VITE_BASE_URL.length));
+        if (fs.existsSync(path2)) {
+          const content = fs.readFileSync(path2);
+          const sha1Hash = crypto.createHash("sha1");
+          sha1Hash.update(content);
+          const hash = sha1Hash.digest("base64url").substring(0, 10);
+          if (addHash) {
+            newPath += "?v=" + hash;
+          }
+        } else if (path2.endsWith("mock-api.js")) ;
+        else {
+          log(chalk.yellow("Cannot find:", path2));
+        }
+      }
+      if (newPath != href) {
+        $(el).attr(attr, newPath);
+      }
+    }
+  });
+};
+const removeStyleBase = ($) => {
+  $('link[rel="stylesheet"]').each((_2, el) => {
+    const href = $(el).attr("href");
+    if (href?.includes("style-base")) {
+      $(el).remove();
+    }
+  });
+};
+const removeDuplicateAssets = ($, selector, attr, paths) => {
+  $(selector).each((_2, el) => {
+    if ($(el).attr("data-pl-inplace") === "true") {
+      return;
+    }
+    const path2 = $(el).attr(attr);
+    if (!path2) {
+      return;
+    }
+    const index = $(el).index();
+    const parent = $(el).parent().clone();
+    const child = parent.children()[index];
+    parent.empty();
+    parent.append(child);
+    const html = parent.html();
+    $(el).after("\n<!-- " + html + " -->");
+    if (paths.includes(path2)) {
+      $(el).remove();
+      return;
+    }
+    paths.push(path2);
+    $(el).removeAttr("data-pl-require");
+    if ($(el).attr("type") === "module") {
+      const deferValue = $(el).attr("defer");
+      if ($(el).attr("defer") === "" || deferValue === "defer" || deferValue === "true") {
+        $(el).removeAttr("defer");
+      }
+    }
+    $("head").append(el);
+  });
+};
+const viteAbsoluteUrl = (remain, addExtension = false) => {
+  const baseUrl = xpackEnv.VITE_BASE_URL;
+  const normalizedRemain = (remain?.startsWith("/") ? remain : "/" + remain) + (addExtension && !remain.endsWith("/") ? xpackEnv.VITE_PATH_EXTENSION ?? "" : "");
+  if (!baseUrl) {
+    return normalizedRemain;
+  }
+  if (!baseUrl.endsWith("/")) {
+    return baseUrl + normalizedRemain;
+  }
+  const len = baseUrl.length;
+  return baseUrl.substring(0, len - 1) + normalizedRemain;
+};
+const renderPage = async (renderedPages, addHash) => {
+  for (const route of routesToPrerender) {
+    const output = await render(viteAbsoluteUrl(route.route, true));
+    const destLocalizedFolderPath = toAbsolute("dist/static");
+    let html = template.replace("<!--app-html-->", output.html ?? "").replace("@style.scss", "/assets/css/" + route.name + ".css");
+    const $ = cheerio.load(html);
+    const paths = [];
+    removeDuplicateAssets($, "link[data-pl-require][href]", "href", paths);
+    removeDuplicateAssets($, "script[data-pl-require][src]", "src", paths);
+    updateResourcePath($, "link", "href", addHash);
+    updateResourcePath($, "script", "src", addHash);
+    updateResourcePath($, "img", "src", addHash);
+    if (route.route === "/") {
+      removeStyleBase($);
+    }
+    $("head title").text(route.name);
+    const fileName = (route.route === "/" ? "/index" : route.route) + ".html";
+    const filePath = `${destLocalizedFolderPath}${fileName}`;
+    if (!fs.existsSync(path.dirname(filePath))) {
+      fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    }
+    html = $.html();
+    html = jsBeautify.html_beautify(html, beautifyOptions);
+    html = html.replace("/* app-styles */", output.styles);
+    fs.writeFileSync(toAbsolute(filePath), html);
+    log("pre-rendered:", slash(filePath));
+    renderedPages.push({
+      name: _.kebabCase(fileName.replaceAll(/\.\w+$/gi, "")),
+      url: `${process.env.VITE_DOMAIN ?? ""}${fileName}`,
+      fileName
+    });
+  }
+};
+(async () => {
+  const renderedPages = [];
+  const pool = [];
+  const addHash = !!process.argv.includes("--add-hash");
+  pool.push(renderPage(renderedPages, addHash));
+  await Promise.all(pool);
+})();

package/dist/scripts.js

@@ -0,0 +1,36 @@
+import fs from "fs";
+import path from "path";
+import chokidar from "chokidar";
+import { glob } from "glob";
+import slash from "slash";
+import { transformWithEsbuild } from "vite";
+const log = console.log.bind(console);
+const scriptCompile = async (inputPath) => {
+  console.log("compile:", slash(inputPath));
+  const code = fs.readFileSync(inputPath, "utf8");
+  return transformWithEsbuild(code, inputPath, {
+    minify: true,
+    format: "esm",
+    sourcemap: path.basename(inputPath).includes("critical") ? false : "external"
+  }).then((result) => {
+    const savePath = path.resolve("public/assets/js/" + path.parse(inputPath).name + ".js");
+    const saveDir = path.dirname(savePath);
+    if (!fs.existsSync(saveDir)) {
+      fs.mkdirSync(saveDir);
+    }
+    fs.writeFileSync(savePath, result.code);
+  }).catch((error) => {
+    log(error);
+  });
+};
+const run = async () => {
+  if (process.argv.includes("--watch")) {
+    const watcher = chokidar.watch("src/assets/scripts/**/*.{js,jsx,ts,tsx}");
+    watcher.on("add", scriptCompile).on("change", scriptCompile).on("unlink", (path2) => log(`File ${path2} has been removed`));
+  } else {
+    const pool = [];
+    glob.sync("src/assets/scripts/**/*.{js,jsx,ts,tsx}").forEach((p) => pool.push(scriptCompile(p)));
+    await Promise.all(pool);
+  }
+};
+await run();