@blinkk/root 3.0.1-alpha.0 → 3.0.1-beta.2

package/dist/chunk-PVBPP5LN.js

@@ -0,0 +1,854 @@
+import {
+  getVitePlugins
+} from "./chunk-XSNCF7WU.js";
+
+// src/node/monorepo.ts
+import path2 from "path";
+import { getWorkspaces, getWorkspaceRoot } from "workspace-tools";
+
+// src/utils/fsutils.ts
+import fs from "fs";
+import path from "path";
+import fsExtra from "fs-extra";
+import glob from "tiny-glob";
+function isJsFile(filename) {
+  return !!filename.match(/\.(j|t)sx?$/);
+}
+async function writeFile(filepath, content) {
+  const dirPath = path.dirname(filepath);
+  await makeDir(dirPath);
+  await fs.promises.writeFile(filepath, content);
+}
+async function makeDir(dirpath) {
+  try {
+    await fs.promises.access(dirpath);
+  } catch (e) {
+    await fs.promises.mkdir(dirpath, { recursive: true });
+  }
+}
+async function copyDir(srcdir, dstdir) {
+  if (!fsExtra.existsSync(srcdir)) {
+    return;
+  }
+  fsExtra.copySync(srcdir, dstdir, { overwrite: true });
+}
+async function copyGlob(pattern, srcdir, dstdir) {
+  const files = await glob(pattern, { cwd: srcdir });
+  if (files.length > 0) {
+    await makeDir(dstdir);
+  }
+  files.forEach((file) => {
+    fsExtra.copySync(path.resolve(srcdir, file), path.resolve(dstdir, file));
+  });
+}
+async function rmDir(dirpath) {
+  await fs.promises.rm(dirpath, { recursive: true, force: true });
+}
+async function loadJson(filepath) {
+  const content = await fs.promises.readFile(filepath, "utf-8");
+  return JSON.parse(content);
+}
+function loadJsonSync(filepath) {
+  const content = fs.readFileSync(filepath, "utf-8");
+  return JSON.parse(content);
+}
+async function writeJson(filepath, data) {
+  const content = JSON.stringify(data, null, 2);
+  await writeFile(filepath, content);
+}
+async function isDirectory(dirpath) {
+  return fs.promises.stat(dirpath).then((fsStat) => {
+    return fsStat.isDirectory();
+  }).catch((err) => {
+    if (err.code === "ENOENT") {
+      return false;
+    }
+    throw err;
+  });
+}
+function fileExists(filepath) {
+  return fs.promises.access(filepath).then(() => true).catch(() => false);
+}
+function fileExistsSync(filepath) {
+  try {
+    fs.accessSync(filepath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function dirExists(dirpath) {
+  try {
+    const stat = await fs.promises.stat(dirpath);
+    return stat.isDirectory();
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+async function directoryContains(dirpath, subpath) {
+  const outer = await fs.promises.realpath(dirpath);
+  const inner = await fs.promises.realpath(subpath);
+  const rel = path.relative(outer, inner);
+  return !rel.startsWith("..");
+}
+
+// src/node/monorepo.ts
+function loadPackageJson(filepath) {
+  if (!fileExistsSync(filepath)) {
+    return null;
+  }
+  return loadJsonSync(filepath);
+}
+function getMonorepoPackages(rootDir) {
+  const monorepoRoot = getWorkspaceRoot(rootDir);
+  if (!monorepoRoot) {
+    return {};
+  }
+  const workspaces = getWorkspaces(monorepoRoot);
+  const packages = {};
+  workspaces.forEach((workspaceInfo) => {
+    packages[workspaceInfo.name] = workspaceInfo;
+  });
+  return packages;
+}
+function getMonorepoPackageDeps(rootDir) {
+  const monorepoRoot = getWorkspaceRoot(rootDir);
+  if (!monorepoRoot) {
+    return {};
+  }
+  const packageJsonPath = path2.join(monorepoRoot, "package.json");
+  const packageJson = loadPackageJson(packageJsonPath);
+  return packageJson?.dependencies || {};
+}
+function flattenPackageDepsFromMonorepo(rootDir, options) {
+  const packageJsonPath = path2.resolve(rootDir, "package.json");
+  const packageJson = loadPackageJson(packageJsonPath);
+  const monorepoDeps = getMonorepoPackageDeps(rootDir);
+  const projectDeps = {
+    ...packageJson?.peerDependencies,
+    ...packageJson?.dependencies
+  };
+  const allDeps = {};
+  const workspacePackages = getMonorepoPackages(rootDir);
+  const ignore = options?.ignore || /* @__PURE__ */ new Set();
+  Object.entries(projectDeps).forEach(([depName, depVersion]) => {
+    if (depName.startsWith("@blinkk/root") && depVersion.startsWith("workspace:")) {
+      const packageInfo = workspacePackages[depName];
+      if (packageInfo) {
+        allDeps[depName] = packageInfo.packageJson.version;
+      }
+    } else if (depVersion.startsWith("workspace:")) {
+      if (ignore.has(depName)) {
+        return;
+      }
+      ignore.add(depName);
+      const packageInfo = workspacePackages[depName];
+      if (packageInfo) {
+        const workspacePackageDir = packageInfo.path;
+        const deps = flattenPackageDepsFromMonorepo(workspacePackageDir, {
+          ignore
+        });
+        for (const key in deps) {
+          const currentValue = allDeps[key];
+          if (deps[key] && deps[key] !== "*" && (!currentValue || currentValue === "*")) {
+            allDeps[key] = deps[key];
+          }
+        }
+      }
+    } else if (depVersion === "*" && monorepoDeps[depName]) {
+      allDeps[depName] = monorepoDeps[depName];
+    } else {
+      allDeps[depName] = depVersion;
+    }
+  });
+  return sortDeps(allDeps);
+}
+function sortDeps(deps) {
+  const keys = Object.keys(deps).sort();
+  const sortedDeps = {};
+  for (const key of keys) {
+    sortedDeps[key] = deps[key];
+  }
+  return sortedDeps;
+}
+
+// src/node/load-config.ts
+import path3 from "path";
+import { bundleRequire } from "bundle-require";
+import { build } from "esbuild";
+async function loadRootConfig(rootDir, options) {
+  const { rootConfig } = await loadRootConfigWithDeps(rootDir, options);
+  return rootConfig;
+}
+async function loadRootConfigWithDeps(rootDir, options) {
+  const configPath = path3.resolve(rootDir, "root.config.ts");
+  const exists = await fileExists(configPath);
+  if (!exists) {
+    throw new Error(`${configPath} does not exist`);
+  }
+  const configBundle = await bundleRequire({
+    filepath: configPath,
+    esbuildOptions: { plugins: [esbuildExternalsPlugin({ rootDir })] }
+  });
+  let config = configBundle.mod.default || {};
+  if (typeof config === "function") {
+    config = await config(options) || {};
+  }
+  const rootConfig = Object.assign({}, config, { rootDir });
+  validateRootconfig(rootConfig);
+  return { rootConfig, dependencies: configBundle.dependencies };
+}
+function validateRootconfig(rootConfig) {
+  const scss = rootConfig.vite?.css?.preprocessorOptions?.scss;
+  if (scss?.includePaths) {
+    console.warn(
+      '[deprecation warning] root.config.ts: vite.css.preprocessorOptions.scss.includePaths is deprecated. rename "includePaths" -> "loadPaths"'
+    );
+    scss.loadPaths = scss.includePaths;
+  }
+}
+async function bundleRootConfig(rootDir, outPath) {
+  const configPath = path3.resolve(rootDir, "root.config.ts");
+  const configExists = await fileExists(configPath);
+  if (!configExists) {
+    throw new Error(`${configPath} does not exist`);
+  }
+  await build({
+    entryPoints: [configPath],
+    bundle: true,
+    minify: true,
+    platform: "node",
+    outfile: outPath,
+    sourcemap: "inline",
+    metafile: true,
+    format: "esm",
+    plugins: [esbuildExternalsPlugin({ rootDir })]
+  });
+}
+async function loadBundledConfig(rootDir, options) {
+  const configPath = path3.resolve(rootDir, "dist/root.config.js");
+  const exists = await fileExists(configPath);
+  if (!exists) {
+    throw new Error(`${configPath} does not exist`);
+  }
+  const module = await import(configPath);
+  let config = module.default || {};
+  if (typeof config === "function") {
+    config = await config(options) || {};
+  }
+  return Object.assign({}, config, { rootDir });
+}
+function esbuildExternalsPlugin(options) {
+  const rootDir = options.rootDir;
+  const allDeps = flattenPackageDepsFromMonorepo(rootDir);
+  function getPackageName(id) {
+    const segments = id.split("/");
+    if (segments.length > 1) {
+      if (segments[0].startsWith("@") && segments[0].length > 1) {
+        return `${segments[0]}/${segments[1]}`;
+      }
+      return segments[0];
+    }
+    return id;
+  }
+  return {
+    name: "root-externals-plugin",
+    setup(build2) {
+      build2.onResolve({ filter: /.*/ }, (args) => {
+        const id = args.path;
+        if (id[0] !== "." && !id.startsWith("@/")) {
+          const packageName = getPackageName(id);
+          if (packageName in allDeps) {
+            return {
+              external: true
+            };
+          }
+        }
+        return null;
+      });
+    }
+  };
+}
+
+// src/node/pod-collector.ts
+import path4 from "path";
+import glob2 from "tiny-glob";
+var cachedPods = null;
+function invalidatePodCache() {
+  cachedPods = null;
+}
+async function collectPods(rootConfig) {
+  if (cachedPods) {
+    return cachedPods;
+  }
+  const plugins = rootConfig.plugins || [];
+  const userPodConfigs = rootConfig.pods || {};
+  const rawPods = await resolvePluginPods(plugins, rootConfig);
+  const resolved = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  for (const pod of rawPods) {
+    if (seenNames.has(pod.name)) {
+      throw new Error(
+        `Duplicate pod name: "${pod.name}". Each pod must have a unique name.`
+      );
+    }
+    seenNames.add(pod.name);
+    const userConfig = userPodConfigs[pod.name] || {};
+    if (userConfig.enabled === false) {
+      continue;
+    }
+    const resolvedPod = await resolvePod(pod, userConfig, rootConfig);
+    resolved.push(resolvedPod);
+  }
+  validateCollectionIds(resolved, rootConfig);
+  cachedPods = resolved;
+  return resolved;
+}
+async function resolvePluginPods(plugins, rootConfig) {
+  const pods = [];
+  for (const plugin of plugins) {
+    if (!plugin.pod) {
+      continue;
+    }
+    if (typeof plugin.pod === "function") {
+      const result = await plugin.pod({ rootConfig });
+      pods.push(result);
+    } else if (Array.isArray(plugin.pod)) {
+      pods.push(...plugin.pod);
+    } else {
+      pods.push(plugin.pod);
+    }
+  }
+  return pods;
+}
+async function resolvePod(pod, userConfig, rootConfig) {
+  const mount = normalizeMountPath(userConfig.mount ?? pod.mount ?? "/");
+  const priority = userConfig.priority ?? pod.priority ?? 0;
+  const routeFiles = pod.routesDir ? await scanRouteFiles(pod.routesDir, mount, userConfig, rootConfig) : [];
+  const bundleFiles = pod.bundlesDir ? await scanBundleFiles(pod.bundlesDir) : [];
+  const collectionFiles = pod.collectionsDir ? await scanCollectionFiles(pod.collectionsDir, userConfig) : [];
+  const translationFiles = pod.translationsDir ? await scanTranslationFiles(pod.translationsDir) : [];
+  return {
+    name: pod.name,
+    enabled: true,
+    mount,
+    priority,
+    routesDir: pod.routesDir,
+    elementsDirs: pod.elementsDirs || [],
+    bundlesDir: pod.bundlesDir,
+    collectionsDir: pod.collectionsDir,
+    translationsDir: pod.translationsDir,
+    routeFiles,
+    bundleFiles,
+    collectionFiles,
+    translationFiles,
+    config: userConfig
+  };
+}
+async function scanRouteFiles(routesDir, mount, userConfig, rootConfig) {
+  if (!await isDirectory(routesDir)) {
+    return [];
+  }
+  const files = await glob2("**/*", { cwd: routesDir });
+  const routes = [];
+  const excludePatterns = userConfig.routes?.exclude || [];
+  for (const file of files) {
+    const parts = path4.parse(file);
+    if (parts.name.startsWith("_") || !isJsFile(parts.base)) {
+      continue;
+    }
+    if (shouldExclude(file, excludePatterns)) {
+      continue;
+    }
+    const filePath = path4.join(routesDir, file);
+    let relativeRoutePath = "/" + file.replace(/\\/g, "/");
+    const routeParts = path4.parse(relativeRoutePath);
+    if (routeParts.name === "index") {
+      relativeRoutePath = routeParts.dir;
+    } else {
+      relativeRoutePath = path4.join(routeParts.dir, routeParts.name);
+    }
+    relativeRoutePath = relativeRoutePath.replace(/\\/g, "/");
+    const routePath = normalizeRoutePath(mount, relativeRoutePath, rootConfig);
+    routes.push({ filePath, relPath: file, routePath });
+  }
+  return routes;
+}
+async function scanBundleFiles(bundlesDir) {
+  if (!await isDirectory(bundlesDir)) {
+    return [];
+  }
+  const files = await glob2("*", { cwd: bundlesDir });
+  return files.filter((file) => isJsFile(path4.parse(file).base)).map((file) => path4.join(bundlesDir, file));
+}
+async function scanCollectionFiles(collectionsDir, userConfig) {
+  if (!await isDirectory(collectionsDir)) {
+    return [];
+  }
+  const files = await glob2("**/*.schema.ts", { cwd: collectionsDir });
+  const excludeIds = new Set(userConfig.collections?.exclude || []);
+  const renameMap = userConfig.collections?.rename || {};
+  const collections = [];
+  for (const file of files) {
+    const parts = path4.parse(file);
+    const rawId = parts.name.replace(".schema", "");
+    if (excludeIds.has(rawId)) {
+      continue;
+    }
+    const id = renameMap[rawId] || rawId;
+    collections.push({
+      filePath: path4.join(collectionsDir, file),
+      relPath: file,
+      id
+    });
+  }
+  return collections;
+}
+async function scanTranslationFiles(translationsDir) {
+  if (!await isDirectory(translationsDir)) {
+    return [];
+  }
+  const files = await glob2("*.json", { cwd: translationsDir });
+  return files.map((file) => ({
+    locale: path4.parse(file).name,
+    filePath: path4.join(translationsDir, file)
+  }));
+}
+function validateCollectionIds(pods, rootConfig) {
+  const seenIds = /* @__PURE__ */ new Map();
+  for (const pod of pods) {
+    for (const col of pod.collectionFiles) {
+      const existing = seenIds.get(col.id);
+      if (existing) {
+        throw new Error(
+          `Collection "${col.id}" is defined by both "${existing}" and "${pod.name}". Use rootConfig.pods['${pod.name}'].collections.rename to disambiguate.`
+        );
+      }
+      seenIds.set(col.id, pod.name);
+    }
+  }
+}
+function normalizeMountPath(mount) {
+  if (!mount.startsWith("/")) {
+    mount = "/" + mount;
+  }
+  if (mount.endsWith("/") && mount.length > 1) {
+    mount = mount.slice(0, -1);
+  }
+  return mount;
+}
+function normalizeRoutePath(mount, relativeRoutePath, rootConfig) {
+  const basePath = rootConfig.base || "/";
+  let fullPath;
+  if (mount === "/") {
+    fullPath = relativeRoutePath || "/";
+  } else {
+    fullPath = mount + (relativeRoutePath || "");
+  }
+  if (basePath !== "/") {
+    const base = basePath.replace(/^\/|\/$/g, "");
+    fullPath = `/${base}${fullPath}`;
+  }
+  fullPath = fullPath.replace(/\/+/g, "/");
+  if (!fullPath.startsWith("/")) {
+    fullPath = "/" + fullPath;
+  }
+  return fullPath || "/";
+}
+function shouldExclude(filePath, patterns) {
+  for (const pattern of patterns) {
+    if (typeof pattern === "string") {
+      if (filePath.includes(pattern)) {
+        return true;
+      }
+    } else {
+      if (pattern.test(filePath)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+// src/node/vite.ts
+import { createServer } from "vite";
+
+// src/node/pods-vite-plugin.ts
+import path5 from "path";
+import glob3 from "tiny-glob";
+var VIRTUAL_ROUTES_ID = "virtual:root/routes";
+var VIRTUAL_SCHEMAS_ID = "virtual:root/schemas";
+var VIRTUAL_TRANSLATIONS_ID = "virtual:root/translations";
+var RESOLVED_VIRTUAL_ROUTES = "\0" + VIRTUAL_ROUTES_ID;
+var RESOLVED_VIRTUAL_SCHEMAS = "\0" + VIRTUAL_SCHEMAS_ID;
+var RESOLVED_VIRTUAL_TRANSLATIONS = "\0" + VIRTUAL_TRANSLATIONS_ID;
+function rootPodsVitePlugin(rootConfig) {
+  let podsPromise = null;
+  const getPods = () => {
+    if (!podsPromise) {
+      podsPromise = collectPods(rootConfig);
+    }
+    return podsPromise;
+  };
+  return {
+    name: "root:pods",
+    enforce: "pre",
+    resolveId(id) {
+      if (id === VIRTUAL_ROUTES_ID) return RESOLVED_VIRTUAL_ROUTES;
+      if (id === VIRTUAL_SCHEMAS_ID) return RESOLVED_VIRTUAL_SCHEMAS;
+      if (id === VIRTUAL_TRANSLATIONS_ID) return RESOLVED_VIRTUAL_TRANSLATIONS;
+      return null;
+    },
+    async load(id) {
+      if (id === RESOLVED_VIRTUAL_ROUTES) {
+        return buildRoutesModule(rootConfig, await getPods());
+      }
+      if (id === RESOLVED_VIRTUAL_SCHEMAS) {
+        return buildSchemasModule(rootConfig, await getPods());
+      }
+      if (id === RESOLVED_VIRTUAL_TRANSLATIONS) {
+        return buildTranslationsModule(rootConfig, await getPods());
+      }
+      return null;
+    },
+    configureServer(server) {
+      const watchDirs = [];
+      getPods().then((pods) => {
+        for (const pod of pods) {
+          if (pod.routesDir) watchDirs.push(pod.routesDir);
+          if (pod.collectionsDir) watchDirs.push(pod.collectionsDir);
+          if (pod.translationsDir) watchDirs.push(pod.translationsDir);
+          if (pod.bundlesDir) watchDirs.push(pod.bundlesDir);
+          for (const dir of pod.elementsDirs) {
+            watchDirs.push(dir);
+          }
+        }
+        for (const dir of watchDirs) {
+          server.watcher.add(dir);
+        }
+      });
+      const invalidateVirtualModules = () => {
+        invalidatePodCache();
+        podsPromise = null;
+        const mods = [
+          RESOLVED_VIRTUAL_ROUTES,
+          RESOLVED_VIRTUAL_SCHEMAS,
+          RESOLVED_VIRTUAL_TRANSLATIONS
+        ];
+        for (const modId of mods) {
+          const mod = server.moduleGraph.getModuleById(modId);
+          if (mod) {
+            server.moduleGraph.invalidateModule(mod);
+          }
+        }
+        server.ws.send({ type: "full-reload" });
+      };
+      server.watcher.on("add", (filePath) => {
+        if (isInPodDir(filePath, watchDirs)) {
+          invalidateVirtualModules();
+        }
+      });
+      server.watcher.on("unlink", (filePath) => {
+        if (isInPodDir(filePath, watchDirs)) {
+          invalidateVirtualModules();
+        }
+      });
+    }
+  };
+}
+function isInPodDir(filePath, watchDirs) {
+  for (const dir of watchDirs) {
+    if (filePath.startsWith(dir)) {
+      return true;
+    }
+  }
+  return false;
+}
+async function buildRoutesModule(rootConfig, pods) {
+  const rootDir = rootConfig.rootDir;
+  const imports = [];
+  const userEntries = [];
+  const podEntries = [];
+  let idx = 0;
+  const routesDir = path5.join(rootDir, "routes");
+  if (await isDirectory(routesDir)) {
+    const files = await glob3("**/*", { cwd: routesDir });
+    for (const file of files) {
+      const parts = path5.parse(file);
+      if (parts.name.startsWith("_") || !isJsFile(parts.base)) {
+        continue;
+      }
+      const modulePath = `/routes/${file.replace(/\\/g, "/")}`;
+      const varName = `_r${idx++}`;
+      imports.push(`import * as ${varName} from '${modulePath}';`);
+      userEntries.push(`  '${modulePath}': ${varName},`);
+    }
+  }
+  for (const pod of pods) {
+    for (const route of pod.routeFiles) {
+      const varName = `_r${idx++}`;
+      imports.push(`import * as ${varName} from '${route.filePath}';`);
+      podEntries.push(
+        `  '${route.filePath}': {module: ${varName}, podName: ${JSON.stringify(pod.name)}, routePath: ${JSON.stringify(route.routePath)}, src: ${JSON.stringify(`pod/${pod.name}/${route.relPath}`)}},`
+      );
+    }
+  }
+  return [
+    ...imports,
+    "",
+    "export const ROUTE_MODULES = {",
+    ...userEntries,
+    "};",
+    "",
+    "export const POD_ROUTE_MODULES = {",
+    ...podEntries,
+    "};"
+  ].join("\n");
+}
+async function buildSchemasModule(rootConfig, pods) {
+  const rootDir = rootConfig.rootDir;
+  const imports = [];
+  const entries = [];
+  let idx = 0;
+  const userCollectionIds = /* @__PURE__ */ new Set();
+  const collectionsDir = path5.join(rootDir, "collections");
+  if (await isDirectory(collectionsDir)) {
+    const files = await glob3("**/*.schema.ts", { cwd: collectionsDir });
+    for (const file of files) {
+      const parts = path5.parse(file);
+      const id = parts.name.replace(".schema", "");
+      userCollectionIds.add(id);
+      const modulePath = `/collections/${file.replace(/\\/g, "/")}`;
+      const varName = `_s${idx++}`;
+      imports.push(`import * as ${varName} from '${modulePath}';`);
+      entries.push(`  '${modulePath}': ${varName},`);
+    }
+  }
+  const rootSchemaFiles = await scanRootSchemaFiles(rootDir);
+  for (const file of rootSchemaFiles) {
+    const modulePath = `/${file.replace(/\\/g, "/")}`;
+    if (modulePath.startsWith("/collections/")) continue;
+    const varName = `_s${idx++}`;
+    imports.push(`import * as ${varName} from '${modulePath}';`);
+    entries.push(`  '${modulePath}': ${varName},`);
+  }
+  for (const pod of pods) {
+    for (const col of pod.collectionFiles) {
+      if (userCollectionIds.has(col.id)) {
+        continue;
+      }
+      const varName = `_s${idx++}`;
+      imports.push(`import * as ${varName} from '${col.filePath}';`);
+      const key = `/collections/${col.id}.schema.ts`;
+      entries.push(`  '${key}': ${varName},`);
+    }
+  }
+  return [
+    ...imports,
+    "",
+    "export const SCHEMA_MODULES = {",
+    ...entries,
+    "};"
+  ].join("\n");
+}
+async function scanRootSchemaFiles(rootDir) {
+  const excludeDirs = ["appengine", "functions", "gae", "node_modules", "dist"];
+  let files;
+  try {
+    files = await glob3("**/*.schema.ts", { cwd: rootDir });
+  } catch {
+    return [];
+  }
+  return files.filter((file) => {
+    const normalized = file.replace(/\\/g, "/");
+    return !excludeDirs.some((dir) => normalized.startsWith(dir + "/"));
+  });
+}
+async function buildTranslationsModule(rootConfig, pods) {
+  const rootDir = rootConfig.rootDir;
+  const imports = [];
+  const entries = [];
+  let idx = 0;
+  const userLocales = /* @__PURE__ */ new Set();
+  const translationsDir = path5.join(rootDir, "translations");
+  if (await isDirectory(translationsDir)) {
+    const files = await glob3("*.json", { cwd: translationsDir });
+    for (const file of files) {
+      const locale = path5.parse(file).name;
+      userLocales.add(locale);
+      const modulePath = `/translations/${file}`;
+      const varName = `_t${idx++}`;
+      imports.push(`import ${varName} from '${modulePath}';`);
+      entries.push(`  '${modulePath}': {default: ${varName}},`);
+    }
+  }
+  for (const pod of pods) {
+    for (const t of pod.translationFiles) {
+      const varName = `_t${idx++}`;
+      imports.push(`import ${varName} from '${t.filePath}';`);
+      const key = `/translations/pod:${pod.name}:${t.locale}.json`;
+      entries.push(`  '${key}': {default: ${varName}},`);
+    }
+  }
+  return [
+    ...imports,
+    "",
+    "export const TRANSLATION_MODULES = {",
+    ...entries,
+    "};"
+  ].join("\n");
+}
+
+// src/node/vite-plugin-root-jsx-virtual.ts
+function preactToRootJsxPlugin(options) {
+  const useRootJsx = options?.useRootJsx ?? false;
+  const SSR_REDIRECTS = {
+    preact: "@blinkk/root/jsx",
+    "preact/hooks": "@blinkk/root/jsx",
+    "preact/jsx-runtime": "@blinkk/root/jsx/jsx-runtime",
+    "preact/jsx-dev-runtime": "@blinkk/root/jsx/jsx-dev-runtime"
+  };
+  return {
+    name: "root:preact-to-jsx",
+    async resolveId(id, importer, resolveOptions) {
+      if (!useRootJsx) {
+        return null;
+      }
+      const ssrTarget = SSR_REDIRECTS[id];
+      if (!ssrTarget) {
+        return null;
+      }
+      const isSSR = this.environment?.name === "ssr";
+      if (!isSSR) {
+        return null;
+      }
+      const resolved = await this.resolve(ssrTarget, importer, {
+        ...resolveOptions,
+        skipSelf: true
+      });
+      return resolved;
+    }
+  };
+}
+
+// src/node/vite.ts
+async function createViteServer(rootConfig, options) {
+  const rootDir = rootConfig.rootDir;
+  const viteConfig = rootConfig.vite || {};
+  let hmrOptions = viteConfig.server?.hmr;
+  if (options?.hmr === false) {
+    hmrOptions = false;
+  } else if (typeof hmrOptions === "undefined" && options?.port) {
+    hmrOptions = { port: options.port + 10 };
+  }
+  const viteServer = await createServer({
+    ...viteConfig,
+    mode: "development",
+    root: rootDir,
+    // publicDir is disabled from the vite dev server since it's handled by the
+    // root dev server directly, which allows user middlewares to override
+    // files in the public dir.
+    publicDir: false,
+    server: {
+      ...viteConfig.server || {},
+      middlewareMode: true,
+      hmr: hmrOptions
+    },
+    appType: "custom",
+    optimizeDeps: {
+      ...viteConfig.optimizeDeps || {},
+      include: [
+        ...options?.optimizeDeps || [],
+        ...viteConfig.optimizeDeps?.include || []
+      ],
+      extensions: [...viteConfig.optimizeDeps?.extensions || [], ".tsx"]
+    },
+    ssr: {
+      ...viteConfig.ssr || {},
+      noExternal: ["@blinkk/root", "@blinkk/root-cms/richtext", /^virtual:/]
+    },
+    plugins: [
+      rootPodsVitePlugin(rootConfig),
+      hmrSSRReload(),
+      preactToRootJsxPlugin({ useRootJsx: !!rootConfig.jsxRenderer?.mode }),
+      ...viteConfig.plugins || [],
+      ...getVitePlugins(rootConfig.plugins || [])
+    ]
+  });
+  return viteServer;
+}
+async function viteSsrLoadModule(rootConfig, file) {
+  const viteServer = await createViteServer(rootConfig, { hmr: false });
+  const module = await viteServer.ssrLoadModule(file);
+  await viteServer.close();
+  return module;
+}
+function hmrSSRReload() {
+  return {
+    name: "hmr-ssr-reload",
+    enforce: "post",
+    hotUpdate: {
+      order: "post",
+      handler({ modules, server, timestamp }) {
+        if (this.environment.name !== "ssr") {
+          return;
+        }
+        let hasSsrOnlyModules = false;
+        const invalidatedModules = /* @__PURE__ */ new Set();
+        for (const mod of modules) {
+          if (mod.id === null) {
+            continue;
+          }
+          const clientModule = server.environments.client.moduleGraph.getModuleById(mod.id);
+          if (clientModule) {
+            continue;
+          }
+          hasSsrOnlyModules = true;
+          this.environment.moduleGraph.invalidateModule(
+            mod,
+            invalidatedModules,
+            timestamp,
+            true
+          );
+        }
+        if (hasSsrOnlyModules) {
+          server.ws.send({ type: "full-reload" });
+          return [];
+        }
+        return;
+      }
+    }
+  };
+}
+
+export {
+  isJsFile,
+  writeFile,
+  makeDir,
+  copyDir,
+  copyGlob,
+  rmDir,
+  loadJson,
+  writeJson,
+  isDirectory,
+  fileExists,
+  dirExists,
+  directoryContains,
+  loadPackageJson,
+  getMonorepoPackageDeps,
+  flattenPackageDepsFromMonorepo,
+  loadRootConfig,
+  loadRootConfigWithDeps,
+  bundleRootConfig,
+  loadBundledConfig,
+  invalidatePodCache,
+  collectPods,
+  rootPodsVitePlugin,
+  preactToRootJsxPlugin,
+  createViteServer,
+  viteSsrLoadModule
+};
+//# sourceMappingURL=chunk-PVBPP5LN.js.map