@constela/start 0.3.1 → 0.4.1

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { CompiledProgram } from '@constela/compiler';
+import { LayoutProgram, Program, StaticPathsDefinition, DataSource } from '@constela/core';
 
 /**
  * Scanned route from file system
@@ -38,11 +39,22 @@ interface MiddlewareContext {
 }
 type MiddlewareNext = () => Promise<Response>;
 type Middleware = (ctx: MiddlewareContext, next: MiddlewareNext) => Promise<Response> | Response;
+/**
+ * Function-form page export that receives route params.
+ *
+ * @example
+ * // pages/users/[id].ts
+ * export default async function(params: Record<string, string>) {
+ *   const user = await fetchUser(params.id);
+ *   return createUserPage(user);
+ * }
+ */
+type PageExportFunction = (params: Record<string, string>) => Promise<CompiledProgram> | CompiledProgram;
 /**
  * Page module with Constela program
  */
 interface PageModule {
-    default: CompiledProgram;
+    default: CompiledProgram | PageExportFunction;
     getStaticPaths?: () => Promise<StaticPathsResult> | StaticPathsResult;
 }
 interface StaticPathsResult {
@@ -185,14 +197,30 @@ interface BuildResult {
  */
 declare function build(options?: BuildOptions): Promise<BuildResult>;
 
+/**
+ * Provider function for static paths when getStaticPaths is not available in the module.
+ * Used for dependency injection in tests.
+ */
+type StaticPathsProvider = (pattern: string) => StaticPathsResult | null | Promise<StaticPathsResult | null>;
+/**
+ * Options for generateStaticPages function
+ */
+interface GenerateStaticPagesOptions {
+    /**
+     * Optional provider for static paths when module doesn't export getStaticPaths.
+     * Primarily used for testing purposes.
+     */
+    staticPathsProvider?: StaticPathsProvider;
+}
 /**
  * Generate static pages for SSG routes
  *
  * @param routes - Array of scanned routes
  * @param outDir - Output directory for generated HTML files
+ * @param options - Optional configuration including staticPathsProvider for DI
  * @returns Array of generated file paths
  */
-declare function generateStaticPages(routes: ScannedRoute[], outDir: string): Promise<string[]>;
+declare function generateStaticPages(routes: ScannedRoute[], outDir: string, options?: GenerateStaticPagesOptions): Promise<string[]>;
 
 /**
  * Create handler function from API module
@@ -227,4 +255,187 @@ interface EdgeAdapter {
  */
 declare function createAdapter(options: AdapterOptions): EdgeAdapter;
 
-export { type APIContext, type APIModule, type BuildOptions, type ConstelaConfig, type DevServerOptions, type Middleware, type MiddlewareContext, type MiddlewareNext, type PageModule, type ScannedRoute, type StaticFileResult, type StaticPathsResult, build, createAPIHandler, createAdapter, createDevServer, createMiddlewareChain, filePathToPattern, generateStaticPages, getMimeType, isPathSafe, resolveStaticFile, scanRoutes };
+/**
+ * Type guard to check if a page export is a function (dynamic) or a static program
+ *
+ * @param exported - The default export from a page module
+ * @returns true if the export is a function, false if it's a static CompiledProgram
+ */
+declare function isPageExportFunction(exported: CompiledProgram | PageExportFunction): exported is PageExportFunction;
+/**
+ * Resolve a page export to a CompiledProgram
+ *
+ * If the export is a function, it will be called with the route params.
+ * If the export is a static CompiledProgram, it will be returned as-is.
+ *
+ * @param pageDefault - The default export from a page module (function or static program)
+ * @param params - Route parameters extracted from the URL
+ * @param expectedParams - Optional array of expected parameter names for validation
+ * @returns Promise resolving to a CompiledProgram
+ * @throws Error if expectedParams is provided and a required param is missing
+ */
+declare function resolvePageExport(pageDefault: CompiledProgram | PageExportFunction, params: Record<string, string>, expectedParams?: string[]): Promise<CompiledProgram>;
+
+/**
+ * Layout Resolver - Scans and resolves layout files for Constela Start
+ *
+ * This module provides functionality to:
+ * - Scan layout directories for layout files
+ * - Resolve layout by name
+ * - Load and validate layout programs
+ * - Compose layouts with page content
+ */
+
+interface ScannedLayout {
+    name: string;
+    file: string;
+}
+interface LayoutInfo {
+    name: string;
+    file: string;
+    program?: LayoutProgram;
+}
+/**
+ * Scans a directory for layout files
+ *
+ * @param layoutsDir - Directory to scan for layouts
+ * @returns Array of scanned layouts with name and file path
+ * @throws Error if directory doesn't exist or is not a directory
+ */
+declare function scanLayouts(layoutsDir: string): Promise<ScannedLayout[]>;
+/**
+ * Resolves a layout by name from scanned layouts
+ *
+ * @param layoutName - Name of the layout to resolve
+ * @param layouts - Array of scanned layouts
+ * @returns The matching layout or undefined
+ */
+declare function resolveLayout(layoutName: string, layouts: ScannedLayout[]): ScannedLayout | undefined;
+/**
+ * Loads and validates a layout file
+ *
+ * @param layoutFile - Path to the layout file
+ * @returns The loaded LayoutProgram
+ * @throws Error if file cannot be loaded or is not a valid layout
+ */
+declare function loadLayout(layoutFile: string): Promise<LayoutProgram>;
+/**
+ * LayoutResolver - Manages layout scanning, resolution, and composition
+ */
+declare class LayoutResolver {
+    private layoutsDir;
+    private layouts;
+    private loadedLayouts;
+    private initialized;
+    constructor(layoutsDir: string);
+    /**
+     * Initialize the resolver by scanning the layouts directory
+     */
+    initialize(): Promise<void>;
+    /**
+     * Check if a layout exists
+     */
+    hasLayout(name: string): boolean;
+    /**
+     * Get a layout by name
+     *
+     * @param name - Layout name
+     * @returns The layout program or undefined if not found
+     */
+    getLayout(name: string): Promise<LayoutProgram | undefined>;
+    /**
+     * 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
+     */
+    composeWithLayout(page: Program): Promise<Program>;
+    /**
+     * Get all scanned layouts
+     */
+    getAll(): ScannedLayout[];
+}
+
+/**
+ * Data Loader for Build-time Content Loading
+ *
+ * This module provides utilities for loading data sources at build time:
+ * - Glob patterns for multiple files
+ * - Single file loading
+ * - API fetching
+ * - MDX/YAML/CSV transformations
+ * - Static path generation for SSG
+ */
+
+interface GlobResult {
+    file: string;
+    raw: string;
+    frontmatter?: Record<string, unknown>;
+    content?: string;
+}
+interface StaticPath {
+    params: Record<string, string>;
+    data?: unknown;
+}
+/**
+ * Transform MDX content - parse frontmatter and content
+ */
+declare function transformMdx(content: string): {
+    frontmatter: Record<string, unknown>;
+    content: string;
+};
+/**
+ * Transform YAML content
+ */
+declare function transformYaml(content: string): Record<string, unknown>;
+/**
+ * Transform CSV content to array of objects
+ */
+declare function transformCsv(content: string): Record<string, string>[];
+/**
+ * Load files matching a glob pattern
+ */
+declare function loadGlob(baseDir: string, pattern: string, transform?: string): Promise<GlobResult[]>;
+/**
+ * Load a single file
+ */
+declare function loadFile(baseDir: string, filePath: string, transform?: string): Promise<unknown>;
+/**
+ * Load data from API endpoint
+ */
+declare function loadApi(url: string, transform?: string): Promise<unknown>;
+/**
+ * Generate static paths from data using params expression
+ */
+declare function generateStaticPaths(data: unknown[], staticPathsDef: StaticPathsDefinition): Promise<StaticPath[]>;
+/**
+ * DataLoader class for managing data source loading with caching
+ */
+declare class DataLoader {
+    private cache;
+    private projectRoot;
+    constructor(projectRoot: string);
+    /**
+     * Load a single data source
+     */
+    loadDataSource(name: string, dataSource: DataSource): Promise<unknown>;
+    /**
+     * Load all data sources
+     */
+    loadAllDataSources(dataSources: Record<string, DataSource>): Promise<Record<string, unknown>>;
+    /**
+     * Clear cache for a specific data source or all caches
+     */
+    clearCache(name?: string): void;
+    /**
+     * Clear all cache entries
+     */
+    clearAllCache(): void;
+    /**
+     * Get the current cache size
+     */
+    getCacheSize(): number;
+}
+
+export { type APIContext, type APIModule, type BuildOptions, type ConstelaConfig, DataLoader, type DevServerOptions, type GenerateStaticPagesOptions, type GlobResult, type LayoutInfo, LayoutResolver, type Middleware, type MiddlewareContext, type MiddlewareNext, type PageExportFunction, type PageModule, type ScannedLayout, type ScannedRoute, type StaticFileResult, type StaticPath, type StaticPathsProvider, type StaticPathsResult, build, createAPIHandler, createAdapter, createDevServer, createMiddlewareChain, filePathToPattern, generateStaticPages, generateStaticPaths, getMimeType, isPageExportFunction, isPathSafe, loadApi, loadFile, loadGlob, loadLayout, resolveLayout, resolvePageExport, resolveStaticFile, scanLayouts, scanRoutes, transformCsv, transformMdx, transformYaml };

package/dist/index.js

@@ -16,6 +16,26 @@ import {
 // src/build/ssg.ts
 import { mkdir, writeFile } from "fs/promises";
 import { join, dirname } from "path";
+
+// src/utils/resolve-page.ts
+function isPageExportFunction(exported) {
+  return typeof exported === "function";
+}
+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}`);
+      }
+    }
+  }
+  if (isPageExportFunction(pageDefault)) {
+    return await pageDefault(params);
+  }
+  return pageDefault;
+}
+
+// src/build/ssg.ts
 var defaultProgram = {
   version: "1.0",
   state: {},
@@ -27,18 +47,6 @@ 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 join(outDir, "index.html");
@@ -61,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;
 }
@@ -88,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,
@@ -111,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);
     }
@@ -222,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;
@@ -257,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,
@@ -274,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,
@@ -284,8 +732,20 @@ export {
   createMiddlewareChain,
   filePathToPattern,
   generateStaticPages,
+  generateStaticPaths,
   getMimeType,
+  isPageExportFunction,
   isPathSafe,
+  loadApi,
+  loadFile,
+  loadGlob,
+  loadLayout,
+  resolveLayout,
+  resolvePageExport,
   resolveStaticFile,
-  scanRoutes
+  scanLayouts,
+  scanRoutes,
+  transformCsv,
+  transformMdx,
+  transformYaml
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constela/start",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "description": "Meta-framework for Constela applications",
   "type": "module",
   "main": "./dist/index.js",
@@ -39,10 +39,11 @@
     "remark-mdx": "^3.0.0",
     "remark-gfm": "^4.0.0",
     "gray-matter": "^4.0.0",
-    "@constela/compiler": "0.4.0",
-    "@constela/runtime": "0.7.0",
-    "@constela/server": "0.1.2",
-    "@constela/router": "4.0.0"
+    "@constela/core": "0.6.0",
+    "@constela/router": "6.0.0",
+    "@constela/server": "2.0.0",
+    "@constela/runtime": "0.9.0",
+    "@constela/compiler": "0.6.0"
   },
   "devDependencies": {
     "typescript": "^5.3.0",