npm - @blinkk/root - Versions diffs - 1.0.0-alpha.0 - Mend

@blinkk/root 1.0.0-alpha.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

package/bin/root.js +22 -0
package/dist/chunk-4SVK7R4Z.js +93 -0
package/dist/chunk-4SVK7R4Z.js.map +1 -0
package/dist/cli.d.ts +7 -0
package/dist/cli.js +548 -0
package/dist/cli.js.map +1 -0
package/dist/config-5b8f6033.d.ts +15 -0
package/dist/core.d.ts +41 -0
package/dist/core.js +27 -0
package/dist/core.js.map +1 -0
package/dist/render.d.ts +69 -0
package/dist/render.js +354 -0
package/dist/render.js.map +1 -0
package/package.json +70 -0

package/bin/root.js ADDED Viewed

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import {Command} from 'commander';
+import {build, dev, start} from '../dist/cli.js';
+const program = new Command('root');
+program.version(process.env.npm_package_version || 'dev');
+program
+  .command('build [path]')
+  .description('generates a static build')
+  .action(build);
+program
+  .command('dev [path]')
+  .description('starts the server in development mode')
+  .action(dev);
+program
+  .command('start [path]')
+  .description('starts the server in production mode')
+  .action(start);
+program.parse(process.argv);

package/dist/chunk-4SVK7R4Z.js ADDED Viewed

@@ -0,0 +1,93 @@
+// src/core/components/error-page.tsx
+import { h } from "preact";
+function ErrorPage(props) {
+  const error = props.error;
+  let message = void 0;
+  if (import.meta.env.DEV) {
+    if (error instanceof Error) {
+      message = error.stack;
+    } else {
+      message = String(error);
+    }
+  }
+  return /* @__PURE__ */ h("div", null, /* @__PURE__ */ h("div", null, /* @__PURE__ */ h("p", null, "An error occured during route handling or page rendering."), message && /* @__PURE__ */ h("pre", null, message)));
+}
+// src/core/components/head.ts
+import { createContext } from "preact";
+import { useContext } from "preact/hooks";
+var HEAD_CONTEXT = createContext([]);
+function Head(props) {
+  let context;
+  try {
+    context = useContext(HEAD_CONTEXT);
+  } catch (err) {
+    console.log(err);
+    throw new Error("<Head> component is not supported in the browser, or during suspense renders.", { cause: err });
+  }
+  context.push(props.children);
+  return null;
+}
+// src/core/components/script.ts
+import { createContext as createContext2 } from "preact";
+import { useContext as useContext2 } from "preact/hooks";
+var SCRIPT_CONTEXT = createContext2([]);
+function Script(props) {
+  let context;
+  try {
+    context = useContext2(SCRIPT_CONTEXT);
+  } catch (err) {
+    throw new Error("<Script> component is not supported in the browser, or during suspense renders.", { cause: err });
+  }
+  context.push(props);
+  return null;
+}
+// src/core/i18n.ts
+import path from "node:path";
+import { createContext as createContext3 } from "preact";
+import { useContext as useContext3 } from "preact/hooks";
+var I18N_CONTEXT = createContext3(null);
+function t(str, params) {
+  const context = useContext3(I18N_CONTEXT);
+  if (!context) {
+    throw new Error("could not find i18n context");
+  }
+  const translations = (context == null ? void 0 : context.translations) || {};
+  let translation = translations[str] || str;
+  if (params) {
+    for (const key in params) {
+      const val = String(params[key] || "");
+      translation = translation.replaceAll(`{${key}}`, val);
+    }
+  }
+  return translation;
+}
+function getTranslations(locale) {
+  const translations = {};
+  const translationsFiles = import.meta.glob(["/translations/*.json"], {
+    eager: true
+  });
+  Object.keys(translationsFiles).forEach((translationPath) => {
+    const parts = path.parse(translationPath);
+    const locale2 = parts.name;
+    const module = translationsFiles[translationPath];
+    if (module && module.default) {
+      translations[locale2] = module.default;
+    }
+  });
+  return translations[locale] || {};
+}
+export {
+  ErrorPage,
+  HEAD_CONTEXT,
+  Head,
+  SCRIPT_CONTEXT,
+  Script,
+  I18N_CONTEXT,
+  t,
+  getTranslations
+};
+//# sourceMappingURL=chunk-4SVK7R4Z.js.map

package/dist/chunk-4SVK7R4Z.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"sources":["../src/core/components/error-page.tsx","../src/core/components/head.ts","../src/core/components/script.ts","../src/core/i18n.ts"],"sourcesContent":["import {h} from 'preact';\n\nexport interface ErrorPageProps {\n error: unknown;\n}\n\nexport function ErrorPage(props: ErrorPageProps) {\n const error = props.error;\n\n let message = undefined;\n if (import.meta.env.DEV) {\n if (error instanceof Error) {\n message = error.stack;\n } else {\n message = String(error);\n }\n }\n\n return (\n <div>\n <div>\n <p>An error occured during route handling or page rendering.</p>\n {message && <pre>{message}</pre>}\n </div>\n </div>\n );\n}\n","import {ComponentChildren, createContext} from 'preact';\nimport {useContext} from 'preact/hooks';\n\nexport const HEAD_CONTEXT = createContext<ComponentChildren[]>([]);\n\nexport interface HeadProps {\n children?: ComponentChildren;\n}\n\n/**\n * The <Head> component can be used for injecting elements into the HTML head\n * tag from any part of a page.\n */\nexport function Head(props: HeadProps) {\n let context: ComponentChildren[];\n try {\n context = useContext(HEAD_CONTEXT);\n } catch (err) {\n console.log(err);\n throw new Error(\n '<Head> component is not supported in the browser, or during suspense renders.',\n {cause: err}\n );\n }\n context.push(props.children);\n return null;\n}\n","import {createContext} from 'preact';\nimport {useContext} from 'preact/hooks';\n\nexport const SCRIPT_CONTEXT = createContext<ScriptProps[]>([]);\n\nexport interface ScriptProps {\n src: string;\n type?: string;\n}\n\n/**\n * The <Script> component is used for rendering any custom script modules. At\n * the moment, the system only pre-renders and bundles files that are in the\n * `src/bundles` folder at the root of the project.\n */\nexport function Script(props: ScriptProps) {\n let context: ScriptProps[];\n try {\n context = useContext(SCRIPT_CONTEXT);\n } catch (err) {\n throw new Error(\n '<Script> component is not supported in the browser, or during suspense renders.',\n {cause: err}\n );\n }\n context.push(props);\n return null;\n}\n","import path from 'node:path';\nimport {createContext} from 'preact';\nimport {useContext} from 'preact/hooks';\n\nexport const I18N_CONTEXT = createContext<I18nContext | null>(null);\n\nexport interface I18nContext {\n locale: string;\n translations: Record<string, string>;\n}\n\nexport function t(str: string, params?: Record<string, string>) {\n const context = useContext(I18N_CONTEXT);\n if (!context) {\n throw new Error('could not find i18n context');\n }\n const translations = context?.translations || {};\n let translation = translations[str] || str;\n if (params) {\n for (const key in params) {\n const val = String(params[key] || '');\n translation = translation.replaceAll(`{${key}}`, val);\n }\n }\n return translation;\n}\n\nexport function getTranslations(locale: string): Record<string, string> {\n const translations: Record<string, Record<string, string>> = {};\n const translationsFiles = import.meta.glob(['/translations/*.json'], {\n eager: true,\n }) as Record<string, {default?: Record<string, string>}>;\n Object.keys(translationsFiles).forEach((translationPath) => {\n const parts = path.parse(translationPath);\n const locale = parts.name;\n const module = translationsFiles[translationPath];\n if (module && module.default) {\n translations[locale] = module.default;\n }\n });\n return translations[locale] || {};\n}\n"],"mappings":";AAAA;AAMO,mBAAmB,OAAuB;AAC/C,QAAM,QAAQ,MAAM;AAEpB,MAAI,UAAU;AACd,MAAI,YAAY,IAAI,KAAK;AACvB,QAAI,iBAAiB,OAAO;AAC1B,gBAAU,MAAM;AAAA,IAClB,OAAO;AACL,gBAAU,OAAO,KAAK;AAAA,IACxB;AAAA,EACF;AAEA,SACE,kBAAC,aACC,kBAAC,aACC,kBAAC,WAAE,2DAAyD,GAC3D,WAAW,kBAAC,aAAK,OAAQ,CAC5B,CACF;AAEJ;;;AC1BA;AACA;AAEO,IAAM,eAAe,cAAmC,CAAC,CAAC;AAU1D,cAAc,OAAkB;AACrC,MAAI;AACJ,MAAI;AACF,cAAU,WAAW,YAAY;AAAA,EACnC,SAAS,KAAP;AACA,YAAQ,IAAI,GAAG;AACf,UAAM,IAAI,MACR,iFACA,EAAC,OAAO,IAAG,CACb;AAAA,EACF;AACA,UAAQ,KAAK,MAAM,QAAQ;AAC3B,SAAO;AACT;;;AC1BA;AACA;AAEO,IAAM,iBAAiB,eAA6B,CAAC,CAAC;AAYtD,gBAAgB,OAAoB;AACzC,MAAI;AACJ,MAAI;AACF,cAAU,YAAW,cAAc;AAAA,EACrC,SAAS,KAAP;AACA,UAAM,IAAI,MACR,mFACA,EAAC,OAAO,IAAG,CACb;AAAA,EACF;AACA,UAAQ,KAAK,KAAK;AAClB,SAAO;AACT;;;AC3BA;AACA;AACA;AAEO,IAAM,eAAe,eAAkC,IAAI;AAO3D,WAAW,KAAa,QAAiC;AAC9D,QAAM,UAAU,YAAW,YAAY;AACvC,MAAI,CAAC,SAAS;AACZ,UAAM,IAAI,MAAM,6BAA6B;AAAA,EAC/C;AACA,QAAM,eAAe,oCAAS,iBAAgB,CAAC;AAC/C,MAAI,cAAc,aAAa,QAAQ;AACvC,MAAI,QAAQ;AACV,eAAW,OAAO,QAAQ;AACxB,YAAM,MAAM,OAAO,OAAO,QAAQ,EAAE;AACpC,oBAAc,YAAY,WAAW,IAAI,QAAQ,GAAG;AAAA,IACtD;AAAA,EACF;AACA,SAAO;AACT;AAEO,yBAAyB,QAAwC;AACtE,QAAM,eAAuD,CAAC;AAC9D,QAAM,oBAAoB,YAAY,KAAK,CAAC,sBAAsB,GAAG;AAAA,IACnE,OAAO;AAAA,EACT,CAAC;AACD,SAAO,KAAK,iBAAiB,EAAE,QAAQ,CAAC,oBAAoB;AAC1D,UAAM,QAAQ,KAAK,MAAM,eAAe;AACxC,UAAM,UAAS,MAAM;AACrB,UAAM,SAAS,kBAAkB;AACjC,QAAI,UAAU,OAAO,SAAS;AAC5B,mBAAa,WAAU,OAAO;AAAA,IAChC;AAAA,EACF,CAAC;AACD,SAAO,aAAa,WAAW,CAAC;AAClC;","names":[]}

package/dist/cli.d.ts ADDED Viewed

@@ -0,0 +1,7 @@
+declare function dev(rootDir?: string): void;
+declare function build(rootDir?: string): Promise<void>;
+declare function start(rootDir?: string): Promise<void>;
+export { build, dev, start };

package/dist/cli.js ADDED Viewed

@@ -0,0 +1,548 @@
+// src/cli/commands/dev.ts
+import path3 from "node:path";
+import { fileURLToPath } from "node:url";
+import { default as express } from "express";
+import { createServer as createViteServer } from "vite";
+// src/render/vite-plugin-root.ts
+import path from "path";
+import glob from "tiny-glob";
+var ELEMENTS_REGEX = /h\("(\w[\w-]+\w)"/g;
+function pluginRoot(options) {
+  const rootDir = (options == null ? void 0 : options.rootDir) || process.cwd();
+  let config;
+  let server;
+  let elementMap;
+  async function updateElementMap() {
+    elementMap = {};
+    const files = await glob("./elements/**/*", { cwd: rootDir });
+    files.forEach((file) => {
+      const parts = path.parse(file);
+      if (isJsFile(parts.base)) {
+        elementMap[parts.name] = `${rootDir}/${file}`;
+      }
+    });
+  }
+  async function getElementImport(tagName) {
+    if (!elementMap) {
+      await updateElementMap();
+    }
+    if (tagName in elementMap) {
+      const filePath = elementMap[tagName];
+      if (server && server.moduleGraph) {
+        const moduleSet = server.moduleGraph.getModulesByFile(filePath);
+        if (moduleSet && moduleSet.size > 0) {
+          const module = moduleSet.values().next().value;
+          return module.url;
+        }
+      }
+    }
+    return null;
+  }
+  return {
+    name: "vite-plugin-root",
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+    },
+    configureServer(_server) {
+      server = _server;
+    },
+    async transform(src, id) {
+      if (id.includes("/elements/") && isJsFile(id)) {
+        const idParts = path.parse(id);
+        const deps = /* @__PURE__ */ new Set();
+        const elementsRe = ELEMENTS_REGEX;
+        for (const match of src.matchAll(elementsRe)) {
+          const tagName = match[1];
+          if (!tagName.includes("-")) {
+            continue;
+          }
+          if (tagName === idParts.name) {
+            continue;
+          }
+          deps.add(tagName);
+        }
+        const importUrls = [];
+        await Promise.all(Array.from(deps).map(async (tagName) => {
+          const importUrl = await getElementImport(tagName);
+          if (importUrl) {
+            importUrls.push(importUrl);
+          }
+        }));
+        if (importUrls.length > 0) {
+          const importLines = importUrls.map((url) => `import '${url}';`).join("\n");
+          const code = `${src}
+// autogenerated by root:
+${importLines}
+`;
+          return { code };
+        }
+        return null;
+      }
+    }
+  };
+}
+function isJsFile(file) {
+  return !!file.match(/\.(j|t)sx?$/);
+}
+var vite_plugin_root_default = pluginRoot;
+// src/render/asset-map/dev-asset-map.ts
+import path2 from "node:path";
+var DevServerAssetMap = class {
+  constructor(moduleGraph) {
+    this.moduleGraph = moduleGraph;
+  }
+  async get(moduleId) {
+    const viteModule = await this.moduleGraph.getModuleByUrl(moduleId);
+    if (!viteModule || !viteModule.id) {
+      return null;
+    }
+    return new DevServerAsset(this, viteModule);
+  }
+};
+var DevServerAsset = class {
+  constructor(assetMap, viteModule) {
+    this.assetMap = assetMap;
+    this.viteModule = viteModule;
+    this.moduleId = this.viteModule.id;
+    this.assetUrl = this.viteModule.url;
+  }
+  async getCssDeps() {
+    const visited = /* @__PURE__ */ new Set();
+    const deps = /* @__PURE__ */ new Set();
+    this.collectCss(this, deps, visited);
+    return Array.from(deps);
+  }
+  async getJsDeps() {
+    const visited = /* @__PURE__ */ new Set();
+    const deps = /* @__PURE__ */ new Set();
+    this.collectJs(this, deps, visited);
+    return Array.from(deps);
+  }
+  getImportedModules() {
+    return this.viteModule.importedModules;
+  }
+  collectJs(asset, urls, visited) {
+    if (!asset) {
+      return;
+    }
+    if (!asset.moduleId) {
+      return;
+    }
+    if (visited.has(asset.moduleId)) {
+      return;
+    }
+    visited.add(asset.moduleId);
+    const parts = path2.parse(asset.assetUrl);
+    if ([".js", ".jsx", ".ts", ".tsx"].includes(parts.ext) && asset.moduleId.includes("/elements/")) {
+      urls.add(asset.assetUrl);
+    }
+    asset.getImportedModules().forEach((viteModule) => {
+      if (viteModule.id) {
+        const importedAsset = new DevServerAsset(this.assetMap, viteModule);
+        this.collectJs(importedAsset, urls, visited);
+      }
+    });
+  }
+  collectCss(asset, urls, visited) {
+    if (!asset) {
+      return;
+    }
+    if (!asset.assetUrl) {
+      return;
+    }
+    if (visited.has(asset.assetUrl)) {
+      return;
+    }
+    visited.add(asset.assetUrl);
+    if (asset.moduleId.endsWith(".scss")) {
+      const parts = path2.parse(asset.assetUrl);
+      if (!parts.name.startsWith("_")) {
+        urls.add(asset.assetUrl);
+      }
+    }
+    asset.getImportedModules().forEach((viteModule) => {
+      if (viteModule.id) {
+        const importedAsset = new DevServerAsset(this.assetMap, viteModule);
+        this.collectCss(importedAsset, urls, visited);
+      }
+    });
+  }
+};
+// src/cli/load-config.ts
+import { bundleRequire } from "bundle-require";
+import JoyCon from "joycon";
+async function loadRootConfig(rootDir) {
+  const joycon = new JoyCon();
+  const configPath = await joycon.resolve({
+    cwd: rootDir,
+    files: ["root.config.ts"]
+  });
+  if (configPath) {
+    const configBundle = await bundleRequire({
+      filepath: configPath
+    });
+    return configBundle.mod.default || {};
+  }
+  return {};
+}
+// src/render/html-minify.ts
+import { minify } from "html-minifier-terser";
+async function htmlMinify(html) {
+  const min = await minify(html, {
+    collapseWhitespace: true,
+    removeComments: true,
+    preserveLineBreaks: true
+  });
+  return min.trimStart();
+}
+// src/cli/commands/dev.ts
+var __dirname2 = path3.dirname(fileURLToPath(import.meta.url));
+async function createServer(options) {
+  const app = express();
+  app.use(express.static("public"));
+  const middlewares = await getMiddlewares({ rootDir: options == null ? void 0 : options.rootDir });
+  middlewares.forEach((middleware) => app.use(middleware));
+  const port = parseInt(process.env.PORT || "4007");
+  const version = process.env.npm_package_version || "dev";
+  console.log(`\u{1F333} Root.js v${version}`);
+  console.log();
+  console.log(`Started server: http://localhost:${port}`);
+  app.listen(port);
+}
+async function getMiddlewares(options) {
+  const rootDir = (options == null ? void 0 : options.rootDir) || process.cwd();
+  const rootConfig = await loadRootConfig(rootDir);
+  const viteConfig = rootConfig.vite || {};
+  const renderModulePath = path3.resolve(__dirname2, "./render.js");
+  const viteServer = await createViteServer({
+    ...viteConfig,
+    server: { middlewareMode: true },
+    appType: "custom",
+    optimizeDeps: {
+      include: [renderModulePath]
+    },
+    esbuild: {
+      jsx: "automatic",
+      jsxImportSource: "preact"
+    },
+    plugins: [...viteConfig.plugins || [], vite_plugin_root_default()]
+  });
+  const rootMiddleware = async (req, res, next) => {
+    const url = req.originalUrl;
+    const render = await viteServer.ssrLoadModule(renderModulePath);
+    const renderer = new render.Renderer(rootConfig);
+    try {
+      const assetMap = new DevServerAssetMap(viteServer.moduleGraph);
+      const data = await renderer.render(url, {
+        assetMap
+      });
+      const html = await htmlMinify(await viteServer.transformIndexHtml(url, data.html || ""));
+      res.status(200).set({ "Content-Type": "text/html" }).end(html);
+    } catch (e) {
+      viteServer.ssrFixStacktrace(e);
+      try {
+        const { html } = await renderer.renderError(e);
+        res.status(500).set({ "Content-Type": "text/html" }).end(html);
+      } catch (e2) {
+        console.error("failed to render custom error");
+        console.error(e2);
+        next(e);
+      }
+    }
+  };
+  return [viteServer.middlewares, rootMiddleware];
+}
+function dev(rootDir) {
+  createServer({ rootDir });
+}
+// src/cli/commands/build.ts
+import path6 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import fsExtra2 from "fs-extra";
+import glob2 from "tiny-glob";
+import { build as viteBuild } from "vite";
+// src/render/asset-map/build-asset-map.ts
+import path4 from "path";
+var BuildAssetMap = class {
+  constructor(manifest) {
+    this.manifest = manifest;
+    this.moduleIdToAsset = /* @__PURE__ */ new Map();
+    Object.keys(this.manifest).forEach((manifestKey) => {
+      const moduleId = `/${manifestKey}`;
+      this.moduleIdToAsset.set(moduleId, new BuildAsset(this, moduleId, this.manifest[manifestKey]));
+    });
+  }
+  async get(moduleId) {
+    return this.moduleIdToAsset.get(moduleId) || null;
+  }
+  toJson() {
+    const result = {};
+    for (const moduleId of this.moduleIdToAsset.keys()) {
+      result[moduleId] = this.moduleIdToAsset.get(moduleId).toJson();
+    }
+    return result;
+  }
+};
+var BuildAsset = class {
+  constructor(assetMap, moduleId, manifestData) {
+    this.assetMap = assetMap;
+    this.moduleId = moduleId;
+    this.manifestData = manifestData;
+    this.assetUrl = `/${manifestData.file}`;
+    this.importedModules = (this.manifestData.imports || []).map((relPath) => `/${relPath}`);
+    this.importedCss = (this.manifestData.css || []).map((relPath) => `/${relPath}`);
+  }
+  async getCssDeps() {
+    const visited = /* @__PURE__ */ new Set();
+    const deps = /* @__PURE__ */ new Set();
+    await this.collectCss(this, deps, visited);
+    return Array.from(deps);
+  }
+  async getJsDeps() {
+    const visited = /* @__PURE__ */ new Set();
+    const deps = /* @__PURE__ */ new Set();
+    await this.collectJs(this, deps, visited);
+    return Array.from(deps);
+  }
+  async collectJs(asset, urls, visited) {
+    if (!asset) {
+      return;
+    }
+    if (!asset.moduleId) {
+      return;
+    }
+    if (visited.has(asset.moduleId)) {
+      return;
+    }
+    visited.add(asset.moduleId);
+    const parts = path4.parse(asset.assetUrl);
+    if ([".ts", ".tsx"].includes(parts.ext) && asset.moduleId.includes("/elements/")) {
+      urls.add(asset.assetUrl);
+    }
+    await Promise.all(asset.importedModules.map(async (moduleId) => {
+      const importedAsset = await this.assetMap.get(moduleId);
+      this.collectJs(importedAsset, urls, visited);
+    }));
+  }
+  async collectCss(asset, urls, visited) {
+    if (!asset) {
+      return;
+    }
+    if (!asset.assetUrl) {
+      return;
+    }
+    if (visited.has(asset.moduleId)) {
+      return;
+    }
+    visited.add(asset.moduleId);
+    if (asset.importedCss) {
+      asset.importedCss.forEach((cssUrl) => urls.add(cssUrl));
+    }
+    await Promise.all(asset.importedModules.map(async (moduleId) => {
+      const importedAsset = await this.assetMap.get(moduleId);
+      this.collectCss(importedAsset, urls, visited);
+    }));
+  }
+  toJson() {
+    return {
+      moduleId: this.moduleId,
+      assetUrl: this.assetUrl,
+      importedModules: this.importedModules,
+      importedCss: this.importedCss
+    };
+  }
+};
+// src/core/fsutils.ts
+import { promises as fs } from "node:fs";
+import path5 from "node:path";
+import fsExtra from "fs-extra";
+function isJsFile2(file) {
+  return !!file.match(/\.(j|t)sx?$/);
+}
+async function writeFile(filePath, content) {
+  const dirPath = path5.dirname(filePath);
+  await makeDir(dirPath);
+  await fs.writeFile(filePath, content);
+}
+async function makeDir(dirPath) {
+  try {
+    await fs.access(dirPath);
+  } catch (e) {
+    await fs.mkdir(dirPath, { recursive: true });
+  }
+}
+async function copyDir(srcDir, dstDir) {
+  if (!fsExtra.existsSync(srcDir)) {
+    return;
+  }
+  fsExtra.copySync(srcDir, dstDir, { recursive: true, overwrite: true });
+}
+async function rmDir(dirPath) {
+  await fs.rm(dirPath, { recursive: true, force: true });
+}
+async function loadJson(filePath) {
+  const content = await fs.readFile(filePath, "utf-8");
+  return JSON.parse(content);
+}
+async function isDirectory(dirPath) {
+  return fs.stat(dirPath).then((fsStat) => {
+    return fsStat.isDirectory();
+  }).catch((err) => {
+    if (err.code === "ENOENT") {
+      return false;
+    }
+    throw err;
+  });
+}
+// src/cli/commands/build.ts
+var __dirname3 = path6.dirname(fileURLToPath2(import.meta.url));
+async function build(rootDir) {
+  const version = process.env.npm_package_version || "dev";
+  console.log(`\u{1F333} Root.js v${version}`);
+  if (!rootDir) {
+    rootDir = process.cwd();
+  }
+  const rootConfig = await loadRootConfig(rootDir);
+  const distDir = path6.join(rootDir, "dist");
+  await rmDir(distDir);
+  await makeDir(distDir);
+  const pages = [];
+  if (await isDirectory(path6.join(rootDir, "routes"))) {
+    const pageFiles = await glob2(path6.join(rootDir, "routes/**/*"));
+    pageFiles.forEach((file) => {
+      const parts = path6.parse(file);
+      if (!parts.name.startsWith("_") && isJsFile2(parts.base)) {
+        pages.push(file);
+      }
+    });
+  }
+  const elements = [];
+  if (await isDirectory(path6.join(rootDir, "elements"))) {
+    const elementFiles = await glob2(path6.join(rootDir, "elements/**/*"));
+    elementFiles.forEach((file) => {
+      const parts = path6.parse(file);
+      if (isJsFile2(parts.base)) {
+        elements.push(file);
+      }
+    });
+  }
+  const bundleScripts = [];
+  if (await isDirectory(path6.join(rootDir, "bundles"))) {
+    const bundleFiles = await glob2(path6.join(rootDir, "bundles/*"));
+    bundleFiles.forEach((file) => {
+      const parts = path6.parse(file);
+      if (isJsFile2(parts.base)) {
+        bundleScripts.push(file);
+      }
+    });
+  }
+  const viteConfig = rootConfig.vite || {};
+  const baseConfig = {
+    ...viteConfig,
+    root: rootDir,
+    esbuild: {
+      jsxFactory: "h",
+      jsxFragment: "Fragment",
+      jsxInject: 'import {h, Fragment} from "preact";'
+    },
+    plugins: [...viteConfig.plugins || [], pluginRoot()]
+  };
+  await viteBuild({
+    ...baseConfig,
+    mode: "production",
+    publicDir: false,
+    build: {
+      rollupOptions: {
+        input: [path6.resolve(__dirname3, "./render.js")],
+        output: {
+          format: "esm",
+          chunkFileNames: "chunks/[name].[hash].js",
+          assetFileNames: "assets/[name].[hash][extname]"
+        }
+      },
+      outDir: path6.join(distDir, "server"),
+      ssr: true,
+      ssrManifest: false,
+      cssCodeSplit: true,
+      target: "esnext",
+      minify: false,
+      polyfillModulePreload: false,
+      reportCompressedSize: false
+    }
+  });
+  await viteBuild({
+    ...baseConfig,
+    mode: "production",
+    publicDir: false,
+    build: {
+      rollupOptions: {
+        input: [...pages, ...elements, ...bundleScripts],
+        output: {
+          format: "esm",
+          chunkFileNames: "chunks/[name].[hash].js",
+          assetFileNames: "assets/[name].[hash][extname]"
+        }
+      },
+      outDir: path6.join(distDir, "client"),
+      ssr: false,
+      ssrManifest: false,
+      manifest: true,
+      cssCodeSplit: true,
+      target: "esnext",
+      minify: true,
+      polyfillModulePreload: false,
+      reportCompressedSize: false
+    }
+  });
+  const manifest = await loadJson(path6.join(distDir, "client/manifest.json"));
+  const assetMap = new BuildAssetMap(manifest);
+  writeFile(path6.join(distDir, "client/root-manifest.json"), JSON.stringify(assetMap.toJson(), null, 2));
+  const buildDir = path6.join(distDir, "html");
+  const publicDir = path6.join(rootDir, "public");
+  if (fsExtra2.existsSync(path6.join(rootDir, "public"))) {
+    fsExtra2.copySync(publicDir, buildDir);
+  } else {
+    makeDir(buildDir);
+  }
+  copyDir(path6.join(distDir, "client/assets"), path6.join(buildDir, "assets"));
+  copyDir(path6.join(distDir, "client/chunks"), path6.join(buildDir, "chunks"));
+  const render = await import(path6.join(distDir, "server/render.js"));
+  const renderer = new render.Renderer(rootConfig);
+  const sitemap = await renderer.getSitemap();
+  await Promise.all(Object.keys(sitemap).map(async (urlPath) => {
+    const { route, params } = sitemap[urlPath];
+    const data = await renderer.renderRoute(route, {
+      assetMap,
+      routeParams: params
+    });
+    let outPath = path6.join(distDir, `html${urlPath}`, "index.html");
+    if (outPath.endsWith("404/index.html")) {
+      outPath = outPath.replace("404/index.html", "404.html");
+    }
+    const html = await htmlMinify(data.html || "");
+    await writeFile(outPath, html);
+    const relPath = outPath.slice(path6.dirname(distDir).length + 1);
+    console.log(`saved ${relPath}`);
+  }));
+}
+// src/cli/commands/start.ts
+async function start(rootDir) {
+  console.log("SSR production server is coming soon");
+}
+export {
+  build,
+  dev,
+  start
+};
+//# sourceMappingURL=cli.js.map