buner 1.0.4 → 1.0.6

package/dist/server.js

@@ -0,0 +1,171 @@
+import { createServer as createServer$1, loadEnv } from "vite";
+import fs$1 from "node:fs";
+import path$1 from "node:path";
+import express from "express";
+import serveStatic from "serve-static";
+import chalk from "chalk";
+import fs from "fs";
+import path from "path";
+import * as cheerio from "cheerio";
+import jsBeautify from "js-beautify";
+const createViteDevServer = ({ root: root2, baseUrl, hmrPort, isTest: isTest2 }) => {
+  const server = createServer$1({
+    root: root2,
+    base: baseUrl,
+    logLevel: isTest2 ? "error" : "info",
+    server: {
+      middlewareMode: true,
+      watch: {
+        // During tests we edit the files too fast and sometimes chokidar
+        // misses change events, so enforce polling for consistency
+        usePolling: true,
+        interval: 200
+      },
+      hmr: {
+        port: hmrPort
+      }
+    },
+    appType: "custom"
+  });
+  return server;
+};
+const beautifyOptions = {
+  indent_size: 2,
+  indent_char: " ",
+  keep_array_indentation: false,
+  break_chained_methods: false,
+  indent_scripts: "normal",
+  brace_style: "expand",
+  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"
+};
+const updateResourcePath = ($, tagName, attr) => {
+  $(tagName).each((_, 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("/") && !href.startsWith("/assets/vendors/") && [".css", ".ico", ".js", ".webmanifest", ".svg"].includes(path.extname(href).toLowerCase()) && !/\.0x[a-z0-9]{8}\.\w+$/gi.test(href)) {
+        newPath += "?v=" + (/* @__PURE__ */ new Date()).getTime();
+      }
+      if (newPath != href) {
+        $(el).attr(attr, newPath);
+      }
+    }
+  });
+};
+const removeDuplicateAssets = ($, selector, attr, paths) => {
+  $(selector).each((_, 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);
+    $("head").append(el);
+  });
+};
+const _useRenderer = ({ app, indexProd, isProd: isProd2, viteDevServer, resolve }) => {
+  app.use(async (req, res) => {
+    try {
+      let template, render;
+      if (!isProd2) {
+        template = fs.readFileSync(resolve("index.html"), "utf-8");
+        template = await viteDevServer.transformIndexHtml(req.originalUrl, template);
+        render = (await viteDevServer.ssrLoadModule(resolve("src/entry-server.tsx"))).render;
+      } else {
+        template = indexProd;
+        render = (await import(resolve("dist/server/entry-server.js"))).render;
+      }
+      const context = {};
+      const output = render(req.originalUrl);
+      if (context.url) {
+        return res.redirect(301, context.url);
+      }
+      const html = template.replace("<!--app-html-->", output.html);
+      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");
+      updateResourcePath($, "script", "src");
+      updateResourcePath($, "img", "src");
+      res.status(200).set({ "Content-Type": "text/html" }).end(jsBeautify.html_beautify($.html(), beautifyOptions).replace("/* app-styles */", output.styles));
+    } catch (e) {
+      !isProd2 && viteDevServer.ssrFixStacktrace(e);
+      console.log(e.stack);
+      res.status(500).end(e.stack);
+    }
+  });
+};
+const argvModeIndex$1 = process.argv.indexOf("--mode");
+const mode$1 = argvModeIndex$1 >= 0 && argvModeIndex$1 < process.argv.length - 1 && !process.argv[argvModeIndex$1 + 1].startsWith("-") ? process.argv[argvModeIndex$1 + 1] : "production";
+process.env.MY_CUSTOM_SECRET = "API_KEY_4c2928b5a14b475d94c3579cbea06178";
+const isProd = process.env.NODE_ENV === "production";
+const createServer = async ({ root: root2, hmrPort, baseUrl, isTest: isTest2 }) => {
+  const resolve = (p) => path$1.join(root2, p);
+  const indexProd = isProd ? fs$1.readFileSync(resolve("index.html"), "utf-8") : "";
+  const app = express();
+  let viteDevServer;
+  if (!isProd) {
+    viteDevServer = await createViteDevServer({ root: root2, baseUrl, hmrPort, isTest: isTest2 });
+    app.use(viteDevServer.middlewares);
+  }
+  app.use("/assets/images", serveStatic(resolve("public/assets/images"), { index: false }));
+  app.use("/assets/fonts", serveStatic(resolve("public/assets/fonts"), { index: false }));
+  app.use("/assets/css", serveStatic(resolve("public/assets/css"), { index: false }));
+  app.use("/assets/js", serveStatic(resolve("public/assets/js"), { index: false }));
+  app.use("/assets/vendors", serveStatic(resolve("public/assets/vendors"), { index: false }));
+  app.use("/assets", serveStatic(resolve("dist/assets"), { index: false }));
+  app.use("/samples", serveStatic(resolve("public/samples"), { index: false }));
+  _useRenderer({ app, indexProd, isProd, viteDevServer, resolve });
+  return { app, viteDevServer };
+};
+const startServer = (props) => {
+  createServer(props).then(({ app }) => {
+    app.listen(props.port, () => {
+      const xpackEnv2 = loadEnv(mode$1, props.root);
+      console.log("Running on " + chalk.green("http://localhost:" + props.port + xpackEnv2.VITE_BASE_URL));
+    });
+  });
+};
+console.log("[INIT] server");
+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 root = process.cwd();
+const xpackEnv = loadEnv(mode, root);
+const isTest = !!xpackEnv.VITE_TEST_BUILD || process.env.NODE_ENV === "test";
+const port = xpackEnv.VITE_PORT ? parseInt(xpackEnv.VITE_PORT) : 5e3;
+if (!isTest) {
+  console.log(root);
+  startServer({
+    root,
+    isTest,
+    port,
+    hmrPort: port + 1,
+    baseUrl: xpackEnv.VITE_BASE_URL
+  });
+}

package/dist/states.js

@@ -0,0 +1,41 @@
+import fs from "fs";
+import chokidar from "chokidar";
+import debounce from "debounce";
+import { glob } from "glob";
+const isWatch = process.argv.includes("--watch");
+const log = console.log.bind(console);
+const states = {};
+const buildStates = debounce(() => {
+  const output = [];
+  const keys = Object.keys(states);
+  [].forEach.call(keys, (key) => {
+    const state = states[key];
+    if (!state) {
+      return;
+    }
+    try {
+      output.push(JSON.parse(state));
+    } catch (error) {
+      console.log(error);
+    }
+  });
+  const json = JSON.stringify(output, null, "  ");
+  fs.writeFileSync("public/pl-states.json", json);
+}, 500);
+const setStates = (statePath) => {
+  const state = fs.readFileSync(statePath, "utf-8");
+  states[statePath] = state;
+  buildStates();
+};
+const removeStates = (statePath) => {
+  delete states[statePath];
+  buildStates();
+};
+if (isWatch) {
+  const watcher = chokidar.watch("src/**/*.states.json");
+  watcher.on("ready", () => {
+    log("States are ready!");
+  }).on("add", (path) => setStates(path)).on("change", (path) => setStates(path)).on("unlink", (path) => removeStates(path));
+} else {
+  glob.sync("src/**/*.states.json").forEach((path) => setStates(path));
+}

package/dist/styles.js

@@ -0,0 +1,165 @@
+import fs from "fs";
+import path from "path";
+import { pathToFileURL, fileURLToPath } from "url";
+import { watch } from "chokidar";
+import * as sass from "sass";
+import slash from "slash";
+import debounce from "debounce";
+import { glob } from "glob";
+import postcss from "postcss";
+import autoprefixer from "autoprefixer";
+import cssnano from "cssnano";
+const isWatch = process.argv.includes("--watch");
+const outDir = "./public/assets/css";
+if (!isWatch && fs.existsSync(outDir)) {
+  fs.rmSync(outDir, { force: true, recursive: true });
+}
+if (!fs.existsSync(outDir)) {
+  fs.mkdirSync(outDir, { recursive: true });
+}
+const log = console.log.bind(console);
+const prepareCssFileContent = ({
+  srcFile,
+  includeMixins = true,
+  includeAbstracts = true
+}) => {
+  return [
+    includeAbstracts ? slash(`@use '${path.relative(path.dirname(srcFile), path.resolve("src/assets/styles/00-abstracts/abstracts"))}' as *;
+`) : void 0,
+    includeMixins ? slash(`@use '${path.relative(path.dirname(srcFile), path.resolve("src/assets/styles/01-mixins/mixins"))}' as *;
+`) : void 0,
+    fs.readFileSync(srcFile, "utf-8")
+  ].filter(Boolean);
+};
+const stringOptions = (srcFile) => {
+  const options = {
+    sourceMap: true,
+    sourceMapIncludeSources: true,
+    syntax: "scss",
+    style: "compressed",
+    url: pathToFileURL(path.resolve(srcFile)),
+    importer: {
+      canonicalize(url) {
+        return new URL(url);
+      },
+      load(canonicalUrl) {
+        let filePath = fileURLToPath(canonicalUrl);
+        if (!filePath.endsWith(".scss")) {
+          const parentDir = path.dirname(filePath);
+          const fileName = path.basename(filePath);
+          filePath = path.join(parentDir, fileName + ".scss");
+          if (!fs.existsSync(filePath)) {
+            filePath = path.join(parentDir, "_" + fileName + ".scss");
+          }
+        }
+        if (!fs.existsSync(filePath)) return null;
+        if (filePath.includes("abstracts") || filePath.includes("_mixins") || filePath.includes("_base") || filePath.includes("xpack"))
+          return {
+            contents: fs.readFileSync(filePath, "utf-8"),
+            syntax: "scss"
+          };
+        let content = prepareCssFileContent({ srcFile: filePath });
+        if (filePath.includes("mixins")) {
+          content = prepareCssFileContent({ srcFile: filePath, includeMixins: false });
+        }
+        return {
+          contents: content.join(""),
+          syntax: "scss"
+        };
+      }
+    }
+  };
+  return options;
+};
+const compile = (srcFile, options) => {
+  if (options.isReady) {
+    log("compile:", slash(srcFile));
+  }
+  if (path.basename(srcFile).startsWith("_")) {
+    return;
+  }
+  const name = path.basename(srcFile) === "index.scss" ? path.basename(path.dirname(srcFile)) + ".css" : path.basename(srcFile).replace(/\.scss$/gi, ".css");
+  const outFile = (options.prefix ?? "") + name;
+  const cssStrings = srcFile.includes("xpack") ? [fs.readFileSync(srcFile, "utf-8")] : prepareCssFileContent({ srcFile });
+  if (srcFile.includes("style-base") || srcFile.includes("style-all")) {
+    glob.sync("./src/atoms/**/*.scss").forEach((atomPath) => {
+      if (!path.basename(atomPath).startsWith("_")) {
+        cssStrings.push(sass.compileString(prepareCssFileContent({ srcFile: atomPath }).join(""), stringOptions(atomPath)).css);
+      }
+    });
+    glob.sync("./src/molecules/**/*.scss").forEach((molPath) => {
+      if (!path.basename(molPath).startsWith("_")) {
+        cssStrings.push(sass.compileString(prepareCssFileContent({ srcFile: molPath }).join(""), stringOptions(molPath)).css);
+      }
+    });
+  }
+  sass.compileStringAsync(cssStrings.join(""), stringOptions(srcFile)).then((result) => postcssProcess(result, srcFile, outFile)).catch((error) => {
+    log(error);
+  });
+};
+const postcssProcess = (result, from, to) => {
+  const postcssOptions = { from: pathToFileURL(from).href, to, map: { prev: result.sourceMap, absolute: false } };
+  postcss([autoprefixer({ grid: true }), cssnano]).process(result.css, postcssOptions).then((result2) => {
+    fs.writeFileSync(path.join(outDir, to), result2.css + (result2.map ? `
+/*# sourceMappingURL=${to}.map */` : ""));
+    if (result2.map) {
+      fs.writeFileSync(path.join(outDir, to + ".map"), result2.map.toString());
+    }
+  });
+};
+const styleOrganisms = debounce((isReady) => {
+  const paths = glob.sync("src/organisms/**/*.scss", { nodir: true });
+  [].forEach.call(paths, (p) => styleOrganism(p, isReady));
+}, 200);
+const styleTemplates = debounce((isReady) => {
+  const paths = glob.sync("src/templates/**/*.scss", { nodir: true });
+  [].forEach.call(paths, (p) => styleTemplate(p, isReady));
+}, 200);
+const styleBase = debounce((isReady) => compile("src/assets/styles/style-base.scss", { isReady }), 200);
+const stylePlState = debounce((isReady) => compile("xpack/styles/pl-states.scss", { isReady }), 200);
+const styleRoot = debounce((isReady) => compile("xpack/styles/root.scss", { isReady }), 200);
+const styleOrganism = (srcFile, isReady) => compile(srcFile, { prefix: "b-", isReady });
+const styleTemplate = (srcFile, isReady) => compile(srcFile, { prefix: "p-", isReady });
+const sassCompile = (inputPath, isReady) => {
+  const p = slash(inputPath);
+  if (p.startsWith("src/assets/styles/00-abstracts/") || p.startsWith("src/assets/styles/01-mixins/")) {
+    styleBase(isReady);
+    styleOrganisms(isReady);
+    styleTemplates(isReady);
+    stylePlState(isReady);
+  }
+  if (p.startsWith("src/atoms") || p.startsWith("src/molecules") || p.startsWith("src/assets/styles/02-base")) {
+    styleBase(isReady);
+  }
+  if (p.startsWith("src/organisms")) {
+    if (path.basename(p).startsWith("_")) {
+      glob.sync(path.dirname(p) + "/*.scss", { nodir: true }).filter((p2) => !path.basename(p2).startsWith("_")).forEach((p2) => styleOrganism(p2, isReady));
+    } else {
+      styleOrganism(p, isReady);
+    }
+  }
+  if (p.startsWith("src/templates")) {
+    if (path.basename(p).startsWith("_")) {
+      glob.sync(path.dirname(p) + "/*.scss", { nodir: true }).filter((p2) => !path.basename(p2).startsWith("_")).forEach((p2) => styleTemplate(p2, isReady));
+    } else {
+      styleTemplate(p, isReady);
+    }
+  }
+  if (p.startsWith("xpack/styles/pl-states")) {
+    stylePlState(isReady);
+  } else if (p.startsWith("xpack/styles")) {
+    styleRoot(isReady);
+  }
+};
+if (isWatch) {
+  const watcher = watch(["src", "xpack/styles"], { ignored: (path2, stats) => !!stats?.isFile() && !path2.endsWith(".scss") });
+  let isReady = false;
+  watcher.on("ready", () => {
+    log("SCSS ready!");
+    isReady = true;
+  }).on("add", (path2) => sassCompile(path2, isReady)).on("change", (path2) => sassCompile(path2, isReady)).on("unlink", (path2) => log(`File ${path2} has been removed`));
+} else {
+  styleBase(true);
+  stylePlState(true);
+  glob.sync(["src/{organisms,templates}/**/*.scss", "xpack/styles/**/*.scss"]).filter((p) => !path.basename(p).startsWith("_")).forEach((path2) => sassCompile(path2, true));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buner",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Frontend build toolkit for Vite + React SSR projects — SCSS pipeline, prerender, SSR dev server, and backend integration.",
   "type": "module",
   "license": "MIT",
@@ -20,20 +20,12 @@
     "cli"
   ],
   "bin": {
-    "buner": "./bin/buner.js"
+    "buner": "./dist/buner.js"
   },
   "files": [
-    "bin",
-    "cli",
+    "dist",
     "xpack",
     "public",
-    "server.ts",
-    "prerender.ts",
-    "integration.ts",
-    "styles.ts",
-    "scripts.ts",
-    "states.ts",
-    "migrate-scss.ts",
     "vite.config.ts",
     "index.html",
     "tsconfig.json",

package/cli/README.md

@@ -1 +0,0 @@
-[![Build Status](https://episerver-es-emea.visualstudio.com/Alloy-Template/_apis/build/status%2FFE%20-%20Integration?branchName=fe-release)](https://episerver-es-emea.visualstudio.com/Alloy-Template/_build/latest?definitionId=28&branchName=fe-release)

package/cli/buner.ts

@@ -1,241 +0,0 @@
-/* eslint-disable no-console */
-
-import path from 'path';
-import { execSync, spawn, SpawnOptions } from 'child_process';
-import { fileURLToPath } from 'url';
-
-import { Command } from 'commander';
-import chalk from 'chalk';
-import fetch from 'node-fetch';
-import prompts from 'prompts';
-
-import packageJson from '../package.json';
-
-import { createApp } from './create-app.js';
-import { validateNpmName } from './helpers/validate-pkg.js';
-
-const { green, yellow, bold, cyan, red } = chalk;
-const packageName = 'buner';
-
-// Package's own directory (where server.ts, styles.ts, etc. live)
-const packageDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-
-/** Resolve a file path relative to the buner package directory */
-const pkg = (file: string) => path.join(packageDir, file);
-
-const run = (cmd: string, args: string[] = [], options: SpawnOptions = {}) => {
-  return new Promise<void>((resolve, reject) => {
-    const child = spawn(cmd, args, {
-      stdio: 'inherit',
-      shell: true,
-      cwd: process.cwd(),
-      ...options,
-    });
-
-    child.on('close', (code) => {
-      if (code !== 0) {
-        reject(new Error(`Command "${cmd} ${args.join(' ')}" exited with code ${code}`));
-      } else {
-        resolve();
-      }
-    });
-
-    child.on('error', reject);
-  });
-};
-
-const runSync = (cmd: string) => {
-  execSync(cmd, { stdio: 'inherit', cwd: process.cwd() });
-};
-
-const onPromptState = (state: { value?: string; aborted?: boolean }) => {
-  if (state?.aborted) {
-    process.stdout.write('\x1B[?25h');
-    process.stdout.write('\n');
-    process.exit(1);
-  }
-};
-
-const parseVersion = (version: string): number => {
-  return parseInt(version.replaceAll('.', ''));
-};
-
-const update = fetch(`https://registry.npmjs.org/${packageJson.name}/latest`)
-  .then((res) => res.json())
-  .catch(() => null);
-
-async function notifyUpdate(): Promise<void> {
-  try {
-    const data = (await update) as { version: string };
-
-    if (data.version && parseVersion(data.version) !== parseVersion(packageJson.version)) {
-      const updateMessage = `npm update -g ${packageName}`;
-
-      console.log(
-        yellow(bold(`A new version of '${packageName}' is available!`)) + '\n' + 'You can update by running: ' + cyan(updateMessage) + '\n'
-      );
-    }
-  } catch {
-    // ignore error
-  }
-}
-
-const program = new Command();
-
-program.name(packageName).description('Frontend build toolkit for Vite + React SSR projects').version(packageJson.version);
-
-// buner create [dir]
-program
-  .command('create')
-  .argument('[project-directory]', 'the project name', '')
-  .description('Scaffold a new frontend project')
-  .action(async (projectPath: string) => {
-    if (!projectPath) {
-      const validation = validateNpmName('my-app');
-
-      const res = await prompts({
-        onState: onPromptState,
-        type: 'text',
-        name: 'path',
-        message: 'What is your project named?',
-        initial: 'my-app',
-        validate: (name) => {
-          const validation = validateNpmName(path.basename(path.resolve(name)));
-
-          if (validation.valid) {
-            return true;
-          }
-
-          return `Invalid project name ${validation?.problems?.[0] ? validation?.problems?.[0] : ''}`;
-        },
-      });
-
-      if (typeof res.path === 'string') {
-        projectPath = res.path.trim();
-      }
-    }
-
-    if (!projectPath) {
-      console.log(
-        '\nPlease specify the project directory:\n' +
-          `  ${cyan('buner create')} ${green('<project-directory>')}\n` +
-          'For example:\n' +
-          `  ${cyan('buner create')} ${green('my-app')}\n`
-      );
-      process.exit(1);
-    }
-
-    const resolvedProjectPath = path.resolve(projectPath);
-
-    await createApp({ appPath: resolvedProjectPath });
-    await notifyUpdate();
-  });
-
-// buner dev
-program
-  .command('dev')
-  .description('Start development mode with all watchers')
-  .action(async () => {
-    await run('npx', [
-      '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"`,
-    ]);
-  });
-
-// buner serve
-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]);
-  });
-
-// buner build
-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`);
-  });
-
-// buner generate
-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')}`);
-    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`);
-    } 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(`bun ${pkg('prerender.ts')} --add-hash --mode ${opts.mode}`);
-  });
-
-// buner eshn
-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`);
-  });
-
-// buner inte
-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')}`);
-  });
-
-// buner styles
-program
-  .command('styles')
-  .description('Compile SCSS')
-  .option('--watch', 'Watch for changes')
-  .action(async (opts) => {
-    const args = [pkg('styles.ts')];
-
-    if (opts.watch) args.push('--watch');
-    await run('bun', args);
-  });
-
-// buner prerender
-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')];
-
-    if (opts.addHash) args.push('--add-hash');
-    args.push('--mode', opts.mode);
-    await run('bun', args);
-  });
-
-program.parseAsync(process.argv).catch(async (error) => {
-  console.log(red(error));
-  await notifyUpdate();
-  process.exit(1);
-});
-
-export { packageName };