@emkodev/emroute 1.6.6-beta.2 → 1.6.6-beta.4

package/src/type/route-tree.type.ts

@@ -13,6 +13,8 @@
 export interface RouteFiles {
   /** TypeScript module (e.g. "routes/about.page.ts") */
   ts?: string;
+  /** JavaScript module — merged module with inlined companions (e.g. "routes/about.page.js") */
+  js?: string;
   /** HTML template (e.g. "routes/about.page.html") */
   html?: string;
   /** Markdown content (e.g. "routes/about.page.md") */

package/src/type/route.type.ts

@@ -10,17 +10,11 @@ export type RouteParams = Readonly<Record<string, string>>;
 
 /** Immutable route context built once per navigation, shared across the render pipeline. */
 export interface RouteInfo {
-  /** Actual URL path (e.g., '/projects/123') */
-  readonly pathname: string;
+  /** The URL being rendered. Components read pathname, searchParams, hash from this. */
+  readonly url: URL;
 
-  /** Matched route pattern (e.g., '/projects/:id') */
-  readonly pattern: string;
-
-  /** URL parameters extracted by the router */
+  /** URL parameters extracted by the trie match. */
   readonly params: RouteParams;
-
-  /** Query string parameters */
-  readonly searchParams: URLSearchParams;
 }
 
 /** Supported file patterns in file-based routing */
@@ -37,6 +31,9 @@ export interface RouteFiles {
   /** TypeScript module path (.page.ts) */
   ts?: string;
 
+  /** JavaScript module — merged module with inlined companions (.page.js) */
+  js?: string;
+
   /** HTML template path (.page.html) */
   html?: string;
 
@@ -75,12 +72,6 @@ export interface MatchedRoute {
 
   /** Extracted URL parameters */
   readonly params: RouteParams;
-
-  /** Query string parameters from the matched URL */
-  readonly searchParams?: URLSearchParams;
-
-  /** The URLPatternResult from matching */
-  readonly patternResult?: URLPatternResult;
 }
 
 /** Error boundary configuration */
@@ -92,23 +83,7 @@ export interface ErrorBoundary {
   modulePath: string;
 }
 
-/** Generated routes manifest from build tool */
-export interface RoutesManifest {
-  /** All page routes */
-  routes: RouteConfig[];
-
-  /** Error boundaries by pattern prefix */
-  errorBoundaries: ErrorBoundary[];
-
-  /** Status-specific pages (404, 401, 403) */
-  statusPages: Map<number, RouteConfig>;
-
-  /** Generic error handler */
-  errorHandler?: RouteConfig;
-
-  /** Pre-bundled module loaders keyed by module path (for SPA bundles) */
-  moduleLoaders?: Record<string, () => Promise<unknown>>;
-}
+export type { RouteNode } from './route-tree.type.ts';
 
 /** Router state for history management */
 export interface RouterState {

package/src/util/md.util.ts

@@ -0,0 +1,31 @@
+/**
+ * Markdown Link Rewriting
+ *
+ * Rewrites internal absolute links in markdown to include a base path prefix.
+ * Skips fenced code blocks and links already under a known base path.
+ */
+
+/** Rewrite internal absolute links in markdown to include the base path prefix. */
+export function rewriteMdLinks(markdown: string, base: string, skipPrefixes: string[]): string {
+  const prefix = base + '/';
+  // Negative lookahead: skip links already under a known base path
+  const skip = skipPrefixes.map((p) => p.slice(1) + '/').join('|');
+  const inlineRe = new RegExp(`\\]\\(\\/(?!${skip})`, 'g');
+  const refRe = new RegExp(`^(\\[[^\\]]+\\]:\\s+)\\/(?!${skip})`, 'g');
+
+  const lines = markdown.split('\n');
+  let inCodeBlock = false;
+
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].startsWith('```')) {
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
+    if (inCodeBlock) continue;
+
+    lines[i] = lines[i].replaceAll(inlineRe, `](${prefix}`);
+    lines[i] = lines[i].replaceAll(refRe, `$1${prefix}`);
+  }
+
+  return lines.join('\n');
+}

package/src/util/widget-resolve.util.ts

@@ -118,7 +118,12 @@ export function resolveWidgetTags(
         files = await loadFiles(widgetName, widget.files);
       }
 
-      const baseContext = { ...routeInfo, files };
+      const baseContext = {
+        ...routeInfo,
+        pathname: routeInfo.url.pathname,
+        searchParams: routeInfo.url.searchParams,
+        files,
+      };
       const context = contextProvider ? contextProvider(baseContext) : baseContext;
 
       const data = await widget.getData({ params, context });

package/src/widget/breadcrumb.widget.ts

@@ -17,7 +17,6 @@
 import { WidgetComponent } from '../component/widget.component.ts';
 import { escapeHtml } from '../util/html.util.ts';
 import type { ComponentContext } from '../component/abstract.component.ts';
-import { DEFAULT_BASE_PATH } from '../route/route.core.ts';
 
 const DEFAULT_HTML_SEPARATOR = ' \u203A ';
 const DEFAULT_MD_SEPARATOR = ' > ';
@@ -42,20 +41,14 @@ export class BreadcrumbWidget extends WidgetComponent<BreadcrumbParams, Breadcru
   override getData(
     args: { params: BreadcrumbParams; signal?: AbortSignal; context: ComponentContext },
   ): Promise<BreadcrumbData | null> {
-    const htmlBase = args.context.basePath ?? DEFAULT_BASE_PATH.html;
-    const pathname = args.context.pathname ?? this.resolvePathname(htmlBase);
-
-    // Skip basePath segments for display — only show route segments
-    const barePathname = htmlBase && pathname.startsWith(htmlBase)
-      ? pathname.slice(htmlBase.length) || '/'
-      : pathname;
-    const parts = barePathname.split('/').filter(Boolean);
+    const pathname = args.context.pathname || '/';
+    const parts = pathname.split('/').filter(Boolean);
 
     const segments: BreadcrumbSegment[] = [
-      { label: 'Home', href: htmlBase + '/' },
+      { label: 'Home', href: '/' },
     ];
 
-    let accumulated = htmlBase;
+    let accumulated = '';
     for (const part of parts) {
       accumulated += '/' + part;
       segments.push({
@@ -67,11 +60,6 @@ export class BreadcrumbWidget extends WidgetComponent<BreadcrumbParams, Breadcru
     return Promise.resolve({ segments });
   }
 
-  private resolvePathname(htmlBase: string): string {
-    if (typeof globalThis.location === 'undefined') return htmlBase + '/';
-    return location.pathname;
-  }
-
   override renderHTML(
     args: { data: BreadcrumbData | null; params: BreadcrumbParams; context: ComponentContext },
   ): string {

package/server/scanner.util.ts

@@ -1,243 +0,0 @@
-/**
- * Standalone Scanning Utilities
- *
- * Runtime-agnostic route and widget scanning. Works with any Runtime
- * that implements query() — used by tests with mock runtimes and by
- * the CLI generate command.
- *
- * Note: BunFsRuntime has these as instance methods with lazy caching.
- * These standalone functions are the same logic without caching.
- */
-
-import type { Runtime } from '../runtime/abstract.runtime.ts';
-import {
-  filePathToPattern,
-  getPageFileType,
-  getRouteType,
-  sortRoutesBySpecificity,
-} from '../src/route/route.matcher.ts';
-import type {
-  ErrorBoundary,
-  RouteConfig,
-  RouteFiles,
-  RoutesManifest,
-} from '../src/type/route.type.ts';
-import type { WidgetManifestEntry } from '../src/type/widget.type.ts';
-
-export interface GeneratorResult extends RoutesManifest {
-  warnings: string[];
-}
-
-/** Walk directory recursively and collect files via Runtime. */
-async function* walkDirectory(runtime: Runtime, dir: string): AsyncGenerator<string> {
-  const trailingDir = dir.endsWith('/') ? dir : dir + '/';
-  const response = await runtime.query(trailingDir);
-  const entries: string[] = await response.json();
-
-  for (const entry of entries) {
-    const path = `${trailingDir}${entry}`;
-    if (entry.endsWith('/')) {
-      yield* walkDirectory(runtime, path);
-    } else {
-      yield path;
-    }
-  }
-}
-
-/** Generate routes manifest by scanning a directory via Runtime. */
-export async function generateRoutesManifest(
-  routesDir: string,
-  runtime: Runtime,
-): Promise<GeneratorResult> {
-  const pageFiles: Array<{
-    path: string;
-    pattern: string;
-    fileType: 'ts' | 'html' | 'md' | 'css';
-  }> = [];
-  const redirects: RouteConfig[] = [];
-  const errorBoundaries: ErrorBoundary[] = [];
-  const statusPages = new Map<number, RouteConfig>();
-  let errorHandler: RouteConfig | undefined;
-
-  const allFiles: string[] = [];
-  for await (const file of walkDirectory(runtime, routesDir)) {
-    allFiles.push(file);
-  }
-
-  for (const filePath of allFiles) {
-    const relativePath = filePath.replace(`${routesDir}/`, '');
-    const filename = relativePath.split('/').pop() ?? '';
-
-    if (filename === 'index.error.ts' && relativePath === 'index.error.ts') {
-      errorHandler = {
-        pattern: '/',
-        type: 'error',
-        modulePath: filePath,
-      };
-      continue;
-    }
-
-    const cssFileType = getPageFileType(filename);
-    if (cssFileType === 'css') {
-      const pattern = filePathToPattern(relativePath);
-      pageFiles.push({ path: filePath, pattern, fileType: 'css' });
-      continue;
-    }
-
-    const routeType = getRouteType(filename);
-    if (!routeType) continue;
-
-    const statusMatch = filename.match(/^(\d{3})\.page\.(ts|html|md)$/);
-    if (statusMatch) {
-      const statusCode = parseInt(statusMatch[1], 10);
-      const fileType = getPageFileType(filename);
-      if (fileType) {
-        const existing = statusPages.get(statusCode);
-        if (existing) {
-          existing.files ??= {};
-          existing.files[fileType] = filePath;
-          existing.modulePath = existing.files.ts ?? existing.files.html ?? existing.files.md ?? '';
-        } else {
-          const files: RouteFiles = { [fileType]: filePath };
-          statusPages.set(statusCode, {
-            pattern: `/${statusCode}`,
-            type: 'page',
-            modulePath: filePath,
-            statusCode,
-            files,
-          });
-        }
-      }
-      continue;
-    }
-
-    const pattern = filePathToPattern(relativePath);
-
-    if (routeType === 'error') {
-      const boundaryPattern = pattern.replace(/\/[^/]+$/, '') || '/';
-      errorBoundaries.push({ pattern: boundaryPattern, modulePath: filePath });
-      continue;
-    }
-
-    if (routeType === 'redirect') {
-      redirects.push({ pattern, type: 'redirect', modulePath: filePath });
-      continue;
-    }
-
-    const fileType = getPageFileType(filename);
-    if (fileType) {
-      pageFiles.push({ path: filePath, pattern, fileType });
-    }
-  }
-
-  // Group files by pattern
-  const groups = new Map<string, { pattern: string; files: RouteFiles; parent?: string }>();
-  for (const { path, pattern, fileType } of pageFiles) {
-    let group = groups.get(pattern);
-    if (!group) {
-      group = { pattern, files: {} };
-      const segments = pattern.split('/').filter(Boolean);
-      if (segments.length > 1) {
-        group.parent = '/' + segments.slice(0, -1).join('/');
-      }
-      groups.set(pattern, group);
-    }
-    const existing = group.files[fileType];
-    if (existing?.includes('/index.page.') && !path.includes('/index.page.')) {
-      continue;
-    }
-    group.files[fileType] = path;
-  }
-
-  // Detect collisions
-  const warnings: string[] = [];
-  for (const [pattern, group] of groups) {
-    const filePaths = Object.values(group.files).filter(Boolean);
-    const hasIndex = filePaths.some((p) => p?.includes('/index.page.'));
-    const hasFlat = filePaths.some((p) => p && !p.includes('/index.page.'));
-    if (hasIndex && hasFlat) {
-      warnings.push(
-        `Warning: Mixed file structure for ${pattern}:\n` +
-          filePaths.map((p) => `     ${p}`).join('\n') +
-          `\n     Both folder/index and flat files detected`,
-      );
-    }
-  }
-
-  // Convert groups to RouteConfig array
-  const routes: RouteConfig[] = [];
-  for (const [_, group] of groups) {
-    const modulePath = group.files.ts ?? group.files.html ?? group.files.md ?? '';
-    if (!modulePath) continue;
-    const route: RouteConfig = {
-      pattern: group.pattern,
-      type: 'page',
-      modulePath,
-      files: group.files,
-    };
-    if (group.parent) route.parent = group.parent;
-    routes.push(route);
-  }
-
-  routes.push(...redirects);
-  const sortedRoutes = sortRoutesBySpecificity(routes);
-
-  return {
-    routes: sortedRoutes,
-    errorBoundaries,
-    statusPages,
-    errorHandler,
-    warnings,
-  };
-}
-
-/**
- * Discover widget modules and companion files by scanning a directory.
- */
-export async function discoverWidgets(
-  widgetsDir: string,
-  runtime: Runtime,
-  pathPrefix?: string,
-): Promise<WidgetManifestEntry[]> {
-  const COMPANION_EXTENSIONS = ['html', 'md', 'css'] as const;
-  const WIDGET_FILE_SUFFIX = '.widget.ts';
-  const entries: WidgetManifestEntry[] = [];
-
-  const trailingDir = widgetsDir.endsWith('/') ? widgetsDir : widgetsDir + '/';
-  const response = await runtime.query(trailingDir);
-  const listing: string[] = await response.json();
-
-  for (const item of listing) {
-    if (!item.endsWith('/')) continue;
-
-    const name = item.slice(0, -1);
-    const moduleFile = `${name}${WIDGET_FILE_SUFFIX}`;
-    const modulePath = `${trailingDir}${name}/${moduleFile}`;
-
-    if ((await runtime.query(modulePath)).status === 404) continue;
-
-    const prefix = pathPrefix ? `${pathPrefix}/` : '';
-    const entry: WidgetManifestEntry = {
-      name,
-      modulePath: `${prefix}${name}/${moduleFile}`,
-      tagName: `widget-${name}`,
-    };
-
-    const files: { html?: string; md?: string; css?: string } = {};
-    let hasFiles = false;
-    for (const ext of COMPANION_EXTENSIONS) {
-      const companionFile = `${name}.widget.${ext}`;
-      const companionPath = `${trailingDir}${name}/${companionFile}`;
-      if ((await runtime.query(companionPath)).status !== 404) {
-        files[ext] = `${prefix}${name}/${companionFile}`;
-        hasFiles = true;
-      }
-    }
-
-    if (hasFiles) entry.files = files;
-    entries.push(entry);
-  }
-
-  entries.sort((a, b) => a.name.localeCompare(b.name));
-  return entries;
-}

package/src/renderer/spa/base.renderer.ts

@@ -1,186 +0,0 @@
-/**
- * Base Renderer
- *
- * Shared rendering logic for SPA and Hash routers:
- * - Route hierarchy traversal with nested slot rendering
- * - Component loading, data fetching, and HTML rendering
- * - Markdown render waiting
- * - Document title updates
- */
-
-import type { MatchedRoute, RouteConfig, RouteInfo } from '../../type/route.type.ts';
-import defaultPageComponent, { type PageComponent } from '../../component/page.component.ts';
-import { DEFAULT_ROOT_ROUTE, RouteCore } from '../../route/route.core.ts';
-import { logger } from '../../util/logger.util.ts';
-
-const MARKDOWN_RENDER_TIMEOUT = 5000;
-
-/**
- * Abstract base for renderers that share the page rendering pipeline.
- * Subclasses provide navigation mechanics (Navigation API, hashchange, etc.).
- */
-export abstract class BaseRenderer {
-  protected core: RouteCore;
-  protected slot: Element | null = null;
-
-  constructor(core: RouteCore) {
-    this.core = core;
-  }
-
-  /**
-   * Render a matched page route with nested route support.
-   */
-  protected async renderPage(
-    routeInfo: RouteInfo,
-    matched: MatchedRoute,
-    signal: AbortSignal,
-  ): Promise<void> {
-    if (!this.slot) return;
-
-    try {
-      const hierarchy = this.core.buildRouteHierarchy(routeInfo.pattern);
-      logger.render('page', routeInfo.pattern, `hierarchy: ${hierarchy.join(' > ')}`);
-
-      let currentSlot: Element = this.slot;
-      let pageTitle: string | undefined;
-
-      for (let i = 0; i < hierarchy.length; i++) {
-        if (signal.aborted) return;
-
-        const routePattern = hierarchy[i];
-        const isLeaf = i === hierarchy.length - 1;
-
-        let route = this.core.findRoute(routePattern);
-
-        if (!route && routePattern === '/') {
-          route = DEFAULT_ROOT_ROUTE;
-        }
-
-        if (!route) {
-          logger.render('skip', routePattern, 'route not found');
-          continue;
-        }
-
-        const routeType = isLeaf ? 'leaf' : 'layout';
-        logger.render(routeType, routePattern, `${route.files?.ts ?? 'default'} → slot`);
-
-        // Skip wildcard route appearing as its own parent (prevents double-render)
-        if (route === matched.route && routePattern !== matched.route.pattern) {
-          continue;
-        }
-
-        const { html, title } = await this.renderRouteContent(routeInfo, route, signal, isLeaf);
-        if (signal.aborted) return;
-
-        currentSlot.setHTMLUnsafe(html);
-
-        if (title) {
-          pageTitle = title;
-        }
-
-        // Wait for <mark-down> to finish rendering its content
-        // (must happen before attributing slots — router-slot may be inside markdown)
-        const markDown = currentSlot.querySelector<HTMLElement>('mark-down');
-        if (markDown) {
-          await this.waitForMarkdownRender(markDown);
-          if (signal.aborted) return;
-        }
-
-        // Attribute bare <router-slot> tags with this route's pattern
-        for (const slot of currentSlot.querySelectorAll('router-slot:not([pattern])')) {
-          slot.setAttribute('pattern', routePattern);
-        }
-
-        if (!isLeaf) {
-          const nestedSlot = currentSlot.querySelector(
-            `router-slot[pattern="${CSS.escape(routePattern)}"]`,
-          );
-          if (nestedSlot) {
-            currentSlot = nestedSlot;
-          } else {
-            logger.warn(
-              `Route "${routePattern}" has no <router-slot> ` +
-                `for child routes to render into. ` +
-                `Add <router-slot></router-slot> to the parent template.`,
-            );
-          }
-        }
-      }
-
-      if (signal.aborted) return;
-
-      this.updateTitle(pageTitle);
-
-      this.core.emit({
-        type: 'load',
-        pathname: routeInfo.pathname,
-        params: routeInfo.params,
-      });
-    } catch (error) {
-      if (signal.aborted) return;
-      throw error;
-    }
-  }
-
-  /**
-   * Render a single route's content.
-   */
-  protected async renderRouteContent(
-    routeInfo: RouteInfo,
-    route: RouteConfig,
-    signal: AbortSignal,
-    isLeaf?: boolean,
-  ): Promise<{ html: string; title?: string }> {
-    if (route.modulePath === DEFAULT_ROOT_ROUTE.modulePath) {
-      return { html: `<router-slot pattern="${route.pattern}"></router-slot>` };
-    }
-
-    const files = route.files ?? {};
-
-    const component: PageComponent = files.ts
-      ? (await this.core.loadModule<{ default: PageComponent }>(files.ts)).default
-      : defaultPageComponent;
-
-    const context = await this.core.buildComponentContext(routeInfo, route, signal, isLeaf);
-    const data = await component.getData({ params: routeInfo.params, signal, context });
-    const html = component.renderHTML({ data, params: routeInfo.params, context });
-    const title = component.getTitle({ data, params: routeInfo.params, context });
-    return { html, title };
-  }
-
-  /**
-   * Wait for a <mark-down> element to finish rendering.
-   */
-  protected waitForMarkdownRender(element: HTMLElement): Promise<void> {
-    return new Promise((resolve) => {
-      if (element.children.length > 0) {
-        resolve();
-        return;
-      }
-
-      const timeout = setTimeout(() => {
-        observer.disconnect();
-        resolve();
-      }, MARKDOWN_RENDER_TIMEOUT);
-
-      const observer = new MutationObserver(() => {
-        if (element.children.length > 0) {
-          clearTimeout(timeout);
-          observer.disconnect();
-          resolve();
-        }
-      });
-
-      observer.observe(element, { childList: true });
-    });
-  }
-
-  /**
-   * Update document.title from getTitle() result.
-   */
-  protected updateTitle(pageTitle?: string): void {
-    if (pageTitle) {
-      document.title = pageTitle;
-    }
-  }
-}