@ecopages/core 0.2.0-alpha.8 → 0.2.1-beta.0

package/src/route-renderer/page-loading/page-module-loader.ts

@@ -1,181 +0,0 @@
-import { invariant } from '../../utils/invariant.ts';
-import type {
-	EcoPageFile,
-	GetMetadata,
-	GetMetadataContext,
-	GetStaticProps,
-	PageMetadataProps,
-	RouteRendererOptions,
-	EcoPageComponent,
-} from '../../public-types.ts';
-import type { EcoPagesAppConfig } from '../../internal-types.ts';
-import { getAppServerModuleTranspiler } from '../../services/module-loading/app-server-module-transpiler.service.ts';
-import type { ServerModuleTranspiler } from '../../services/module-loading/server-module-transpiler.service.ts';
-import { resolveInternalExecutionDir } from '../../utils/resolve-work-dir.ts';
-
-/**
- * Loads route page modules and normalizes their data hooks for rendering.
- *
- * @remarks
- * This service keeps the render pipeline from depending directly on raw module
- * imports. It owns the shared server-module transpiler setup, the precedence
- * rules between component statics and module exports, and the normalization of
- * page props and metadata into one renderer-facing shape.
- */
-export class PageModuleLoaderService {
-	private serverModuleTranspiler: ServerModuleTranspiler;
-	private appConfig: EcoPagesAppConfig;
-	private runtimeOrigin: string;
-
-	/**
-	 * Creates the page-module loader for one app/runtime instance.
-	 *
-	 * @param appConfig Finalized app config that owns build and invalidation state.
-	 * @param runtimeOrigin Runtime origin exposed to page data hooks.
-	 */
-	constructor(appConfig: EcoPagesAppConfig, runtimeOrigin: string) {
-		this.appConfig = appConfig;
-		this.runtimeOrigin = runtimeOrigin;
-		this.serverModuleTranspiler = getAppServerModuleTranspiler(appConfig);
-	}
-
-	/**
-	 * Imports one page module through the shared server-side module loading path.
-	 *
-	 * @remarks
-	 * The underlying transpiler keeps Bun and Node aligned on one framework-owned
-	 * loading contract even though the runtime-specific execution transport differs.
-	 */
-	async importPageFile(file: string): Promise<EcoPageFile> {
-		try {
-			return await this.serverModuleTranspiler.importModule<EcoPageFile>({
-				filePath: file,
-				outdir: `${resolveInternalExecutionDir(this.appConfig)}/.server-modules`,
-				transpileErrorMessage: (details) => `Error transpiling page file: ${details}`,
-				noOutputMessage: (targetFilePath) => `No transpiled output generated for page: ${targetFilePath}`,
-			});
-		} catch (error) {
-			invariant(false, `Error importing page file: ${error}`);
-		}
-	}
-
-	/**
-	 * Executes the page's static-props hook with Ecopages runtime context.
-	 *
-	 * @remarks
-	 * Pages without a static-props hook still return a normalized empty props
-	 * object so downstream render preparation does not branch on hook presence.
-	 */
-	async getStaticPropsForPage(options: {
-		getStaticProps?: GetStaticProps<Record<string, unknown>>;
-		params?: RouteRendererOptions['params'];
-	}): Promise<{
-		props: Record<string, unknown>;
-		metadata?: PageMetadataProps;
-	}> {
-		const { getStaticProps, params } = options;
-		return getStaticProps
-			? await getStaticProps({
-					pathname: { params: params ?? {} },
-					appConfig: this.appConfig,
-					runtimeOrigin: this.runtimeOrigin,
-				})
-					.then((data) => data)
-					.catch((err) => {
-						throw new Error(`Error fetching static props: ${err.message}`);
-					})
-			: {
-					props: {},
-					metadata: undefined,
-				};
-	}
-
-	/**
-	 * Builds the final page metadata object for one render request.
-	 *
-	 * @remarks
-	 * App-level default metadata forms the baseline, then page-level metadata is
-	 * overlaid so route-specific fields win without dropping global defaults.
-	 */
-	async getMetadataPropsForPage(options: {
-		getMetadata: GetMetadata | undefined;
-		context: GetMetadataContext;
-	}): Promise<PageMetadataProps> {
-		const { getMetadata, context } = options;
-		let metadata: PageMetadataProps = this.appConfig.defaultMetadata;
-		if (getMetadata) {
-			const dynamicMetadata = await getMetadata({
-				params: context.params,
-				query: context.query,
-				props: context.props,
-				appConfig: this.appConfig,
-			});
-			metadata = { ...metadata, ...dynamicMetadata };
-		}
-		return metadata;
-	}
-
-	/**
-	 * Loads a page module and normalizes integration-facing exports.
-	 * When both component static methods and module exports exist, component statics win.
-	 */
-	async resolvePageModule(options: {
-		file: string;
-		importPageFileFn?: (file: string) => Promise<EcoPageFile>;
-	}): Promise<{
-		Page: EcoPageFile['default'] | EcoPageComponent<any>;
-		getStaticProps?: GetStaticProps<Record<string, unknown>>;
-		getMetadata?: GetMetadata;
-		integrationSpecificProps: Record<string, unknown>;
-	}> {
-		const module = await (options.importPageFileFn ?? ((file) => this.importPageFile(file)))(options.file);
-		const {
-			default: Page,
-			getStaticProps: moduleGetStaticProps,
-			getMetadata: moduleGetMetadata,
-			...integrationSpecificProps
-		} = module;
-
-		return {
-			Page,
-			getStaticProps: Page.staticProps ?? moduleGetStaticProps,
-			getMetadata: Page.metadata ?? moduleGetMetadata,
-			integrationSpecificProps,
-		};
-	}
-
-	/**
-	 * Resolves the page data needed by the render pipeline.
-	 *
-	 * @remarks
-	 * Static props are resolved first because page metadata may depend on those
-	 * props. This preserves the same ordering whether data hooks are declared as
-	 * component statics or module exports.
-	 */
-	async resolvePageData(options: {
-		pageModule: {
-			getStaticProps?: GetStaticProps<Record<string, unknown>>;
-			getMetadata?: GetMetadata;
-		};
-		routeOptions: RouteRendererOptions;
-	}): Promise<{
-		props: Record<string, unknown>;
-		metadata: PageMetadataProps;
-	}> {
-		const { props } = await this.getStaticPropsForPage({
-			getStaticProps: options.pageModule.getStaticProps,
-			params: options.routeOptions.params,
-		});
-
-		const metadata = await this.getMetadataPropsForPage({
-			getMetadata: options.pageModule.getMetadata,
-			context: {
-				props,
-				params: options.routeOptions.params ?? {},
-				query: options.routeOptions.query ?? {},
-			} as GetMetadataContext,
-		});
-
-		return { props, metadata };
-	}
-}

package/src/route-renderer/route-renderer.ts

@@ -1,115 +0,0 @@
-import type { EcoPagesAppConfig } from '../internal-types.ts';
-import type { IntegrationPlugin } from '../plugins/integration-plugin.ts';
-import type { RouteRenderResult, RouteRendererOptions } from '../public-types.ts';
-import { invariant } from '../utils/invariant.ts';
-import { PathUtils } from '../utils/path-utils.module.ts';
-import type { IntegrationRenderer } from './orchestration/integration-renderer.ts';
-
-/**
- * Thin wrapper around one initialized integration renderer.
- *
- * @remarks
- * This type exists so higher-level routing code can ask for a route renderer
- * without depending on the full integration plugin lifecycle. It delegates all
- * real work to the integration-specific renderer selected by the factory.
- */
-export class RouteRenderer {
-	private renderer: IntegrationRenderer;
-
-	/**
-	 * Creates a route renderer bound to one integration renderer instance.
-	 */
-	constructor(renderer: IntegrationRenderer) {
-		this.renderer = renderer;
-	}
-
-	/**
-	 * Executes the render pipeline for one matched route.
-	 */
-	async createRoute(options: RouteRendererOptions): Promise<RouteRenderResult> {
-		return this.renderer.execute(options);
-	}
-}
-
-/**
- * Selects and caches integration renderers for route files and explicit views.
- *
- * @remarks
- * The factory owns the policy that maps a route file or explicit integration
- * name to one initialized integration renderer. Renderer instances are cached by
- * integration name so repeated requests do not rebuild renderer state.
- */
-export class RouteRendererFactory {
-	private appConfig: EcoPagesAppConfig;
-	runtimeOrigin: string;
-	private rendererCache = new Map<string, IntegrationRenderer>();
-
-	/**
-	 * Creates the route-renderer factory for one app/runtime instance.
-	 */
-	constructor({ appConfig, runtimeOrigin }: { appConfig: EcoPagesAppConfig; runtimeOrigin: string }) {
-		this.appConfig = appConfig;
-		this.runtimeOrigin = runtimeOrigin;
-	}
-
-	/**
-	 * Returns a route renderer for the supplied route file.
-	 */
-	createRenderer(filePath: string): RouteRenderer {
-		const integrationRenderer = this.getRouteRendererEngine(filePath);
-		invariant(!!integrationRenderer, `No integration renderer found for file: ${filePath}`);
-		return new RouteRenderer(integrationRenderer);
-	}
-
-	/**
-	 * Get an integration renderer by its name.
-	 * Used for explicit routing where views specify their integration via __eco.integration.
-	 */
-	getRendererByIntegration(integrationName: string): IntegrationRenderer | null {
-		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();
-		this.rendererCache.set(integrationName, renderer);
-		return renderer;
-	}
-
-	/**
-	 * Resolves the integration plugin that owns a given route file.
-	 */
-	getIntegrationPlugin(filePath: string): IntegrationPlugin {
-		const templateExtension = PathUtils.getEcoTemplateExtension(filePath);
-		const isIntegrationPlugin = (plugin: IntegrationPlugin): boolean => {
-			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 as IntegrationPlugin;
-	}
-
-	/**
-	 * Returns the cached renderer engine for the file's owning integration,
-	 * creating it on first use.
-	 */
-	private getRouteRendererEngine(filePath: string): IntegrationRenderer {
-		const integrationPlugin = this.getIntegrationPlugin(filePath);
-		const cached = this.rendererCache.get(integrationPlugin.name);
-		if (cached) {
-			return cached;
-		}
-
-		const renderer = integrationPlugin.initializeRenderer();
-		this.rendererCache.set(integrationPlugin.name, renderer);
-		return renderer;
-	}
-}

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

@@ -1,51 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { getAnchorFromNavigationEvent, recoverPendingNavigationHref } from './link-intent.ts';
-
-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, 2000, 1000)).toBeNull();
-	});
-
-	it('returns the captured href while a navigation is still in flight', () => {
-		expect(recoverPendingNavigationHref({ href: '/fast', timestamp: 10 }, true, 20, 1000)).toBe('/fast');
-	});
-});

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

@@ -1,92 +0,0 @@
-/**
- * Shared client-side navigation intent helpers.
- *
- * Browser runtimes use the same low-level mechanics to:
- * - locate the anchor associated with a click, pointer, or hover event,
- * - persist the last valid pointer or hover target while a navigation is in flight,
- * - recover the final intended href when the DOM changes before the click lands.
- *
- * Keeping those mechanics here lets browser-router and react-router share one
- * implementation while preserving their router-specific interception rules.
- *
- * @module
- */
-
-/**
- * Timestamped navigation intent captured from pointer or hover activity.
- */
-export type EcoPendingNavigationIntent = {
-	href: string;
-	timestamp: number;
-};
-
-/**
- * Finds the nearest matching anchor within an event's composed path.
- *
- * This works across Shadow DOM boundaries, which is required for delegated
- * navigation handling when links are rendered inside custom elements.
- *
- * @param event - Pointer or mouse event being inspected.
- * @param linkSelector - Selector that identifies navigable anchors.
- * @returns The matched anchor element, or `null` when no matching anchor exists.
- */
-export function getAnchorFromNavigationEvent(
-	event: MouseEvent | PointerEvent,
-	linkSelector: string,
-): HTMLAnchorElement | null {
-	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),
-		) as HTMLAnchorElement | null;
-}
-
-/**
- * Resolves a previously captured intent while a navigation is still in flight.
- *
- * Pending intents expire quickly because they are only meant to bridge the gap
- * between pointer or hover capture and the later click event when the DOM or
- * active runtime changes during a rapid navigation sequence.
- *
- * @param intent - Previously captured pointer or hover intent.
- * @param hasInFlightNavigation - Whether a router navigation is still active.
- * @param now - Current monotonic timestamp, usually from `performance.now()`.
- * @param maxAgeMs - Maximum allowed age for the recovered intent.
- * @returns The intended href when still valid, otherwise `null`.
- */
-export function recoverPendingNavigationHref(
-	intent: EcoPendingNavigationIntent | null,
-	hasInFlightNavigation: boolean,
-	now: number,
-	maxAgeMs = 1000,
-): string | null {
-	if (!intent || !hasInFlightNavigation) {
-		return null;
-	}
-
-	if (now - intent.timestamp > maxAgeMs) {
-		return null;
-	}
-
-	return intent.href;
-}