@constela/start 0.3.0 → 0.4.0

package/dist/index.js

@@ -1,404 +1,41 @@
+import {
+  build,
+  createDevServer,
+  filePathToPattern,
+  getMimeType,
+  isPathSafe,
+  resolveStaticFile,
+  scanRoutes
+} from "./chunk-JXIOHPG5.js";
 import {
   generateHydrationScript,
   renderPage,
   wrapHtml
 } from "./chunk-QLDID7EZ.js";
 
-// src/router/file-router.ts
-import fg from "fast-glob";
-import { existsSync, statSync } from "fs";
-import { join } from "path";
-function filePathToPattern(filePath, _routesDir) {
-  let normalized = filePath.replace(/\\/g, "/");
-  normalized = normalized.replace(/\.(ts|tsx|js|jsx)$/, "");
-  const segments = normalized.split("/");
-  const processedSegments = segments.map((segment) => {
-    if (segment.startsWith("[...") && segment.endsWith("]")) {
-      return "*";
-    }
-    if (segment.startsWith("[") && segment.endsWith("]")) {
-      const paramName = segment.slice(1, -1);
-      return `:${paramName}`;
-    }
-    return segment;
-  });
-  if (processedSegments.at(-1) === "index") {
-    processedSegments.pop();
-  }
-  const path = "/" + processedSegments.join("/");
-  if (path === "/") {
-    return "/";
-  }
-  return path.endsWith("/") ? path.slice(0, -1) : path;
-}
-function extractParams(filePath) {
-  const params = [];
-  const normalized = filePath.replace(/\\/g, "/");
-  const regex = /\[(?:\.\.\.)?([^\]]+)\]/g;
-  let match;
-  while ((match = regex.exec(normalized)) !== null) {
-    const paramName = match[1];
-    if (paramName !== void 0) {
-      params.push(paramName);
-    }
-  }
-  return params;
-}
-function determineRouteType(filePath) {
-  const normalized = filePath.replace(/\\/g, "/");
-  const fileName = normalized.split("/").pop() ?? "";
-  if (fileName.startsWith("_middleware.")) {
-    return "middleware";
-  }
-  if (normalized.startsWith("api/") || normalized.includes("/api/")) {
-    return "api";
-  }
-  return "page";
-}
-function shouldIncludeRoute(filePath) {
-  const normalized = filePath.replace(/\\/g, "/");
-  const fileName = normalized.split("/").pop() ?? "";
-  if (fileName.endsWith(".d.ts")) {
-    return false;
-  }
-  if (fileName.startsWith("_") && !fileName.startsWith("_middleware.")) {
-    return false;
-  }
-  return true;
-}
-async function scanRoutes(routesDir) {
-  if (!existsSync(routesDir)) {
-    throw new Error(`Routes directory does not exist: ${routesDir}`);
-  }
-  const stats = statSync(routesDir);
-  if (!stats.isDirectory()) {
-    throw new Error(`Routes path is not a directory: ${routesDir}`);
-  }
-  const files = await fg("**/*.{ts,tsx,js,jsx}", {
-    cwd: routesDir,
-    ignore: ["node_modules/**", "**/*.d.ts"],
-    onlyFiles: true,
-    followSymbolicLinks: false
-  });
-  const routes = [];
-  for (const filePath of files) {
-    if (!shouldIncludeRoute(filePath)) {
-      continue;
-    }
-    const route = {
-      file: join(routesDir, filePath),
-      pattern: filePathToPattern(filePath, routesDir),
-      type: determineRouteType(filePath),
-      params: extractParams(filePath)
-    };
-    routes.push(route);
-  }
-  routes.sort((a, b) => {
-    return compareRoutes(a, b);
-  });
-  return routes;
-}
-function compareRoutes(a, b) {
-  if (a.type === "middleware" && b.type !== "middleware") return -1;
-  if (b.type === "middleware" && a.type !== "middleware") return 1;
-  const segmentsA = a.pattern.split("/").filter(Boolean);
-  const segmentsB = b.pattern.split("/").filter(Boolean);
-  const minLen = Math.min(segmentsA.length, segmentsB.length);
-  for (let i = 0; i < minLen; i++) {
-    const segA = segmentsA[i] ?? "";
-    const segB = segmentsB[i] ?? "";
-    const typeA = getSegmentType(segA);
-    const typeB = getSegmentType(segB);
-    if (typeA !== typeB) {
-      return typeA - typeB;
-    }
-    if (typeA === 0 && segA !== segB) {
-      return segA.localeCompare(segB);
-    }
-  }
-  if (segmentsA.length !== segmentsB.length) {
-    return segmentsA.length - segmentsB.length;
-  }
-  return a.pattern.localeCompare(b.pattern);
-}
-function getSegmentType(segment) {
-  if (segment === "*") return 2;
-  if (segment.startsWith(":")) return 1;
-  return 0;
-}
-
-// src/dev/server.ts
-import { createServer } from "http";
-import { createReadStream } from "fs";
-import { join as join3 } from "path";
+// src/build/ssg.ts
+import { mkdir, writeFile } from "fs/promises";
+import { join, dirname } from "path";
 
-// src/static/index.ts
-import { extname, join as join2, normalize, resolve } from "path";
-import { existsSync as existsSync2, statSync as statSync2 } from "fs";
-var MIME_TYPES = {
-  // Images
-  ".ico": "image/x-icon",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".svg": "image/svg+xml",
-  ".webp": "image/webp",
-  // Fonts
-  ".woff": "font/woff",
-  ".woff2": "font/woff2",
-  ".ttf": "font/ttf",
-  ".otf": "font/otf",
-  ".eot": "application/vnd.ms-fontobject",
-  // Web assets
-  ".css": "text/css",
-  ".js": "text/javascript",
-  ".json": "application/json",
-  ".txt": "text/plain",
-  ".html": "text/html",
-  ".xml": "application/xml",
-  // Other
-  ".pdf": "application/pdf",
-  ".mp3": "audio/mpeg",
-  ".mp4": "video/mp4",
-  ".webm": "video/webm",
-  ".map": "application/json"
-};
-var DEFAULT_MIME_TYPE = "application/octet-stream";
-function isPathSafe(pathname) {
-  if (!pathname) {
-    return false;
-  }
-  if (!pathname.startsWith("/")) {
-    return false;
-  }
-  if (pathname.includes("\\")) {
-    return false;
-  }
-  if (pathname.includes("//")) {
-    return false;
-  }
-  if (pathname.includes("\0") || pathname.includes("%00")) {
-    return false;
-  }
-  let decoded;
-  try {
-    decoded = pathname;
-    let prevDecoded = "";
-    while (decoded !== prevDecoded) {
-      prevDecoded = decoded;
-      decoded = decodeURIComponent(decoded);
-    }
-  } catch {
-    return false;
-  }
-  if (decoded.includes("\0")) {
-    return false;
-  }
-  if (decoded.includes("..")) {
-    return false;
-  }
-  const segments = decoded.split("/").filter(Boolean);
-  for (const segment of segments) {
-    if (segment.startsWith(".")) {
-      return false;
-    }
-  }
-  return true;
+// src/utils/resolve-page.ts
+function isPageExportFunction(exported) {
+  return typeof exported === "function";
 }
-function getMimeType(filePath) {
-  const ext = extname(filePath).toLowerCase();
-  return MIME_TYPES[ext] ?? DEFAULT_MIME_TYPE;
-}
-function hasObviousAttackPattern(pathname) {
-  if (!pathname) {
-    return true;
-  }
-  if (!pathname.startsWith("/")) {
-    return true;
-  }
-  if (pathname.includes("\\")) {
-    return true;
-  }
-  if (pathname.includes("//")) {
-    return true;
-  }
-  if (pathname.includes("\0") || pathname.includes("%00")) {
-    return true;
-  }
-  let decoded;
-  try {
-    decoded = pathname;
-    let prevDecoded = "";
-    while (decoded !== prevDecoded) {
-      prevDecoded = decoded;
-      decoded = decodeURIComponent(decoded);
-    }
-  } catch {
-    return true;
-  }
-  if (decoded.includes("\0")) {
-    return true;
-  }
-  const segments = decoded.split("/").filter(Boolean);
-  for (const segment of segments) {
-    if (segment.startsWith(".") && segment !== "..") {
-      return true;
-    }
-  }
-  if (decoded.startsWith("/..")) {
-    return true;
-  }
-  return false;
-}
-function resolveStaticFile(pathname, publicDir) {
-  if (hasObviousAttackPattern(pathname)) {
-    return {
-      exists: false,
-      filePath: null,
-      mimeType: null,
-      error: "path_traversal"
-    };
-  }
-  let decodedPathname;
-  try {
-    decodedPathname = decodeURIComponent(pathname);
-  } catch {
-    return {
-      exists: false,
-      filePath: null,
-      mimeType: null,
-      error: "path_traversal"
-    };
-  }
-  const relativePath = decodedPathname.slice(1);
-  const resolvedPath = normalize(join2(publicDir, relativePath));
-  const absolutePublicDir = resolve(publicDir);
-  const publicDirWithSep = absolutePublicDir.endsWith("/") ? absolutePublicDir : absolutePublicDir + "/";
-  if (!resolvedPath.startsWith(publicDirWithSep) && resolvedPath !== absolutePublicDir) {
-    return {
-      exists: false,
-      filePath: null,
-      mimeType: null,
-      error: "outside_public"
-    };
-  }
-  const mimeType = getMimeType(resolvedPath);
-  let exists = false;
-  if (existsSync2(resolvedPath)) {
-    try {
-      const stats = statSync2(resolvedPath);
-      exists = stats.isFile();
-    } catch {
-      exists = false;
+async function resolvePageExport(pageDefault, params, expectedParams) {
+  if (expectedParams) {
+    for (const key of expectedParams) {
+      if (!(key in params)) {
+        throw new Error(`Missing required route param: ${key}`);
+      }
     }
   }
-  return {
-    exists,
-    filePath: resolvedPath,
-    mimeType
-  };
-}
-
-// src/dev/server.ts
-var DEFAULT_PORT = 3e3;
-var DEFAULT_HOST = "localhost";
-var DEFAULT_PUBLIC_DIR = "public";
-async function createDevServer(options = {}) {
-  const {
-    port = DEFAULT_PORT,
-    host = DEFAULT_HOST,
-    routesDir: _routesDir = "src/routes",
-    publicDir = join3(process.cwd(), DEFAULT_PUBLIC_DIR)
-  } = options;
-  let httpServer = null;
-  let actualPort = port;
-  const devServer = {
-    get port() {
-      return actualPort;
-    },
-    async listen() {
-      return new Promise((resolve2, reject) => {
-        httpServer = createServer((req, res) => {
-          const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
-          const pathname = url.pathname;
-          const staticResult = resolveStaticFile(pathname, publicDir);
-          if (staticResult.error === "path_traversal" || staticResult.error === "outside_public") {
-            res.writeHead(403, { "Content-Type": "text/plain" });
-            res.end("Forbidden");
-            return;
-          }
-          if (staticResult.exists && staticResult.filePath && staticResult.mimeType) {
-            res.writeHead(200, { "Content-Type": staticResult.mimeType });
-            const stream = createReadStream(staticResult.filePath);
-            stream.pipe(res);
-            stream.on("error", () => {
-              if (!res.headersSent) {
-                res.writeHead(500, { "Content-Type": "text/plain" });
-              }
-              res.end("Internal Server Error");
-            });
-            return;
-          }
-          if (staticResult.filePath && !staticResult.exists) {
-            res.writeHead(404, { "Content-Type": "text/plain" });
-            res.end("Not Found");
-            return;
-          }
-          res.writeHead(200, { "Content-Type": "text/html" });
-          res.end("<html><body>Constela Dev Server</body></html>");
-        });
-        httpServer.on("error", (err) => {
-          reject(err);
-        });
-        httpServer.listen(port, host, () => {
-          const address = httpServer?.address();
-          if (address) {
-            actualPort = address.port;
-          }
-          resolve2();
-        });
-      });
-    },
-    async close() {
-      return new Promise((resolve2, reject) => {
-        if (!httpServer) {
-          resolve2();
-          return;
-        }
-        httpServer.close((err) => {
-          if (err) {
-            reject(err);
-          } else {
-            httpServer = null;
-            resolve2();
-          }
-        });
-      });
-    }
-  };
-  return devServer;
-}
-
-// src/build/index.ts
-async function build(options) {
-  const outDir = options?.outDir ?? "dist";
-  const routesDir = options?.routesDir ?? "src/routes";
-  let routes = [];
-  try {
-    const scannedRoutes = await scanRoutes(routesDir);
-    routes = scannedRoutes.map((r) => r.pattern);
-  } catch {
+  if (isPageExportFunction(pageDefault)) {
+    return await pageDefault(params);
   }
-  return {
-    outDir,
-    routes
-  };
+  return pageDefault;
 }
 
 // src/build/ssg.ts
-import { mkdir, writeFile } from "fs/promises";
-import { join as join4, dirname } from "path";
 var defaultProgram = {
   version: "1.0",
   state: {},
@@ -410,24 +47,12 @@ var defaultProgram = {
     children: [{ kind: "text", value: { expr: "lit", value: "" } }]
   }
 };
-var testStaticPaths = {
-  "/users/:id": {
-    paths: [{ params: { id: "1" } }, { params: { id: "2" } }]
-  },
-  "/posts/:slug": {
-    paths: [{ params: { slug: "hello-world" } }]
-  },
-  "/posts/:year/:month": {
-    paths: [{ params: { year: "2024", month: "01" } }]
-  }
-};
-var consumedPatterns = /* @__PURE__ */ new Set();
 function getOutputPath(pattern, outDir) {
   if (pattern === "/") {
-    return join4(outDir, "index.html");
+    return join(outDir, "index.html");
   }
   const segments = pattern.slice(1).split("/");
-  return join4(outDir, ...segments, "index.html");
+  return join(outDir, ...segments, "index.html");
 }
 function resolvePattern(pattern, params) {
   let resolved = pattern;
@@ -444,15 +69,13 @@ async function tryLoadModule(filePath) {
     return null;
   }
 }
-async function getStaticPathsForRoute(route, module) {
+async function getStaticPathsForRoute(route, module, staticPathsProvider) {
   if (module?.getStaticPaths) {
     const result = await module.getStaticPaths();
     return result;
   }
-  const testData = testStaticPaths[route.pattern];
-  if (testData && !consumedPatterns.has(route.pattern)) {
-    consumedPatterns.add(route.pattern);
-    return testData;
+  if (staticPathsProvider) {
+    return await staticPathsProvider(route.pattern);
   }
   return null;
 }
@@ -471,19 +94,21 @@ async function generateSinglePage(pattern, outDir, program, params = {}) {
   await writeFile(outputPath, html, "utf-8");
   return outputPath;
 }
-async function generateStaticPages(routes, outDir) {
+async function generateStaticPages(routes, outDir, options = {}) {
+  const { staticPathsProvider } = options;
   const generatedPaths = [];
   const pageRoutes = routes.filter((r) => r.type === "page");
   for (const route of pageRoutes) {
     const isDynamic = route.params.length > 0;
     const module = await tryLoadModule(route.file);
-    const program = module?.default ?? defaultProgram;
+    const pageExport = module?.default ?? defaultProgram;
     if (isDynamic) {
-      const staticPaths = await getStaticPathsForRoute(route, module);
+      const staticPaths = await getStaticPathsForRoute(route, module, staticPathsProvider);
       if (!staticPaths) {
         continue;
       }
       for (const pathData of staticPaths.paths) {
+        const program = await resolvePageExport(pageExport, pathData.params, route.params);
         const resolvedPattern = resolvePattern(route.pattern, pathData.params);
         const filePath = await generateSinglePage(
           resolvedPattern,
@@ -494,6 +119,7 @@ async function generateStaticPages(routes, outDir) {
         generatedPaths.push(filePath);
       }
     } else {
+      const program = await resolvePageExport(pageExport, {});
       const filePath = await generateSinglePage(route.pattern, outDir, program);
       generatedPaths.push(filePath);
     }
@@ -605,7 +231,7 @@ function createErrorResponse(error) {
 }
 function createAdapter(options) {
   const { routes, loadModule = defaultLoadModule } = options;
-  async function fetch(request) {
+  async function fetch2(request) {
     try {
       const url = new URL(request.url);
       let pathname = url.pathname;
@@ -640,7 +266,7 @@ function createAdapter(options) {
         return await handler(ctx);
       } else {
         const pageModule = module;
-        const program = pageModule.default;
+        const program = await resolvePageExport(pageModule.default, matchedParams, matchedRoute.params);
         const content = await renderPage(program, {
           url: request.url,
           params: matchedParams,
@@ -657,9 +283,448 @@ function createAdapter(options) {
       return createErrorResponse(error);
     }
   }
-  return { fetch };
+  return { fetch: fetch2 };
 }
+
+// src/layout/resolver.ts
+import { existsSync, statSync } from "fs";
+import { join as join2, basename } from "path";
+import fg from "fast-glob";
+import { isLayoutProgram } from "@constela/core";
+async function scanLayouts(layoutsDir) {
+  if (!existsSync(layoutsDir)) {
+    throw new Error(`Layouts directory does not exist: ${layoutsDir}`);
+  }
+  const stat = statSync(layoutsDir);
+  if (!stat.isDirectory()) {
+    throw new Error(`Path is not a directory: ${layoutsDir}`);
+  }
+  const files = await fg(["**/*.ts", "**/*.tsx"], {
+    cwd: layoutsDir,
+    ignore: ["**/_*", "**/*.d.ts"]
+  });
+  const layouts = files.filter((file) => {
+    const name = basename(file);
+    if (name.startsWith("_")) return false;
+    if (name.endsWith(".d.ts")) return false;
+    if (!name.endsWith(".ts") && !name.endsWith(".tsx")) return false;
+    return true;
+  }).map((file) => {
+    const name = basename(file).replace(/\.(tsx?|ts)$/, "");
+    return {
+      name,
+      file: join2(layoutsDir, file)
+    };
+  });
+  return layouts;
+}
+function resolveLayout(layoutName, layouts) {
+  return layouts.find((l) => l.name === layoutName);
+}
+async function loadLayout(layoutFile) {
+  try {
+    const module = await import(layoutFile);
+    const exported = module.default || module;
+    if (!isLayoutProgram(exported)) {
+      throw new Error(`File is not a valid layout: ${layoutFile}`);
+    }
+    return exported;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("not a valid layout")) {
+      throw error;
+    }
+    throw new Error(`Failed to load layout: ${layoutFile}`);
+  }
+}
+var LayoutResolver = class {
+  layoutsDir;
+  layouts = [];
+  loadedLayouts = /* @__PURE__ */ new Map();
+  initialized = false;
+  constructor(layoutsDir) {
+    this.layoutsDir = layoutsDir;
+  }
+  /**
+   * Initialize the resolver by scanning the layouts directory
+   */
+  async initialize() {
+    try {
+      this.layouts = await scanLayouts(this.layoutsDir);
+      this.initialized = true;
+    } catch {
+      this.layouts = [];
+      this.initialized = true;
+    }
+  }
+  /**
+   * Check if a layout exists
+   */
+  hasLayout(name) {
+    return this.layouts.some((l) => l.name === name);
+  }
+  /**
+   * Get a layout by name
+   *
+   * @param name - Layout name
+   * @returns The layout program or undefined if not found
+   */
+  async getLayout(name) {
+    const cached = this.loadedLayouts.get(name);
+    if (cached) {
+      return cached;
+    }
+    const scanned = resolveLayout(name, this.layouts);
+    if (!scanned) {
+      return void 0;
+    }
+    const layout = await loadLayout(scanned.file);
+    this.loadedLayouts.set(name, layout);
+    return layout;
+  }
+  /**
+   * Compose a page with its layout
+   *
+   * @param page - Page program to compose
+   * @returns Composed program (or original if no layout)
+   * @throws Error if specified layout is not found
+   */
+  async composeWithLayout(page) {
+    const layoutName = page.route?.layout;
+    if (!layoutName) {
+      return page;
+    }
+    if (!this.hasLayout(layoutName)) {
+      const available = this.layouts.map((l) => l.name).join(", ");
+      throw new Error(
+        `Layout '${layoutName}' not found. Available layouts: ${available || "none"}`
+      );
+    }
+    const layout = await this.getLayout(layoutName);
+    if (!layout) {
+      throw new Error(`Layout '${layoutName}' not found`);
+    }
+    return page;
+  }
+  /**
+   * Get all scanned layouts
+   */
+  getAll() {
+    return [...this.layouts];
+  }
+};
+
+// src/data/loader.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { join as join3 } from "path";
+import fg2 from "fast-glob";
+function parseYaml(content) {
+  const result = {};
+  const lines = content.split("\n");
+  const stack = [{ indent: -2, obj: result }];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line || line.trim() === "" || line.trim().startsWith("#")) continue;
+    const arrayMatch = line.match(/^(\s*)-\s*(.*)$/);
+    if (arrayMatch) {
+      const [, indentStr2, rest] = arrayMatch;
+      const indent2 = indentStr2?.length ?? 0;
+      while (stack.length > 1 && indent2 <= stack[stack.length - 1].indent) {
+        stack.pop();
+      }
+      const parent = stack[stack.length - 1];
+      const key2 = parent.key;
+      if (key2) {
+        if (!Array.isArray(parent.obj[key2])) {
+          parent.obj[key2] = [];
+        }
+        const arr = parent.obj[key2];
+        const objMatch = rest?.match(/^([\w-]+):\s*(.*)$/);
+        if (objMatch) {
+          const [, k, v] = objMatch;
+          const newObj = {};
+          if (v?.trim()) {
+            newObj[k] = parseValue(v);
+          }
+          arr.push(newObj);
+          stack.push({ indent: indent2, obj: newObj, key: k, isArray: true });
+        } else if (rest?.trim()) {
+          arr.push(parseValue(rest.trim()));
+        }
+      }
+      continue;
+    }
+    const match = line.match(/^(\s*)([\w-]+):\s*(.*)$/);
+    if (!match) continue;
+    const [, indentStr, key, value] = match;
+    const indent = indentStr?.length ?? 0;
+    while (stack.length > 1 && indent <= stack[stack.length - 1].indent) {
+      stack.pop();
+    }
+    let targetObj;
+    const currentTop = stack[stack.length - 1];
+    if (currentTop.isArray) {
+      targetObj = currentTop.obj;
+    } else if (currentTop.key) {
+      if (!currentTop.obj[currentTop.key]) {
+        currentTop.obj[currentTop.key] = {};
+      }
+      targetObj = currentTop.obj[currentTop.key];
+    } else {
+      targetObj = currentTop.obj;
+    }
+    if (value?.trim() === "" || value === void 0) {
+      const newObj = {};
+      targetObj[key] = newObj;
+      stack.push({ indent, obj: targetObj, key });
+    } else {
+      targetObj[key] = parseValue(value);
+    }
+  }
+  return result;
+}
+function parseValue(value) {
+  const trimmed = value.trim();
+  if (trimmed === "true") return true;
+  if (trimmed === "false") return false;
+  if (trimmed === "null" || trimmed === "~") return null;
+  if (/^-?\d+$/.test(trimmed)) return parseInt(trimmed, 10);
+  if (/^-?\d+\.\d+$/.test(trimmed)) return parseFloat(trimmed);
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function transformMdx(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match) {
+    return { frontmatter: {}, content: content.trim() };
+  }
+  const frontmatter = parseYaml(match[1]);
+  return { frontmatter, content: match[2].trim() };
+}
+function transformYaml(content) {
+  return parseYaml(content);
+}
+function transformCsv(content) {
+  const lines = content.trim().split("\n");
+  if (lines.length === 0) return [];
+  const headerLine = lines[0];
+  const headers = parseCSVLine(headerLine);
+  const result = [];
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim() === "") continue;
+    const values = parseCSVLine(line);
+    const row = {};
+    for (let j = 0; j < headers.length; j++) {
+      row[headers[j].trim()] = (values[j] ?? "").trim();
+    }
+    result.push(row);
+  }
+  return result;
+}
+function parseCSVLine(line) {
+  const result = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i];
+    if (char === '"') {
+      inQuotes = !inQuotes;
+    } else if (char === "," && !inQuotes) {
+      result.push(current);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  result.push(current);
+  return result;
+}
+function applyTransform(content, transform, filename) {
+  if (!transform) {
+    if (filename.endsWith(".json")) {
+      return JSON.parse(content);
+    }
+    return content;
+  }
+  switch (transform) {
+    case "mdx":
+      return transformMdx(content);
+    case "yaml":
+      return transformYaml(content);
+    case "csv":
+      return transformCsv(content);
+    default:
+      return content;
+  }
+}
+async function loadGlob(baseDir, pattern, transform) {
+  const files = await fg2(pattern, { cwd: baseDir });
+  const results = [];
+  for (const file of files) {
+    const fullPath = join3(baseDir, file);
+    const content = readFileSync(fullPath, "utf-8");
+    if (transform === "mdx") {
+      const transformed = transformMdx(content);
+      results.push({
+        file,
+        raw: content,
+        frontmatter: transformed.frontmatter,
+        content: transformed.content
+      });
+    } else {
+      results.push({
+        file,
+        raw: content
+      });
+    }
+  }
+  return results;
+}
+async function loadFile(baseDir, filePath, transform) {
+  const fullPath = join3(baseDir, filePath);
+  if (!existsSync2(fullPath)) {
+    throw new Error(`File not found: ${fullPath}`);
+  }
+  const content = readFileSync(fullPath, "utf-8");
+  return applyTransform(content, transform, filePath);
+}
+async function loadApi(url, transform) {
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`api request failed: ${response.status} ${response.statusText}`);
+    }
+    if (transform === "csv") {
+      const text = await response.text();
+      return transformCsv(text);
+    }
+    return await response.json();
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("api request failed")) {
+      throw error;
+    }
+    throw new Error(`Network error: ${error.message}`);
+  }
+}
+function evaluateParamExpression(expr, item) {
+  switch (expr.expr) {
+    case "lit":
+      return String(expr.value);
+    case "var":
+      if (expr.name === "item") {
+        if (expr.path) {
+          return getNestedValue(item, expr.path);
+        }
+        return String(item);
+      }
+      return "";
+    case "get":
+      if (expr.base.expr === "var" && expr.base.name === "item") {
+        return getNestedValue(item, expr.path);
+      }
+      return "";
+    default:
+      return "";
+  }
+}
+function getNestedValue(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0) return "";
+    if (typeof current !== "object") return "";
+    current = current[part];
+  }
+  return current !== void 0 && current !== null ? String(current) : "";
+}
+async function generateStaticPaths(data, staticPathsDef) {
+  const paths = [];
+  for (const item of data) {
+    const params = {};
+    for (const [paramName, paramExpr] of Object.entries(staticPathsDef.params)) {
+      params[paramName] = evaluateParamExpression(paramExpr, item);
+    }
+    paths.push({ params, data: item });
+  }
+  return paths;
+}
+var DataLoader = class {
+  cache = /* @__PURE__ */ new Map();
+  projectRoot;
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  /**
+   * Load a single data source
+   */
+  async loadDataSource(name, dataSource) {
+    if (this.cache.has(name)) {
+      return this.cache.get(name);
+    }
+    let data;
+    switch (dataSource.type) {
+      case "glob":
+        if (!dataSource.pattern) {
+          throw new Error(`Glob data source '${name}' requires pattern`);
+        }
+        data = await loadGlob(this.projectRoot, dataSource.pattern, dataSource.transform);
+        break;
+      case "file":
+        if (!dataSource.path) {
+          throw new Error(`File data source '${name}' requires path`);
+        }
+        data = await loadFile(this.projectRoot, dataSource.path, dataSource.transform);
+        break;
+      case "api":
+        if (!dataSource.url) {
+          throw new Error(`API data source '${name}' requires url`);
+        }
+        data = await loadApi(dataSource.url, dataSource.transform);
+        break;
+      default:
+        throw new Error(`Unknown data source type: ${dataSource.type}`);
+    }
+    this.cache.set(name, data);
+    return data;
+  }
+  /**
+   * Load all data sources
+   */
+  async loadAllDataSources(dataSources) {
+    const result = {};
+    for (const [name, source] of Object.entries(dataSources)) {
+      result[name] = await this.loadDataSource(name, source);
+    }
+    return result;
+  }
+  /**
+   * Clear cache for a specific data source or all caches
+   */
+  clearCache(name) {
+    if (name) {
+      this.cache.delete(name);
+    } else {
+      this.cache.clear();
+    }
+  }
+  /**
+   * Clear all cache entries
+   */
+  clearAllCache() {
+    this.cache.clear();
+  }
+  /**
+   * Get the current cache size
+   */
+  getCacheSize() {
+    return this.cache.size;
+  }
+};
 export {
+  DataLoader,
+  LayoutResolver,
   build,
   createAPIHandler,
   createAdapter,
@@ -667,8 +732,20 @@ export {
   createMiddlewareChain,
   filePathToPattern,
   generateStaticPages,
+  generateStaticPaths,
   getMimeType,
+  isPageExportFunction,
   isPathSafe,
+  loadApi,
+  loadFile,
+  loadGlob,
+  loadLayout,
+  resolveLayout,
+  resolvePageExport,
   resolveStaticFile,
-  scanRoutes
+  scanLayouts,
+  scanRoutes,
+  transformCsv,
+  transformMdx,
+  transformYaml
 };