@flexireact/core 3.0.2 → 3.0.4

package/dist/core/build/index.js

@@ -0,0 +1,689 @@
+// core/build/index.ts
+import * as esbuild from "esbuild";
+import fs3 from "fs";
+import path3 from "path";
+import { fileURLToPath } from "url";
+
+// core/utils.ts
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+function generateHash(content) {
+  return crypto.createHash("md5").update(content).digest("hex").slice(0, 8);
+}
+function findFiles(dir, pattern, files = []) {
+  if (!fs.existsSync(dir)) return files;
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      findFiles(fullPath, pattern, files);
+    } else if (pattern.test(entry.name)) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+function cleanDir(dir) {
+  if (fs.existsSync(dir)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+  fs.mkdirSync(dir, { recursive: true });
+}
+function isServerComponent(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const firstLine = content.split("\n")[0].trim();
+    return firstLine === "'use server'" || firstLine === '"use server"';
+  } catch {
+    return false;
+  }
+}
+function isClientComponent(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const firstLine = content.split("\n")[0].trim();
+    return firstLine === "'use client'" || firstLine === '"use client"';
+  } catch {
+    return false;
+  }
+}
+function isIsland(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const firstLine = content.split("\n")[0].trim();
+    return firstLine === "'use island'" || firstLine === '"use island"';
+  } catch {
+    return false;
+  }
+}
+
+// core/router/index.ts
+import fs2 from "fs";
+import path2 from "path";
+var RouteType = {
+  PAGE: "page",
+  API: "api",
+  LAYOUT: "layout",
+  LOADING: "loading",
+  ERROR: "error",
+  NOT_FOUND: "not-found"
+};
+function buildRouteTree(pagesDir, layoutsDir, appDir = null, routesDir = null) {
+  const projectRoot = path2.dirname(pagesDir);
+  const routes = {
+    pages: [],
+    api: [],
+    layouts: /* @__PURE__ */ new Map(),
+    tree: {},
+    appRoutes: [],
+    // Next.js style app router routes
+    flexiRoutes: []
+    // FlexiReact v2 routes/ directory
+  };
+  const routesDirPath = routesDir || path2.join(projectRoot, "routes");
+  if (fs2.existsSync(routesDirPath)) {
+    scanRoutesDirectory(routesDirPath, routesDirPath, routes);
+  }
+  const appDirPath = appDir || path2.join(projectRoot, "app");
+  if (fs2.existsSync(appDirPath)) {
+    scanAppDirectory(appDirPath, appDirPath, routes);
+  }
+  if (fs2.existsSync(pagesDir)) {
+    scanDirectory(pagesDir, pagesDir, routes);
+  }
+  if (fs2.existsSync(layoutsDir)) {
+    scanLayouts(layoutsDir, routes.layouts);
+  }
+  const rootLayoutPath = path2.join(appDirPath, "layout.tsx");
+  const rootLayoutPathJs = path2.join(appDirPath, "layout.jsx");
+  if (fs2.existsSync(rootLayoutPath)) {
+    routes.rootLayout = rootLayoutPath;
+  } else if (fs2.existsSync(rootLayoutPathJs)) {
+    routes.rootLayout = rootLayoutPathJs;
+  }
+  routes.tree = buildTree([...routes.flexiRoutes, ...routes.appRoutes, ...routes.pages]);
+  return routes;
+}
+function scanRoutesDirectory(baseDir, currentDir, routes, parentSegments = [], parentLayout = null, parentMiddleware = null) {
+  const entries = fs2.readdirSync(currentDir, { withFileTypes: true });
+  let layoutFile = null;
+  let loadingFile = null;
+  let errorFile = null;
+  let middlewareFile = null;
+  for (const entry of entries) {
+    if (entry.isFile()) {
+      const name = entry.name.replace(/\.(jsx|js|tsx|ts)$/, "");
+      const fullPath = path2.join(currentDir, entry.name);
+      const ext = path2.extname(entry.name);
+      if (name === "layout") layoutFile = fullPath;
+      if (name === "loading") loadingFile = fullPath;
+      if (name === "error") errorFile = fullPath;
+      if (name === "_middleware" || name === "middleware") middlewareFile = fullPath;
+      if (["layout", "loading", "error", "not-found", "_middleware", "middleware"].includes(name)) continue;
+      if (![".tsx", ".jsx", ".ts", ".js"].includes(ext)) continue;
+      const relativePath = path2.relative(baseDir, currentDir);
+      const isApiRoute = relativePath.startsWith("api") || relativePath.startsWith("api/");
+      if (isApiRoute && [".ts", ".js"].includes(ext)) {
+        const apiPath = "/" + [...parentSegments, name === "index" ? "" : name].filter(Boolean).join("/");
+        routes.api.push({
+          type: RouteType.API,
+          path: apiPath.replace(/\/+/g, "/") || "/",
+          filePath: fullPath,
+          pattern: createRoutePattern(apiPath),
+          segments: [...parentSegments, name === "index" ? "" : name].filter(Boolean)
+        });
+        continue;
+      }
+      if ([".tsx", ".jsx"].includes(ext)) {
+        let routePath;
+        if (name === "home" && parentSegments.length === 0) {
+          routePath = "/";
+        } else if (name === "index") {
+          routePath = "/" + parentSegments.join("/") || "/";
+        } else if (name.startsWith("[") && name.endsWith("]")) {
+          const paramName = name.slice(1, -1);
+          if (paramName.startsWith("...")) {
+            routePath = "/" + [...parentSegments, "*" + paramName.slice(3)].join("/");
+          } else {
+            routePath = "/" + [...parentSegments, ":" + paramName].join("/");
+          }
+        } else {
+          routePath = "/" + [...parentSegments, name].join("/");
+        }
+        routes.flexiRoutes.push({
+          type: RouteType.PAGE,
+          path: routePath.replace(/\/+/g, "/"),
+          filePath: fullPath,
+          pattern: createRoutePattern(routePath),
+          segments: routePath.split("/").filter(Boolean),
+          layout: layoutFile || parentLayout,
+          loading: loadingFile,
+          error: errorFile,
+          middleware: middlewareFile || parentMiddleware,
+          isFlexiRouter: true,
+          isServerComponent: isServerComponent(fullPath),
+          isClientComponent: isClientComponent(fullPath),
+          isIsland: isIsland(fullPath)
+        });
+      }
+    }
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const fullPath = path2.join(currentDir, entry.name);
+      const dirName = entry.name;
+      if (dirName.startsWith("_") || dirName.startsWith(".")) continue;
+      const isGroup = dirName.startsWith("(") && dirName.endsWith(")");
+      let segmentName = dirName;
+      if (dirName.startsWith("[") && dirName.endsWith("]")) {
+        const paramName = dirName.slice(1, -1);
+        if (paramName.startsWith("...")) {
+          segmentName = "*" + paramName.slice(3);
+        } else {
+          segmentName = ":" + paramName;
+        }
+      }
+      const newSegments = isGroup ? parentSegments : [...parentSegments, segmentName];
+      const newLayout = layoutFile || parentLayout;
+      const newMiddleware = middlewareFile || parentMiddleware;
+      scanRoutesDirectory(baseDir, fullPath, routes, newSegments, newLayout, newMiddleware);
+    }
+  }
+}
+function scanAppDirectory(baseDir, currentDir, routes, parentSegments = [], parentLayout = null, parentMiddleware = null) {
+  const entries = fs2.readdirSync(currentDir, { withFileTypes: true });
+  const specialFiles = {
+    page: null,
+    layout: null,
+    loading: null,
+    error: null,
+    notFound: null,
+    template: null,
+    middleware: null
+  };
+  for (const entry of entries) {
+    if (entry.isFile()) {
+      const name = entry.name.replace(/\.(jsx|js|tsx|ts)$/, "");
+      const fullPath = path2.join(currentDir, entry.name);
+      if (name === "page") specialFiles.page = fullPath;
+      if (name === "layout") specialFiles.layout = fullPath;
+      if (name === "loading") specialFiles.loading = fullPath;
+      if (name === "error") specialFiles.error = fullPath;
+      if (name === "not-found") specialFiles.notFound = fullPath;
+      if (name === "template") specialFiles.template = fullPath;
+      if (name === "middleware" || name === "_middleware") specialFiles.middleware = fullPath;
+    }
+  }
+  if (specialFiles.page) {
+    const routePath = "/" + parentSegments.join("/") || "/";
+    routes.appRoutes.push({
+      type: RouteType.PAGE,
+      path: routePath.replace(/\/+/g, "/"),
+      filePath: specialFiles.page,
+      pattern: createRoutePattern(routePath),
+      segments: parentSegments,
+      layout: specialFiles.layout || parentLayout,
+      loading: specialFiles.loading,
+      error: specialFiles.error,
+      notFound: specialFiles.notFound,
+      template: specialFiles.template,
+      middleware: specialFiles.middleware || parentMiddleware,
+      isAppRouter: true,
+      isServerComponent: isServerComponent(specialFiles.page),
+      isClientComponent: isClientComponent(specialFiles.page),
+      isIsland: isIsland(specialFiles.page)
+    });
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const fullPath = path2.join(currentDir, entry.name);
+      const isGroup = entry.name.startsWith("(") && entry.name.endsWith(")");
+      let segmentName = entry.name;
+      if (entry.name.startsWith("[") && entry.name.endsWith("]")) {
+        segmentName = ":" + entry.name.slice(1, -1);
+        if (entry.name.startsWith("[...")) {
+          segmentName = "*" + entry.name.slice(4, -1);
+        }
+        if (entry.name.startsWith("[[...")) {
+          segmentName = "*" + entry.name.slice(5, -2);
+        }
+      }
+      const newSegments = isGroup ? parentSegments : [...parentSegments, segmentName];
+      const newLayout = specialFiles.layout || parentLayout;
+      const newMiddleware = specialFiles.middleware || parentMiddleware;
+      scanAppDirectory(baseDir, fullPath, routes, newSegments, newLayout, newMiddleware);
+    }
+  }
+}
+function scanDirectory(baseDir, currentDir, routes, parentSegments = []) {
+  const entries = fs2.readdirSync(currentDir, { withFileTypes: true });
+  const specialFiles = {
+    layout: null,
+    loading: null,
+    error: null,
+    notFound: null
+  };
+  for (const entry of entries) {
+    if (entry.isFile()) {
+      const name = entry.name.replace(/\.(jsx|js|tsx|ts)$/, "");
+      const fullPath = path2.join(currentDir, entry.name);
+      if (name === "layout") specialFiles.layout = fullPath;
+      if (name === "loading") specialFiles.loading = fullPath;
+      if (name === "error") specialFiles.error = fullPath;
+      if (name === "not-found" || name === "404") specialFiles.notFound = fullPath;
+    }
+  }
+  for (const entry of entries) {
+    const fullPath = path2.join(currentDir, entry.name);
+    const relativePath = path2.relative(baseDir, fullPath);
+    if (entry.isDirectory()) {
+      const isGroup = entry.name.startsWith("(") && entry.name.endsWith(")");
+      const newSegments = isGroup ? parentSegments : [...parentSegments, entry.name];
+      scanDirectory(baseDir, fullPath, routes, newSegments);
+    } else if (entry.isFile()) {
+      const ext = path2.extname(entry.name);
+      const baseName = path2.basename(entry.name, ext);
+      if (["layout", "loading", "error", "not-found", "404"].includes(baseName)) {
+        continue;
+      }
+      if ([".jsx", ".js", ".tsx", ".ts"].includes(ext)) {
+        const isApi = relativePath.startsWith("api" + path2.sep) || relativePath.startsWith("api/");
+        if (isApi && [".js", ".ts"].includes(ext)) {
+          routes.api.push(createRoute(fullPath, baseDir, specialFiles, RouteType.API));
+        } else if (!isApi && [".jsx", ".tsx"].includes(ext)) {
+          routes.pages.push(createRoute(fullPath, baseDir, specialFiles, RouteType.PAGE));
+        }
+      }
+    }
+  }
+}
+function createRoute(filePath, baseDir, specialFiles, type) {
+  const relativePath = path2.relative(baseDir, filePath);
+  const routePath = filePathToRoute(relativePath);
+  return {
+    type,
+    path: routePath,
+    filePath,
+    pattern: createRoutePattern(routePath),
+    segments: routePath.split("/").filter(Boolean),
+    layout: specialFiles.layout,
+    loading: specialFiles.loading,
+    error: specialFiles.error,
+    notFound: specialFiles.notFound,
+    isServerComponent: isServerComponent(filePath),
+    isClientComponent: isClientComponent(filePath),
+    isIsland: isIsland(filePath)
+  };
+}
+function scanLayouts(layoutsDir, layoutsMap) {
+  const entries = fs2.readdirSync(layoutsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isFile() && /\.(jsx|tsx)$/.test(entry.name)) {
+      const name = entry.name.replace(/\.(jsx|tsx)$/, "");
+      layoutsMap.set(name, path2.join(layoutsDir, entry.name));
+    }
+  }
+}
+function filePathToRoute(filePath) {
+  let route = filePath.replace(/\\/g, "/");
+  route = route.replace(/\.(jsx|js|tsx|ts)$/, "");
+  route = route.replace(/\[\.\.\.([^\]]+)\]/g, "*$1");
+  route = route.replace(/\[([^\]]+)\]/g, ":$1");
+  if (route.endsWith("/index")) {
+    route = route.slice(0, -6) || "/";
+  } else if (route === "index") {
+    route = "/";
+  }
+  route = route.replace(/\/?\([^)]+\)\/?/g, "/");
+  if (!route.startsWith("/")) {
+    route = "/" + route;
+  }
+  route = route.replace(/\/+/g, "/");
+  return route;
+}
+function createRoutePattern(routePath) {
+  let pattern = routePath.replace(/\*[^/]*/g, "(.*)").replace(/:[^/]+/g, "([^/]+)").replace(/\//g, "\\/");
+  return new RegExp(`^${pattern}$`);
+}
+function buildTree(routes) {
+  const tree = { children: {}, routes: [] };
+  for (const route of routes) {
+    let current = tree;
+    for (const segment of route.segments) {
+      if (!current.children[segment]) {
+        current.children[segment] = { children: {}, routes: [] };
+      }
+      current = current.children[segment];
+    }
+    current.routes.push(route);
+  }
+  return tree;
+}
+
+// core/build/index.ts
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = path3.dirname(__filename2);
+var BuildMode = {
+  DEVELOPMENT: "development",
+  PRODUCTION: "production"
+};
+async function build2(options) {
+  const {
+    projectRoot,
+    config,
+    mode = BuildMode.PRODUCTION,
+    analyze = false
+  } = options;
+  const startTime = Date.now();
+  const outDir = config.outDir;
+  const isDev = mode === BuildMode.DEVELOPMENT;
+  console.log("\n\u26A1 FlexiReact Build\n");
+  console.log(`  Mode: ${mode}`);
+  console.log(`  Output: ${outDir}
+`);
+  cleanDir(outDir);
+  ensureDir(path3.join(outDir, "client"));
+  ensureDir(path3.join(outDir, "server"));
+  ensureDir(path3.join(outDir, "static"));
+  const routes = buildRouteTree(config.pagesDir, config.layoutsDir);
+  const clientEntries = findClientEntries(config.pagesDir, config.layoutsDir);
+  console.log("\u{1F4E6} Building client bundle...");
+  const clientResult = await buildClient({
+    entries: clientEntries,
+    outDir: path3.join(outDir, "client"),
+    config,
+    isDev
+  });
+  console.log("\u{1F4E6} Building server bundle...");
+  const serverResult = await buildServer({
+    pagesDir: config.pagesDir,
+    layoutsDir: config.layoutsDir,
+    outDir: path3.join(outDir, "server"),
+    config,
+    isDev
+  });
+  console.log("\u{1F4C1} Copying public assets...");
+  await copyPublicAssets(config.publicDir, path3.join(outDir, "static"));
+  const manifest = generateManifest({
+    routes,
+    clientResult,
+    serverResult,
+    config
+  });
+  fs3.writeFileSync(
+    path3.join(outDir, "manifest.json"),
+    JSON.stringify(manifest, null, 2)
+  );
+  const duration = Date.now() - startTime;
+  console.log("\n\u2728 Build complete!\n");
+  console.log(`  Duration: ${duration}ms`);
+  console.log(`  Client chunks: ${clientResult.outputs.length}`);
+  console.log(`  Server modules: ${serverResult.outputs.length}`);
+  console.log("");
+  let analysis = null;
+  if (analyze) {
+    analysis = generateBundleAnalysis(clientResult, serverResult, outDir);
+  }
+  return {
+    success: true,
+    duration,
+    manifest,
+    clientResult,
+    serverResult,
+    analysis
+  };
+}
+function generateBundleAnalysis(clientResult, serverResult, outDir) {
+  const files = {};
+  let totalSize = 0;
+  let totalGzipSize = 0;
+  for (const output of clientResult.outputs || []) {
+    if (output.path && fs3.existsSync(output.path)) {
+      const stat = fs3.statSync(output.path);
+      const relativePath = path3.relative(outDir, output.path);
+      const gzipSize = Math.round(stat.size * 0.3);
+      files[relativePath] = {
+        size: stat.size,
+        gzipSize
+      };
+      totalSize += stat.size;
+      totalGzipSize += gzipSize;
+    }
+  }
+  for (const output of serverResult.outputs || []) {
+    if (output.path && fs3.existsSync(output.path)) {
+      const stat = fs3.statSync(output.path);
+      const relativePath = path3.relative(outDir, output.path);
+      files[relativePath] = {
+        size: stat.size
+      };
+      totalSize += stat.size;
+    }
+  }
+  return {
+    files,
+    totalSize,
+    totalGzipSize,
+    clientSize: clientResult.outputs?.reduce((sum, o) => {
+      if (o.path && fs3.existsSync(o.path)) {
+        return sum + fs3.statSync(o.path).size;
+      }
+      return sum;
+    }, 0) || 0,
+    serverSize: serverResult.outputs?.reduce((sum, o) => {
+      if (o.path && fs3.existsSync(o.path)) {
+        return sum + fs3.statSync(o.path).size;
+      }
+      return sum;
+    }, 0) || 0
+  };
+}
+function findClientEntries(pagesDir, layoutsDir) {
+  const entries = [];
+  const dirs = [pagesDir, layoutsDir].filter((d) => fs3.existsSync(d));
+  for (const dir of dirs) {
+    const files = findFiles(dir, /\.(jsx|tsx)$/);
+    for (const file of files) {
+      if (isClientComponent(file) || isIsland(file)) {
+        entries.push(file);
+      }
+    }
+  }
+  return entries;
+}
+async function buildClient(options) {
+  const { entries, outDir, config, isDev } = options;
+  if (entries.length === 0) {
+    return { outputs: [] };
+  }
+  const entryPoints = {};
+  for (const entry of entries) {
+    const name = path3.basename(entry, path3.extname(entry));
+    const hash = generateHash(entry);
+    entryPoints[`${name}-${hash}`] = entry;
+  }
+  const runtimePath = path3.join(__dirname2, "..", "client", "runtime.js");
+  if (fs3.existsSync(runtimePath)) {
+    entryPoints["runtime"] = runtimePath;
+  }
+  try {
+    const result = await esbuild.build({
+      entryPoints,
+      bundle: true,
+      splitting: true,
+      format: "esm",
+      outdir: outDir,
+      minify: !isDev && config.build.minify,
+      sourcemap: config.build.sourcemap,
+      target: config.build.target,
+      jsx: "automatic",
+      jsxImportSource: "react",
+      metafile: true,
+      external: [],
+      define: {
+        "process.env.NODE_ENV": JSON.stringify(isDev ? "development" : "production")
+      },
+      loader: {
+        ".js": "jsx",
+        ".jsx": "jsx",
+        ".ts": "tsx",
+        ".tsx": "tsx"
+      }
+    });
+    const outputs = Object.keys(result.metafile.outputs).map((file) => ({
+      file: path3.basename(file),
+      size: result.metafile.outputs[file].bytes
+    }));
+    return { outputs, metafile: result.metafile };
+  } catch (error) {
+    console.error("Client build failed:", error);
+    throw error;
+  }
+}
+async function buildServer(options) {
+  const { pagesDir, layoutsDir, outDir, config, isDev } = options;
+  const entries = [];
+  for (const dir of [pagesDir, layoutsDir]) {
+    if (fs3.existsSync(dir)) {
+      entries.push(...findFiles(dir, /\.(jsx|tsx|js|ts)$/));
+    }
+  }
+  if (entries.length === 0) {
+    return { outputs: [] };
+  }
+  const entryPoints = {};
+  for (const entry of entries) {
+    const relativePath = path3.relative(pagesDir, entry);
+    const name = relativePath.replace(/[\/\\]/g, "_").replace(/\.(jsx|tsx|js|ts)$/, "");
+    entryPoints[name] = entry;
+  }
+  try {
+    const result = await esbuild.build({
+      entryPoints,
+      bundle: true,
+      format: "esm",
+      platform: "node",
+      outdir: outDir,
+      minify: false,
+      // Keep server code readable
+      sourcemap: true,
+      target: "node18",
+      jsx: "automatic",
+      jsxImportSource: "react",
+      metafile: true,
+      packages: "external",
+      // Don't bundle node_modules
+      loader: {
+        ".js": "jsx",
+        ".jsx": "jsx",
+        ".ts": "tsx",
+        ".tsx": "tsx"
+      }
+    });
+    const outputs = Object.keys(result.metafile.outputs).map((file) => ({
+      file: path3.basename(file),
+      size: result.metafile.outputs[file].bytes
+    }));
+    return { outputs, metafile: result.metafile };
+  } catch (error) {
+    console.error("Server build failed:", error);
+    throw error;
+  }
+}
+async function copyPublicAssets(publicDir, outDir) {
+  if (!fs3.existsSync(publicDir)) {
+    return;
+  }
+  const copyRecursive = (src, dest) => {
+    const entries = fs3.readdirSync(src, { withFileTypes: true });
+    ensureDir(dest);
+    for (const entry of entries) {
+      const srcPath = path3.join(src, entry.name);
+      const destPath = path3.join(dest, entry.name);
+      if (entry.isDirectory()) {
+        copyRecursive(srcPath, destPath);
+      } else {
+        fs3.copyFileSync(srcPath, destPath);
+      }
+    }
+  };
+  copyRecursive(publicDir, outDir);
+}
+function generateManifest(options) {
+  const { routes, clientResult, serverResult, config } = options;
+  return {
+    version: "2.0.0",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    routes: {
+      pages: routes.pages.map((r) => ({
+        path: r.path,
+        file: r.filePath,
+        hasLayout: !!r.layout,
+        hasLoading: !!r.loading,
+        hasError: !!r.error
+      })),
+      api: routes.api.map((r) => ({
+        path: r.path,
+        file: r.filePath
+      }))
+    },
+    client: {
+      chunks: clientResult.outputs || []
+    },
+    server: {
+      modules: serverResult.outputs || []
+    },
+    config: {
+      islands: config.islands.enabled,
+      rsc: config.rsc.enabled
+    }
+  };
+}
+async function buildDev(options) {
+  const { projectRoot, config, onChange } = options;
+  const outDir = config.outDir;
+  ensureDir(outDir);
+  const ctx = await esbuild.context({
+    entryPoints: findFiles(config.pagesDir, /\.(jsx|tsx)$/),
+    bundle: true,
+    format: "esm",
+    outdir: path3.join(outDir, "dev"),
+    sourcemap: true,
+    jsx: "automatic",
+    jsxImportSource: "react",
+    loader: {
+      ".js": "jsx",
+      ".jsx": "jsx"
+    },
+    plugins: [{
+      name: "flexi-watch",
+      setup(build3) {
+        build3.onEnd((result) => {
+          if (result.errors.length === 0) {
+            onChange?.();
+          }
+        });
+      }
+    }]
+  });
+  await ctx.watch();
+  return ctx;
+}
+var build_default = {
+  build: build2,
+  buildDev,
+  BuildMode
+};
+export {
+  BuildMode,
+  build2 as build,
+  buildDev,
+  build_default as default
+};
+//# sourceMappingURL=index.js.map