@constela/start 1.1.0 → 1.2.1

package/dist/index.js

@@ -1,17 +1,32 @@
 import {
+  DataLoader,
+  LayoutResolver,
   build,
   createDevServer,
   filePathToPattern,
+  generateStaticPaths,
   getMimeType,
   isPathSafe,
+  loadApi,
+  loadComponentDefinitions,
+  loadFile,
+  loadGlob,
+  loadLayout,
+  mdxContentToNode,
+  mdxToConstela,
+  resolveLayout,
   resolveStaticFile,
-  scanRoutes
-} from "./chunk-JXIOHPG5.js";
+  scanLayouts,
+  scanRoutes,
+  transformCsv,
+  transformMdx,
+  transformYaml
+} from "./chunk-6AN7W7KZ.js";
 import {
   generateHydrationScript,
   renderPage,
   wrapHtml
-} from "./chunk-QLDID7EZ.js";
+} from "./chunk-PUTC5BCP.js";
 
 // src/build/ssg.ts
 import { mkdir, writeFile } from "fs/promises";
@@ -89,7 +104,12 @@ async function generateSinglePage(pattern, outDir, program, params = {}) {
     query: new URLSearchParams()
   };
   const content = await renderPage(program, ctx);
-  const hydrationScript = generateHydrationScript(program);
+  const routeContext = {
+    params,
+    query: {},
+    path: pattern
+  };
+  const hydrationScript = generateHydrationScript(program, void 0, routeContext);
   const html = wrapHtml(content, hydrationScript);
   await writeFile(outputPath, html, "utf-8");
   return outputPath;
@@ -109,6 +129,12 @@ async function generateStaticPages(routes, outDir, options = {}) {
       }
       for (const pathData of staticPaths.paths) {
         const program = await resolvePageExport(pageExport, pathData.params, route.params);
+        if (pathData.data !== void 0) {
+          program.importData = {
+            ...program.importData,
+            __pathData: pathData.data
+          };
+        }
         const resolvedPattern = resolvePattern(route.pattern, pathData.params);
         const filePath = await generateSinglePage(
           resolvedPattern,
@@ -231,7 +257,7 @@ function createErrorResponse(error) {
 }
 function createAdapter(options) {
   const { routes, loadModule = defaultLoadModule } = options;
-  async function fetch2(request) {
+  async function fetch(request) {
     try {
       const url = new URL(request.url);
       let pathname = url.pathname;
@@ -272,7 +298,12 @@ function createAdapter(options) {
           params: matchedParams,
           query: url.searchParams
         });
-        const hydrationScript = generateHydrationScript(program);
+        const routeContext = {
+          params: matchedParams,
+          query: Object.fromEntries(url.searchParams.entries()),
+          path: url.pathname
+        };
+        const hydrationScript = generateHydrationScript(program, void 0, routeContext);
         const html = wrapHtml(content, hydrationScript);
         return new Response(html, {
           status: 200,
@@ -283,915 +314,8 @@ function createAdapter(options) {
       return createErrorResponse(error);
     }
   }
-  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 { basename as basename2, extname, join as join3 } from "path";
-import fg2 from "fast-glob";
-
-// src/build/mdx.ts
-import { unified } from "unified";
-import remarkParse from "remark-parse";
-import remarkMdx from "remark-mdx";
-import remarkGfm from "remark-gfm";
-import matter from "gray-matter";
-function lit(value) {
-  return { expr: "lit", value };
-}
-function textNode(value) {
-  return { kind: "text", value: lit(value) };
-}
-function elementNode(tag, props, children) {
-  const node = { kind: "element", tag };
-  if (props && Object.keys(props).length > 0) {
-    node.props = props;
-  }
-  if (children && children.length > 0) {
-    node.children = children;
-  }
-  return node;
-}
-function codeNode(language, content) {
-  return {
-    kind: "code",
-    language: lit(language),
-    content: lit(content)
-  };
-}
-function wrapNodes(nodes) {
-  if (nodes.length === 0) {
-    return elementNode("div");
-  }
-  if (nodes.length === 1 && nodes[0]) {
-    return nodes[0];
-  }
-  return elementNode("div", void 0, nodes);
-}
-function isCustomComponent(name) {
-  if (!name) return false;
-  return /^[A-Z]/.test(name);
-}
-var DISALLOWED_PATTERNS = [
-  /\bfunction\b/i,
-  /\b(eval|Function|setTimeout|setInterval)\b/,
-  /\bimport\b/,
-  /\brequire\b/,
-  /\bfetch\b/,
-  /\bwindow\b/,
-  /\bdocument\b/,
-  /\bglobal\b/,
-  /\bprocess\b/,
-  /\b__proto__\b/,
-  /\bconstructor\b/,
-  /\bprototype\b/
-];
-function isSafeLiteral(value) {
-  return !DISALLOWED_PATTERNS.some((pattern) => pattern.test(value));
-}
-function safeEvalLiteral(value) {
-  try {
-    return JSON.parse(value);
-  } catch {
-  }
-  if (!isSafeLiteral(value)) {
-    return null;
-  }
-  try {
-    const fn = new Function(`return (${value});`);
-    return fn();
-  } catch {
-    return null;
-  }
-}
-function parseAttributeValue(attr) {
-  if (attr.value === null) {
-    return lit(true);
-  }
-  if (typeof attr.value === "string") {
-    return lit(attr.value);
-  }
-  if (attr.value.type === "mdxJsxAttributeValueExpression") {
-    const exprValue = attr.value.value.trim();
-    if (exprValue === "true") return lit(true);
-    if (exprValue === "false") return lit(false);
-    if (exprValue === "null") return lit(null);
-    const num = Number(exprValue);
-    if (!Number.isNaN(num)) return lit(num);
-    if (exprValue.startsWith("[") || exprValue.startsWith("{")) {
-      const parsed = safeEvalLiteral(exprValue);
-      if (parsed !== null && parsed !== void 0) {
-        return lit(parsed);
-      }
-    }
-    return lit(exprValue);
-  }
-  return lit(null);
-}
-function transformNode(node, ctx) {
-  switch (node.type) {
-    case "heading":
-      return elementNode(
-        `h${node.depth}`,
-        void 0,
-        transformChildren(node.children, ctx)
-      );
-    case "paragraph":
-      return elementNode("p", void 0, transformChildren(node.children, ctx));
-    case "text":
-      return textNode(node.value);
-    case "emphasis":
-      return elementNode("em", void 0, transformChildren(node.children, ctx));
-    case "strong":
-      return elementNode("strong", void 0, transformChildren(node.children, ctx));
-    case "link": {
-      const props = {
-        href: lit(node.url)
-      };
-      if (node["title"]) {
-        props["title"] = lit(node["title"]);
-      }
-      return elementNode("a", props, transformChildren(node.children, ctx));
-    }
-    case "inlineCode":
-      return elementNode("code", void 0, [textNode(node.value)]);
-    case "code": {
-      const lang = node.lang || "text";
-      return codeNode(lang, node.value);
-    }
-    case "blockquote":
-      return elementNode("blockquote", void 0, transformChildren(node.children, ctx));
-    case "list": {
-      const tag = node.ordered ? "ol" : "ul";
-      return elementNode(tag, void 0, transformChildren(node.children, ctx));
-    }
-    case "listItem": {
-      const children = [];
-      for (const child of node.children) {
-        if (child.type === "paragraph") {
-          children.push(...transformChildren(child.children, ctx));
-        } else {
-          const transformed = transformNode(child, ctx);
-          if (transformed) {
-            if (Array.isArray(transformed)) {
-              children.push(...transformed);
-            } else {
-              children.push(transformed);
-            }
-          }
-        }
-      }
-      return elementNode("li", void 0, children);
-    }
-    case "thematicBreak":
-      return elementNode("hr");
-    case "break":
-      return elementNode("br");
-    case "image": {
-      const props = {
-        src: lit(node.url)
-      };
-      if (node["alt"]) {
-        props["alt"] = lit(node["alt"]);
-      }
-      if (node["title"]) {
-        props["title"] = lit(node["title"]);
-      }
-      return elementNode("img", props);
-    }
-    case "html":
-      return textNode(node.value);
-    // MDX JSX elements
-    case "mdxJsxFlowElement":
-    case "mdxJsxTextElement":
-      return transformJsxElement(node, ctx);
-    // MDX expressions
-    case "mdxFlowExpression":
-    case "mdxTextExpression": {
-      const exprNode = node;
-      const value = exprNode.value.trim();
-      if (value === "") return null;
-      if (value === "true") return textNode("true");
-      if (value === "false") return textNode("false");
-      if (value === "null") return textNode("null");
-      const num = Number(value);
-      if (!Number.isNaN(num)) return textNode(String(num));
-      return textNode(value);
-    }
-    // GFM extensions
-    case "table":
-      return elementNode("table", void 0, transformChildren(node.children, ctx));
-    case "tableRow":
-      return elementNode("tr", void 0, transformChildren(node.children, ctx));
-    case "tableCell":
-      return elementNode("td", void 0, transformChildren(node.children, ctx));
-    case "delete":
-      return elementNode("del", void 0, transformChildren(node.children, ctx));
-    default:
-      return null;
-  }
-}
-function transformJsxElement(node, ctx) {
-  const name = node.name;
-  if (!name) {
-    const children2 = transformChildren(node.children, ctx);
-    return wrapNodes(children2);
-  }
-  if (isCustomComponent(name)) {
-    const def = ctx.components[name];
-    if (!def) {
-      throw new Error(`Undefined component: ${name}`);
-    }
-    const props2 = {};
-    for (const attr of node.attributes) {
-      if (attr.type === "mdxJsxAttribute") {
-        props2[attr.name] = parseAttributeValue(attr);
-      }
-    }
-    const children2 = transformChildren(node.children, ctx);
-    return applyComponentView(def.view, props2, children2);
-  }
-  const props = {};
-  for (const attr of node.attributes) {
-    if (attr.type === "mdxJsxAttribute") {
-      props[attr.name] = parseAttributeValue(attr);
-    }
-  }
-  const children = transformChildren(node.children, ctx);
-  return elementNode(name, props, children);
-}
-function substituteExpression(expr, props) {
-  const exprAny = expr;
-  if (exprAny.expr === "param") {
-    const paramExpr = expr;
-    const propValue = props[paramExpr.name];
-    if (!propValue) {
-      return { expr: "lit", value: null };
-    }
-    if (paramExpr.path && propValue.expr === "var") {
-      const varExpr = propValue;
-      return {
-        expr: "var",
-        name: varExpr.name,
-        path: paramExpr.path
-      };
-    }
-    return propValue;
-  }
-  if (expr.expr === "bin") {
-    const binExpr = expr;
-    return {
-      expr: "bin",
-      op: binExpr.op,
-      left: substituteExpression(binExpr.left, props),
-      right: substituteExpression(binExpr.right, props)
-    };
-  }
-  if (expr.expr === "not") {
-    const notExpr = expr;
-    return {
-      expr: "not",
-      operand: substituteExpression(notExpr.operand, props)
-    };
-  }
-  if (expr.expr === "cond") {
-    const condExpr = expr;
-    return {
-      expr: "cond",
-      if: substituteExpression(condExpr.if, props),
-      then: substituteExpression(condExpr.then, props),
-      else: substituteExpression(condExpr.else, props)
-    };
-  }
-  if (expr.expr === "get") {
-    const getExpr = expr;
-    return {
-      expr: "get",
-      base: substituteExpression(getExpr.base, props),
-      path: getExpr.path
-    };
-  }
-  return expr;
-}
-function applyComponentView(view, props, children) {
-  return substituteInNode(view, props, children);
-}
-function substituteInNode(node, props, children) {
-  switch (node.kind) {
-    case "each": {
-      const eachNode = node;
-      const result = {
-        kind: "each",
-        items: substituteExpression(eachNode.items, props),
-        as: eachNode.as,
-        body: substituteInNode(eachNode.body, props, children)
-      };
-      if (eachNode.index) {
-        result.index = eachNode.index;
-      }
-      if (eachNode.key) {
-        result.key = substituteExpression(eachNode.key, props);
-      }
-      return result;
-    }
-    case "text": {
-      const textNode2 = node;
-      return {
-        kind: "text",
-        value: substituteExpression(textNode2.value, props)
-      };
-    }
-    case "if": {
-      const ifNode = node;
-      const result = {
-        kind: "if",
-        condition: substituteExpression(ifNode.condition, props),
-        then: substituteInNode(ifNode.then, props, children)
-      };
-      if (ifNode.else) {
-        result.else = substituteInNode(ifNode.else, props, children);
-      }
-      return result;
-    }
-    case "element": {
-      const elem = node;
-      const newProps = {};
-      if (elem.props) {
-        for (const [key, value] of Object.entries(elem.props)) {
-          newProps[key] = substituteExpression(value, props);
-        }
-      }
-      let newChildren;
-      if (elem.children) {
-        newChildren = [];
-        for (const child of elem.children) {
-          if (child.kind === "slot") {
-            newChildren.push(...children);
-          } else {
-            newChildren.push(substituteInNode(child, props, children));
-          }
-        }
-      }
-      return elementNode(
-        elem.tag,
-        Object.keys(newProps).length > 0 ? newProps : void 0,
-        newChildren && newChildren.length > 0 ? newChildren : void 0
-      );
-    }
-    case "markdown":
-    case "code":
-      return node;
-    default:
-      return node;
-  }
-}
-function transformChildren(children, ctx) {
-  const result = [];
-  for (const child of children) {
-    const transformed = transformNode(child, ctx);
-    if (transformed) {
-      if (Array.isArray(transformed)) {
-        result.push(...transformed);
-      } else {
-        result.push(transformed);
-      }
-    }
-  }
-  return result;
-}
-function transformRoot(root, ctx) {
-  const nodes = transformChildren(root.children, ctx);
-  return wrapNodes(nodes);
-}
-async function mdxToConstela(source, options) {
-  const { content, data: _frontmatter } = matter(source);
-  const processor = unified().use(remarkParse).use(remarkGfm).use(remarkMdx);
-  const tree = processor.parse(content);
-  const ctx = {
-    components: options?.components ?? {}
-  };
-  const view = transformRoot(tree, ctx);
-  return {
-    version: "1.0",
-    state: {},
-    actions: {},
-    view
-  };
-}
-async function mdxContentToNode(content, options) {
-  const processor = unified().use(remarkParse).use(remarkGfm).use(remarkMdx);
-  const tree = processor.parse(content);
-  const ctx = {
-    components: options?.components ?? {}
-  };
-  return transformRoot(tree, ctx);
-}
-
-// src/data/loader.ts
-var mdxContentToNode2 = mdxContentToNode;
-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 loadComponentDefinitions(baseDir, componentsPath) {
-  const fullPath = join3(baseDir, componentsPath);
-  const resolvedBase = join3(baseDir, "");
-  const resolvedPath = join3(fullPath, "");
-  if (!resolvedPath.startsWith(resolvedBase)) {
-    throw new Error(`Invalid component path: path traversal detected`);
-  }
-  if (!existsSync2(fullPath)) {
-    throw new Error(`MDX components file not found: ${fullPath}`);
-  }
-  const content = readFileSync(fullPath, "utf-8");
-  try {
-    return JSON.parse(content);
-  } catch {
-    throw new Error(`Invalid JSON in MDX components file: ${fullPath}`);
-  }
-}
-async function transformMdx(content, file, options) {
-  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
-  let frontmatter = {};
-  let mdxContent;
-  if (match) {
-    frontmatter = parseYaml(match[1]);
-    mdxContent = match[2].trim();
-  } else {
-    mdxContent = content.trim();
-  }
-  const compiledContent = await mdxContentToNode(
-    mdxContent,
-    options?.components ? { components: options.components } : void 0
-  );
-  const fmSlug = frontmatter["slug"];
-  const slug = typeof fmSlug === "string" ? fmSlug : basename2(file, extname(file));
-  return {
-    file,
-    raw: content,
-    frontmatter,
-    content: compiledContent,
-    slug
-  };
-}
-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":
-      throw new Error("MDX transform for single files is not supported via loadFile. Use loadGlob instead.");
-    case "yaml":
-      return transformYaml(content);
-    case "csv":
-      return transformCsv(content);
-    default:
-      return content;
-  }
-}
-async function loadGlob(baseDir, pattern, transform, options) {
-  const files = await fg2(pattern, { cwd: baseDir });
-  if (transform === "mdx") {
-    const results2 = [];
-    for (const file of files) {
-      const fullPath = join3(baseDir, file);
-      const content = readFileSync(fullPath, "utf-8");
-      const transformed = await transformMdx(content, file, options);
-      results2.push(transformed);
-    }
-    return results2;
-  }
-  const results = [];
-  for (const file of files) {
-    const fullPath = join3(baseDir, file);
-    const content = readFileSync(fullPath, "utf-8");
-    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) : "";
+  return { fetch };
 }
-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();
-  componentCache = /* @__PURE__ */ new Map();
-  projectRoot;
-  constructor(projectRoot) {
-    this.projectRoot = projectRoot;
-  }
-  /**
-   * Resolve components from string path or import reference
-   */
-  resolveComponents(ref, imports) {
-    if (typeof ref === "string") {
-      if (this.componentCache.has(ref)) {
-        return this.componentCache.get(ref);
-      }
-      const defs = loadComponentDefinitions(this.projectRoot, ref);
-      this.componentCache.set(ref, defs);
-      return defs;
-    }
-    if (ref.expr === "import") {
-      if (!imports) {
-        throw new Error(`Import context required for component reference "${ref.name}"`);
-      }
-      const imported = imports[ref.name];
-      if (!imported || typeof imported !== "object") {
-        throw new Error(`Component import "${ref.name}" not found or invalid`);
-      }
-      return imported;
-    }
-    return {};
-  }
-  /**
-   * Load a single data source
-   */
-  async loadDataSource(name, dataSource, context) {
-    if (this.cache.has(name)) {
-      return this.cache.get(name);
-    }
-    let componentDefs;
-    if (dataSource.transform === "mdx" && dataSource.components) {
-      componentDefs = this.resolveComponents(
-        dataSource.components,
-        context?.imports
-      );
-    }
-    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,
-          componentDefs ? { components: componentDefs } : void 0
-        );
-        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,
@@ -1211,7 +335,7 @@ export {
   loadFile,
   loadGlob,
   loadLayout,
-  mdxContentToNode2 as mdxContentToNode,
+  mdxContentToNode,
   mdxToConstela,
   resolveLayout,
   resolvePageExport,