@ecopages/core 0.2.0-alpha.27 → 0.2.0-alpha.28

package/src/route-renderer/route-renderer.js

@@ -0,0 +1,80 @@
+import { invariant } from "../utils/invariant.js";
+import { PathUtils } from "../utils/path-utils.module.js";
+class RouteRendererFactory {
+  appConfig;
+  runtimeOrigin;
+  rendererModules;
+  rendererCache = /* @__PURE__ */ new Map();
+  /**
+   * Creates the route-renderer factory for one app/runtime instance.
+   */
+  constructor({
+    appConfig,
+    rendererModules,
+    runtimeOrigin
+  }) {
+    this.appConfig = appConfig;
+    this.rendererModules = rendererModules;
+    this.runtimeOrigin = runtimeOrigin;
+  }
+  /**
+   * Returns a route renderer for the supplied route file.
+   */
+  getPageRenderer(filePath) {
+    const integrationRenderer = this.getRouteRendererEngine(filePath);
+    invariant(!!integrationRenderer, `No integration renderer found for file: ${filePath}`);
+    return integrationRenderer;
+  }
+  /**
+   * Returns a renderer for an explicit view integration.
+   */
+  getExplicitViewRenderer(integrationName) {
+    const integrationPlugin = this.appConfig.integrations.find((plugin) => plugin.name === integrationName);
+    if (!integrationPlugin) {
+      return null;
+    }
+    const cached = this.rendererCache.get(integrationName);
+    if (cached) {
+      return cached;
+    }
+    const renderer = integrationPlugin.initializeRenderer({
+      rendererModules: this.rendererModules
+    });
+    this.rendererCache.set(integrationName, renderer);
+    return renderer;
+  }
+  /**
+   * Resolves the integration plugin that owns a given route file.
+   */
+  getIntegrationPlugin(filePath) {
+    const templateExtension = PathUtils.getEcoTemplateExtension(filePath);
+    const isIntegrationPlugin = (plugin) => {
+      return plugin.extensions.some((extension) => templateExtension === extension);
+    };
+    const integrationPlugin = this.appConfig.integrations.find(isIntegrationPlugin);
+    invariant(
+      !!integrationPlugin,
+      `No integration plugin found for template extension: ${templateExtension}, file: ${filePath}`
+    );
+    return integrationPlugin;
+  }
+  /**
+   * Returns the cached renderer engine for the file's owning integration,
+   * creating it on first use.
+   */
+  getRouteRendererEngine(filePath) {
+    const integrationPlugin = this.getIntegrationPlugin(filePath);
+    const cached = this.rendererCache.get(integrationPlugin.name);
+    if (cached) {
+      return cached;
+    }
+    const renderer = integrationPlugin.initializeRenderer({
+      rendererModules: this.rendererModules
+    });
+    this.rendererCache.set(integrationPlugin.name, renderer);
+    return renderer;
+  }
+}
+export {
+  RouteRendererFactory
+};

package/src/router/client/link-intent.js

@@ -0,0 +1,34 @@
+function getAnchorFromNavigationEvent(event, linkSelector) {
+  const eventTarget = event.target;
+  if (eventTarget instanceof HTMLAnchorElement && eventTarget.matches(linkSelector)) {
+    return eventTarget;
+  }
+  if (eventTarget instanceof Element) {
+    const closestAnchor = eventTarget.closest(linkSelector);
+    if (closestAnchor instanceof HTMLAnchorElement) {
+      return closestAnchor;
+    }
+  }
+  if (eventTarget instanceof Text) {
+    const parentAnchor = eventTarget.parentElement?.closest(linkSelector);
+    if (parentAnchor instanceof HTMLAnchorElement) {
+      return parentAnchor;
+    }
+  }
+  return event.composedPath().find(
+    (target) => target instanceof HTMLAnchorElement && target.matches(linkSelector)
+  );
+}
+function recoverPendingNavigationHref(intent, hasInFlightNavigation, now, maxAgeMs = 1e3) {
+  if (!intent || !hasInFlightNavigation) {
+    return null;
+  }
+  if (now - intent.timestamp > maxAgeMs) {
+    return null;
+  }
+  return intent.href;
+}
+export {
+  getAnchorFromNavigationEvent,
+  recoverPendingNavigationHref
+};

package/src/router/client/link-intent.test.browser.d.ts

@@ -0,0 +1 @@
+export {};

package/src/router/client/link-intent.test.browser.js

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import { getAnchorFromNavigationEvent, recoverPendingNavigationHref } from "./link-intent.js";
+describe("getAnchorFromNavigationEvent", () => {
+  it("returns the anchor when the event target is a text node inside it", () => {
+    const anchor = document.createElement("a");
+    anchor.href = "/fast";
+    anchor.setAttribute("data-eco-link", "true");
+    const textNode = document.createTextNode("fast-link");
+    anchor.append(textNode);
+    document.body.append(anchor);
+    const event = new MouseEvent("click", { bubbles: true, cancelable: true, composed: true });
+    Object.defineProperty(event, "target", {
+      configurable: true,
+      value: textNode
+    });
+    expect(getAnchorFromNavigationEvent(event, "a[data-eco-link]")).toBe(anchor);
+  });
+  it("returns the closest matching anchor for nested element targets", () => {
+    const anchor = document.createElement("a");
+    anchor.href = "/fast";
+    anchor.setAttribute("data-eco-link", "true");
+    const span = document.createElement("span");
+    span.textContent = "fast-link";
+    anchor.append(span);
+    document.body.append(anchor);
+    const event = new MouseEvent("click", { bubbles: true, cancelable: true, composed: true });
+    Object.defineProperty(event, "target", {
+      configurable: true,
+      value: span
+    });
+    expect(getAnchorFromNavigationEvent(event, "a[data-eco-link]")).toBe(anchor);
+  });
+});
+describe("recoverPendingNavigationHref", () => {
+  it("returns null for stale or missing pending intent state", () => {
+    expect(recoverPendingNavigationHref(null, true, 10)).toBeNull();
+    expect(recoverPendingNavigationHref({ href: "/fast", timestamp: 0 }, false, 10)).toBeNull();
+    expect(recoverPendingNavigationHref({ href: "/fast", timestamp: 0 }, true, 2e3, 1e3)).toBeNull();
+  });
+  it("returns the captured href while a navigation is still in flight", () => {
+    expect(recoverPendingNavigationHref({ href: "/fast", timestamp: 10 }, true, 20, 1e3)).toBe("/fast");
+  });
+});

package/src/router/client/navigation-coordinator.d.ts

@@ -0,0 +1,169 @@
+/**
+ * Shared browser-side navigation coordinator.
+ *
+ * This module is the client runtime contract used by browser-router,
+ * react-router, and HMR code to coordinate ownership, cross-runtime handoff,
+ * current-page reloads, and stale-navigation cancellation.
+ *
+ * The coordinator stays framework-agnostic: browser runtimes register their
+ * capabilities here, and the coordinator arbitrates which runtime currently
+ * owns the document and which navigation transaction is still current.
+ *
+ * @module
+ */
+/** Logical owner name for a browser navigation runtime. */
+export type EcoNavigationOwner = 'none' | 'browser-router' | 'react-router' | (string & {});
+/** HTML attribute used to persist the rendered document owner across navigations. */
+export declare const ECO_DOCUMENT_OWNER_ATTRIBUTE = "data-eco-document-owner";
+/** High-level navigation direction understood by browser runtimes. */
+export type EcoNavigationDirection = 'forward' | 'back' | 'replace';
+/** Navigation request sent between browser runtimes. */
+export type EcoNavigationRequest = {
+    href: string;
+    direction?: EcoNavigationDirection;
+    source?: EcoNavigationOwner;
+};
+/** Navigation handoff request that includes a pre-fetched document. */
+export type EcoNavigationHandoffRequest = EcoNavigationRequest & {
+    finalHref?: string;
+    targetOwner: EcoNavigationOwner;
+    document: Document;
+    html?: string;
+    /**
+     * Reports whether the source runtime's original navigation has already been
+     * superseded.
+     *
+     * Target runtimes use this to ignore handoff work that arrives after a newer
+     * navigation has already claimed ownership.
+     */
+    isStaleSourceNavigation?: () => boolean;
+};
+/** Request to reload the current page through the active runtime. */
+export type EcoReloadRequest = {
+    /**
+     * Clears runtime-owned caches before reloading.
+     *
+     * Runtimes use this when a reload must discard persisted client state such as
+     * cached layouts or route-local module instances.
+     */
+    clearCache?: boolean;
+    /**
+     * Explicit page module URL to load for the reload.
+     *
+     * This is primarily used by HMR-aware runtimes so a current-page reload can
+     * reuse the active hot module entry instead of rediscovering the static page
+     * bootstrap asset from the fetched HTML document.
+     */
+    moduleUrl?: string;
+    source?: EcoNavigationOwner;
+};
+/** Snapshot of the coordinator's current runtime ownership state. */
+export type EcoNavigationOwnerState = {
+    owner: EcoNavigationOwner;
+    canHandleSpaNavigation: boolean;
+};
+/**
+ * Coordinator-managed navigation transaction.
+ *
+ * Runtimes use this to determine whether async work has become stale and to
+ * cancel or complete the active navigation sequence.
+ */
+export type EcoNavigationTransaction = {
+    id: number;
+    signal: AbortSignal;
+    isCurrent: () => boolean;
+    cancel: () => void;
+    complete: () => void;
+};
+export type EcoNavigationRuntimeEvent = {
+    type: 'owner-change';
+    owner: EcoNavigationOwner;
+    previousOwner: EcoNavigationOwner;
+    reason: 'set' | 'claim' | 'release' | 'document' | 'unregister';
+} | {
+    type: 'registration-change';
+    owner: EcoNavigationOwner;
+    status: 'registered' | 'unregistered';
+};
+export type EcoNavigationRuntimeListener = (event: EcoNavigationRuntimeEvent) => void;
+export type EcoNavigationRuntimeRegistration = {
+    owner: EcoNavigationOwner;
+    navigate?: (request: EcoNavigationRequest) => Promise<boolean | void>;
+    handoffNavigation?: (request: EcoNavigationHandoffRequest) => Promise<boolean | void>;
+    /**
+     * Reloads the current page through the runtime's local navigation mechanism.
+     *
+     * Implementations may honor `request.moduleUrl` to force a specific page entry
+     * and `request.clearCache` to discard persisted runtime state before reloading.
+     */
+    reloadCurrentPage?: (request?: EcoReloadRequest) => Promise<void>;
+    /**
+     * Releases runtime-owned client state before another runtime commits a new
+     * document.
+     *
+     * This hook intentionally does not run as part of `requestHandoff()`. The
+     * accepting runtime decides when cleanup is safe so cross-runtime handoffs do
+     * not blank the current page before the incoming document is ready.
+     */
+    cleanupBeforeHandoff?: () => void | Promise<void>;
+};
+/** Public browser-side navigation coordinator interface. */
+export interface EcoNavigationRuntime {
+    /** Returns the currently active runtime owner and whether it can handle SPA navigation. */
+    getOwnerState(): EcoNavigationOwnerState;
+    /** Starts a new navigation transaction, invalidating the previously active one. */
+    beginNavigationTransaction(): EcoNavigationTransaction;
+    /** Reports whether a navigation transaction is still in flight. */
+    hasPendingNavigationTransaction(): boolean;
+    /** Cancels the active navigation transaction, if one exists. */
+    cancelCurrentNavigationTransaction(): void;
+    /** Forces the current owner value without checking registrations. */
+    setOwner(owner: EcoNavigationOwner): void;
+    /** Claims ownership for a runtime that is ready to drive SPA navigation. */
+    claimOwnership(owner: EcoNavigationOwner): void;
+    /** Releases ownership when the given runtime no longer controls the document. */
+    releaseOwnership(owner: EcoNavigationOwner): void;
+    /** Resolves document ownership from the rendered owner marker or fallback. */
+    resolveDocumentOwner(doc: Document, fallbackOwner?: EcoNavigationOwner): EcoNavigationOwner;
+    /** Reads and adopts the rendered document owner as the active runtime owner. */
+    adoptDocumentOwner(doc: Document, fallbackOwner?: EcoNavigationOwner): EcoNavigationOwner;
+    /** Returns whether the active owner is some runtime other than the given owner. */
+    isOwnedByAnotherRuntime(owner: EcoNavigationOwner): boolean;
+    /** Subscribes to ownership and registration change events. */
+    subscribe(listener: EcoNavigationRuntimeListener): () => void;
+    /** Registers a runtime implementation with the coordinator. */
+    register(runtime: EcoNavigationRuntimeRegistration): () => void;
+    /** Requests navigation through another eligible registered runtime. */
+    requestNavigation(request: EcoNavigationRequest): Promise<boolean>;
+    /**
+     * Hands a pre-fetched document to the target runtime.
+     *
+     * The coordinator delegates the document but does not clean up the current
+     * owner first. Cleanup timing belongs to the accepting runtime so a stale or
+     * superseded handoff cannot tear down the current page prematurely.
+     */
+    requestHandoff(request: EcoNavigationHandoffRequest): Promise<boolean>;
+    /** Requests the active runtime to reload the current page. */
+    reloadCurrentPage(request?: EcoReloadRequest): Promise<boolean>;
+    /** Runs a target runtime's cleanup hook before handoff. */
+    cleanupOwner(owner: EcoNavigationOwner): Promise<void>;
+    /** Runs cleanup for whichever runtime currently owns the document. */
+    cleanupCurrentOwner(): Promise<void>;
+}
+/**
+ * Reads the explicit browser document owner marker from a rendered HTML document.
+ *
+ * Documents without a marker return `null`, allowing runtimes to fall back to
+ * their local default behavior without scanning hydration scripts.
+ */
+export declare function getEcoDocumentOwner(doc: Document): EcoNavigationOwner | null;
+/**
+ * Returns the singleton browser-side navigation coordinator.
+ *
+ * The coordinator centralizes ownership, handoff, and current-page reload
+ * requests across browser runtimes through one internal protocol.
+ *
+ * @param windowObject - Window-like object that stores the singleton runtime.
+ * @returns The shared browser navigation coordinator.
+ */
+export declare function getEcoNavigationRuntime(windowObject?: Window & typeof globalThis): EcoNavigationRuntime;

package/src/router/client/navigation-coordinator.js

@@ -0,0 +1,215 @@
+const ECO_DOCUMENT_OWNER_ATTRIBUTE = "data-eco-document-owner";
+function getEcoDocumentOwner(doc) {
+  const owner = doc.documentElement.getAttribute(ECO_DOCUMENT_OWNER_ATTRIBUTE);
+  return owner && owner.length > 0 ? owner : null;
+}
+function getCandidateOwners(currentOwner, registrations, excludedOwner) {
+  const owners = [];
+  if (currentOwner !== "none" && currentOwner !== excludedOwner) {
+    owners.push(currentOwner);
+  }
+  for (const owner of registrations.keys()) {
+    if (owner === currentOwner || owner === excludedOwner) {
+      continue;
+    }
+    owners.push(owner);
+  }
+  return owners;
+}
+function createEcoNavigationRuntime() {
+  const registrations = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  let owner = "none";
+  let navigationSequence = 0;
+  let navigationAbortController = null;
+  const emit = (event) => {
+    for (const listener of listeners) {
+      listener(event);
+    }
+  };
+  const updateOwner = (nextOwner, reason) => {
+    if (owner === nextOwner) {
+      return;
+    }
+    const previousOwner = owner;
+    owner = nextOwner;
+    emit({
+      type: "owner-change",
+      owner: nextOwner,
+      previousOwner,
+      reason
+    });
+  };
+  const cancelNavigationTransaction = (navigationId, abortController) => {
+    if (navigationSequence !== navigationId || navigationAbortController !== abortController) {
+      return;
+    }
+    navigationSequence += 1;
+    navigationAbortController = null;
+    abortController.abort();
+  };
+  const completeNavigationTransaction = (navigationId, abortController) => {
+    if (navigationSequence !== navigationId || navigationAbortController !== abortController) {
+      return;
+    }
+    navigationAbortController = null;
+  };
+  const runtime = {
+    getOwnerState() {
+      const activeRuntime = registrations.get(owner);
+      return {
+        owner,
+        canHandleSpaNavigation: typeof activeRuntime?.navigate === "function"
+      };
+    },
+    hasPendingNavigationTransaction() {
+      return navigationAbortController !== null;
+    },
+    beginNavigationTransaction() {
+      navigationAbortController?.abort();
+      const abortController = new AbortController();
+      const navigationId = ++navigationSequence;
+      navigationAbortController = abortController;
+      return {
+        id: navigationId,
+        signal: abortController.signal,
+        isCurrent: () => navigationSequence === navigationId && navigationAbortController === abortController,
+        cancel: () => {
+          cancelNavigationTransaction(navigationId, abortController);
+        },
+        complete: () => {
+          completeNavigationTransaction(navigationId, abortController);
+        }
+      };
+    },
+    cancelCurrentNavigationTransaction() {
+      if (!navigationAbortController) {
+        return;
+      }
+      cancelNavigationTransaction(navigationSequence, navigationAbortController);
+    },
+    setOwner(nextOwner) {
+      updateOwner(nextOwner, "set");
+    },
+    claimOwnership(nextOwner) {
+      updateOwner(nextOwner, "claim");
+    },
+    releaseOwnership(currentOwner) {
+      if (owner !== currentOwner) {
+        return;
+      }
+      updateOwner("none", "release");
+    },
+    resolveDocumentOwner(doc, fallbackOwner = "none") {
+      return getEcoDocumentOwner(doc) ?? fallbackOwner;
+    },
+    adoptDocumentOwner(doc, fallbackOwner = "none") {
+      const nextOwner = runtime.resolveDocumentOwner(doc, fallbackOwner);
+      updateOwner(nextOwner, "document");
+      return nextOwner;
+    },
+    isOwnedByAnotherRuntime(candidateOwner) {
+      return owner !== "none" && owner !== candidateOwner;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    register(registration) {
+      registrations.set(registration.owner, registration);
+      emit({
+        type: "registration-change",
+        owner: registration.owner,
+        status: "registered"
+      });
+      return () => {
+        const currentRegistration = registrations.get(registration.owner);
+        if (currentRegistration !== registration) {
+          return;
+        }
+        registrations.delete(registration.owner);
+        emit({
+          type: "registration-change",
+          owner: registration.owner,
+          status: "unregistered"
+        });
+        if (owner === registration.owner) {
+          updateOwner("none", "unregister");
+        }
+      };
+    },
+    async requestNavigation(request) {
+      for (const candidateOwner of getCandidateOwners(owner, registrations, request.source)) {
+        const registration = registrations.get(candidateOwner);
+        if (!registration?.navigate) {
+          continue;
+        }
+        const handled = await registration.navigate(request);
+        if (handled !== false) {
+          return true;
+        }
+      }
+      return false;
+    },
+    async requestHandoff(request) {
+      if (request.targetOwner === "none") {
+        return false;
+      }
+      if (request.isStaleSourceNavigation?.()) {
+        return true;
+      }
+      const registration = registrations.get(request.targetOwner);
+      if (!registration?.handoffNavigation) {
+        return false;
+      }
+      if (request.isStaleSourceNavigation?.()) {
+        return true;
+      }
+      const handled = await registration.handoffNavigation(request);
+      return handled !== false;
+    },
+    async reloadCurrentPage(request) {
+      for (const candidateOwner of getCandidateOwners(owner, registrations)) {
+        const registration = registrations.get(candidateOwner);
+        if (!registration?.reloadCurrentPage) {
+          continue;
+        }
+        await registration.reloadCurrentPage(request);
+        return true;
+      }
+      return false;
+    },
+    async cleanupOwner(targetOwner) {
+      if (targetOwner === "none") {
+        return;
+      }
+      const registration = registrations.get(targetOwner);
+      if (!registration?.cleanupBeforeHandoff) {
+        return;
+      }
+      await registration.cleanupBeforeHandoff();
+      if (owner === targetOwner) {
+        updateOwner("none", "release");
+      }
+    },
+    async cleanupCurrentOwner() {
+      await runtime.cleanupOwner(owner);
+    }
+  };
+  return runtime;
+}
+function getEcoNavigationRuntime(windowObject = window) {
+  const runtimeWindow = windowObject;
+  runtimeWindow.__ECO_PAGES__ = runtimeWindow.__ECO_PAGES__ || {};
+  if (!runtimeWindow.__ECO_PAGES__.navigation) {
+    runtimeWindow.__ECO_PAGES__.navigation = createEcoNavigationRuntime();
+  }
+  return runtimeWindow.__ECO_PAGES__.navigation;
+}
+export {
+  ECO_DOCUMENT_OWNER_ATTRIBUTE,
+  getEcoDocumentOwner,
+  getEcoNavigationRuntime
+};

package/src/router/server/route-registry.d.ts

@@ -0,0 +1,78 @@
+import type { EcoPagesAppConfig, RouteKind } from '../../types/internal-types.js';
+export type RouteParams = Record<string, string | string[]>;
+export type RouteQuery = Record<string, string>;
+export type TemplateRoute = {
+    readonly pathname: string;
+    readonly kind: RouteKind;
+    readonly filePath: string;
+    readonly paramNames: readonly string[];
+};
+export type RouteMatch = {
+    readonly requestedPathname: string;
+    readonly templateRoute: TemplateRoute;
+    readonly params: RouteParams;
+    readonly query: RouteQuery;
+};
+export type StaticPathExpansion = {
+    readonly pathname: string;
+    readonly templateRoute: TemplateRoute;
+    readonly params: RouteParams;
+};
+export type StaticGenerationRoute = {
+    readonly requestUrl: string;
+    readonly pathname: string;
+    readonly templateRoute: TemplateRoute;
+    readonly params: RouteParams;
+};
+export type StaticPathsContext = {
+    readonly appConfig: EcoPagesAppConfig;
+    readonly runtimeOrigin: string;
+};
+export type RouteRegistryPageModule = {
+    readonly staticPaths?: (context: StaticPathsContext) => Promise<{
+        paths: Array<{
+            params: RouteParams;
+        }>;
+    }>;
+    readonly staticProps?: unknown;
+};
+export interface RouteRegistryPageModuleAdapter {
+    loadPageModule(filePath: string): Promise<RouteRegistryPageModule>;
+}
+export type RouteRegistryOptions = {
+    pagesDir: string;
+    appConfig: EcoPagesAppConfig;
+    origin: string;
+    templatesExt: readonly string[];
+    buildMode: boolean;
+    pageModuleAdapter: RouteRegistryPageModuleAdapter;
+};
+export declare class RouteRegistry {
+    readonly origin: string;
+    readonly appConfig: EcoPagesAppConfig;
+    readonly pagesDir: string;
+    readonly templatesExt: readonly string[];
+    readonly buildMode: boolean;
+    private readonly pageModuleAdapter;
+    private templateRouteList;
+    private readonly reloadListeners;
+    constructor(options: RouteRegistryOptions);
+    get templateRoutes(): readonly TemplateRoute[];
+    init(): Promise<void>;
+    reload(): Promise<void>;
+    onReload(listener: () => void): () => void;
+    matchRequest(requestUrl: string): RouteMatch | null;
+    listStaticPathExpansions(input: {
+        runtimeOrigin: string;
+    }): Promise<readonly StaticPathExpansion[]>;
+    listStaticGenerationRoutes(input: {
+        runtimeOrigin: string;
+    }): Promise<readonly StaticGenerationRoute[]>;
+    private scanTemplateRoutes;
+    private getRoutePath;
+    private classifyRouteKind;
+    private getParamNames;
+    private tryExtractParams;
+    private getSearchParams;
+    private resolveTemplatePath;
+}