npm - @ecopages/core - Versions diffs - 0.2.0-alpha.4 → 0.2.0-alpha.6 - Mend

@ecopages/core 0.2.0-alpha.4 → 0.2.0-alpha.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (418) hide show

package/src/route-renderer/orchestration/render-preparation.service.test.ts ADDED Viewed

@@ -0,0 +1,235 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { EcoPagesAppConfig } from '../../internal-types.ts';
+import type { EcoComponent, EcoPageComponent, HtmlTemplateProps, RouteRendererOptions } from '../../public-types.ts';
+import type {
+	AssetDefinition,
+	AssetProcessingService,
+	ProcessedAsset,
+} from '../../services/assets/asset-processing-service/index.ts';
+import { RenderPreparationService } from './render-preparation.service.ts';
+declare module '../../public-types.ts' {
+	interface RequestLocals {
+		user?: string;
+		guarded?: boolean;
+	}
+}
+describe('RenderPreparationService', () => {
+	it('should prepare dynamic render options and merge renderer-owned assets', async () => {
+		const integrationDependency = {
+			kind: 'script',
+			srcUrl: '/assets/react-runtime.js',
+			position: 'head',
+		} as ProcessedAsset;
+		const componentAsset = {
+			kind: 'script',
+			srcUrl: '/assets/page-root.js',
+			position: 'head',
+		} as ProcessedAsset;
+		const resolvedDependency = {
+			kind: 'stylesheet',
+			srcUrl: '/assets/page.css',
+			position: 'head',
+		} as ProcessedAsset;
+		const pageDependency = {
+			kind: 'script',
+			srcUrl: '/assets/page-entry.js',
+			position: 'head',
+		} as ProcessedAsset;
+		const assetProcessingService = {
+			processDependencies: vi.fn(async () => []),
+		} as unknown as AssetProcessingService;
+		const appConfig = {
+			cache: { defaultStrategy: 'static' },
+			integrations: [
+				{
+					name: 'react',
+					initializeRenderer: vi.fn(),
+					getResolvedIntegrationDependencies: () => [integrationDependency],
+				},
+			],
+		} as unknown as EcoPagesAppConfig;
+		const service = new RenderPreparationService(appConfig, assetProcessingService);
+		const HtmlTemplate = (() => '<html></html>') as EcoComponent<HtmlTemplateProps>;
+		const Nested = (() => '<aside>Nested</aside>') as EcoComponent<Record<string, unknown>>;
+		Nested.config = {
+			integration: 'react',
+			__eco: { id: 'nested', file: '/app/components/nested.tsx', integration: 'react' },
+		};
+		const Page = (() => '<main>Page</main>') as unknown as EcoPageComponent<any>;
+		Page.cache = 'dynamic';
+		Page.config = {
+			dependencies: {
+				components: [Nested],
+			},
+		};
+		const routeOptions = {
+			file: '/app/pages/index.tsx',
+			params: { slug: 'hello' },
+			query: { preview: '1' },
+			locals: { user: 'andee' },
+		} as unknown as RouteRendererOptions;
+		const setProcessedDependencies = vi.fn();
+		const result = await service.prepare(routeOptions, 'ghtml', {
+			resolvePageModule: async () => ({
+				Page,
+				integrationSpecificProps: { layoutMode: 'full' },
+			}),
+			getHtmlTemplate: async () => HtmlTemplate,
+			resolvePageData: async () => ({
+				props: { title: 'Hello' },
+				metadata: { title: 'Hello', description: 'Hello description' },
+			}),
+			resolveDependencies: async () => [resolvedDependency],
+			buildRouteRenderAssets: async () => [pageDependency],
+			shouldRenderPageComponent: () => true,
+			renderPageComponent: async () => ({
+				html: '<main>Page</main>',
+				canAttachAttributes: true,
+				rootTag: 'main',
+				integrationName: 'ghtml',
+				assets: [componentAsset],
+			}),
+			getComponentRenderBoundaryContext: () => ({
+				decideBoundaryRender: () => 'inline',
+			}),
+			setProcessedDependencies,
+			dedupeProcessedAssets: (assets) => assets,
+			createPageLocalsProxy: () => ({ guarded: true }),
+		});
+		expect(result.locals).toEqual({ user: 'andee' });
+		expect(result.pageLocals).toEqual({ user: 'andee' });
+		expect(result.pageProps).toEqual({ title: 'Hello', params: { slug: 'hello' }, query: { preview: '1' } });
+		expect((result as typeof result & { layoutMode?: string }).layoutMode).toBe('full');
+		expect(result.componentRender?.assets).toEqual([componentAsset]);
+		expect(setProcessedDependencies).toHaveBeenCalledWith([
+			resolvedDependency,
+			integrationDependency,
+			pageDependency,
+			componentAsset,
+		]);
+	});
+	it('should guard page locals for static pages and skip page-root rendering when disabled', async () => {
+		const assetProcessingService = {
+			processDependencies: vi.fn(async () => []),
+		} as unknown as AssetProcessingService;
+		const appConfig = {
+			cache: { defaultStrategy: 'static' },
+			integrations: [],
+		} as unknown as EcoPagesAppConfig;
+		const service = new RenderPreparationService(appConfig, assetProcessingService);
+		const HtmlTemplate = (() => '<html></html>') as EcoComponent<HtmlTemplateProps>;
+		const Page = (() => '<main>Page</main>') as unknown as EcoPageComponent<any>;
+		const renderPageComponent = vi.fn();
+		const result = await service.prepare(
+			{
+				file: '/app/pages/index.tsx',
+				params: {},
+				query: {},
+				locals: { hidden: true },
+			} as unknown as RouteRendererOptions,
+			'ghtml',
+			{
+				resolvePageModule: async () => ({
+					Page,
+					integrationSpecificProps: {},
+				}),
+				getHtmlTemplate: async () => HtmlTemplate,
+				resolvePageData: async () => ({
+					props: {},
+					metadata: { title: 'Static page', description: 'Static page description' },
+				}),
+				resolveDependencies: async () => [],
+				buildRouteRenderAssets: async () => [],
+				shouldRenderPageComponent: () => false,
+				renderPageComponent,
+				getComponentRenderBoundaryContext: () => ({
+					decideBoundaryRender: () => 'inline',
+				}),
+				setProcessedDependencies: vi.fn(),
+				dedupeProcessedAssets: (assets) => assets,
+				createPageLocalsProxy: () => ({ guarded: true }),
+			},
+		);
+		expect(result.locals).toBeUndefined();
+		expect(result.pageLocals).toEqual({ guarded: true });
+		expect(result.componentRender).toBeUndefined();
+		expect(renderPageComponent).not.toHaveBeenCalled();
+	});
+	it('eagerly emits lazy SSR component scripts for shared non-owning routes', async () => {
+		const eagerSsrLazyAsset = {
+			kind: 'script',
+			srcUrl: '/assets/components/lit-counter.script.js',
+			position: 'head',
+		} as ProcessedAsset;
+		const assetProcessingService = {
+			processDependencies: vi.fn(async (dependencies: AssetDefinition[]) => {
+				const hasEagerSsrLazyDependency = dependencies.some((dependency) => {
+					if (dependency.kind !== 'script' || dependency.source !== 'file') {
+						return false;
+					}
+					return String(dependency.filepath).endsWith('/lit-counter.script.ts');
+				});
+				return hasEagerSsrLazyDependency ? [eagerSsrLazyAsset] : [];
+			}),
+		} as unknown as AssetProcessingService;
+		const appConfig = {
+			cache: { defaultStrategy: 'static' },
+			integrations: [],
+		} as unknown as EcoPagesAppConfig;
+		const service = new RenderPreparationService(appConfig, assetProcessingService);
+		const HtmlTemplate = (() => '<html></html>') as EcoComponent<HtmlTemplateProps>;
+		const LitCounter = (() => '<lit-counter count="0"></lit-counter>') as unknown as EcoComponent<object>;
+		LitCounter.config = {
+			__eco: { id: 'lit-counter', file: '/app/components/lit-counter.lit.tsx', integration: 'lit' },
+			dependencies: {
+				scripts: [{ src: './lit-counter.script.ts', lazy: { 'on:interaction': 'click' }, ssr: true }],
+			},
+		};
+		const Page = (() => '<main>Page</main>') as unknown as EcoPageComponent<any>;
+		Page.config = {
+			dependencies: {
+				components: [LitCounter],
+			},
+		};
+		const setProcessedDependencies = vi.fn();
+		await service.prepare(
+			{ file: '/app/pages/index.tsx', params: {}, query: {} } as unknown as RouteRendererOptions,
+			'ghtml',
+			{
+				resolvePageModule: async () => ({
+					Page,
+					integrationSpecificProps: {},
+				}),
+				getHtmlTemplate: async () => HtmlTemplate,
+				resolvePageData: async () => ({
+					props: {},
+					metadata: { title: 'Static page', description: 'Static page description' },
+				}),
+				resolveDependencies: async () => [],
+				buildRouteRenderAssets: async () => [],
+				shouldRenderPageComponent: () => false,
+				renderPageComponent: vi.fn(),
+				getComponentRenderBoundaryContext: () => ({
+					decideBoundaryRender: () => 'inline',
+				}),
+				setProcessedDependencies,
+				dedupeProcessedAssets: (assets) => assets,
+				createPageLocalsProxy: () => ({}),
+			},
+		);
+		expect(setProcessedDependencies).toHaveBeenCalledWith([eagerSsrLazyAsset]);
+	});
+});

package/src/route-renderer/{render-preparation.service.ts → orchestration/render-preparation.service.ts} RENAMED Viewed

@@ -1,8 +1,10 @@
 import { createRequire } from 'node:module';
-import type { EcoPagesAppConfig } from '../internal-types.ts';
+import type { EcoPagesAppConfig } from '../../internal-types.ts';
 import type {
 	ComponentRenderResult,
 	EcoComponent,
+	EcoComponentConfig,
+	DependencyAttributes,
 	EcoPageComponent,
 	EcoPageFile,
 	EcoPagesElement,
@@ -14,14 +16,17 @@ import type {
 	PageMetadataProps,
 	ResolvedLazyTrigger,
 	RouteRendererOptions,
-} from '../public-types.ts';
+} from '../../public-types.ts';
 import {
 	type AssetProcessingService,
 	AssetFactory,
 	type ProcessedAsset,
-} from '../services/asset-processing-service/index.ts';
-import { buildGlobalInjectorBootstrapContent, buildGlobalInjectorMapScript } from '../eco/global-injector-map.ts';
-import { runWithComponentRenderContext, type ComponentRenderBoundaryContext } from '../eco/component-render-context.ts';
+} from '../../services/assets/asset-processing-service/index.ts';
+import { buildGlobalInjectorBootstrapContent, buildGlobalInjectorMapScript } from '../../eco/global-injector-map.ts';
+import {
+	runWithComponentRenderContext,
+	type ComponentRenderBoundaryContext,
+} from '../../eco/component-render-context.ts';
 const coreRequire = createRequire(import.meta.url);
@@ -72,10 +77,20 @@ export interface RenderPreparationCallbacks {
  * locals policy.
  */
 export class RenderPreparationService {
-	constructor(
-		private appConfig: EcoPagesAppConfig,
-		private assetProcessingService: AssetProcessingService,
-	) {}
+	private appConfig: EcoPagesAppConfig;
+	private assetProcessingService: AssetProcessingService;
+	/**
+	 * Creates the render-preparation orchestrator for one app instance.
+	 *
+	 * @remarks
+	 * The service is app-scoped because it depends on finalized config defaults and
+	 * the app-owned asset-processing pipeline while remaining renderer-agnostic.
+	 */
+	constructor(appConfig: EcoPagesAppConfig, assetProcessingService: AssetProcessingService) {
+		this.appConfig = appConfig;
+		this.assetProcessingService = assetProcessingService;
+	}
 	/**
 	 * Builds the final render options object used by the integration-specific
@@ -132,6 +147,11 @@ export class RenderPreparationService {
 			allDependencies.push(...globalAssets);
 		}
+		const eagerSsrLazyAssets = await this.buildEagerSsrLazyAssets(componentsToResolve, currentIntegrationName);
+		if (eagerSsrLazyAssets.length > 0) {
+			allDependencies.push(...eagerSsrLazyAssets);
+		}
 		callbacks.setProcessedDependencies(callbacks.dedupeProcessedAssets(allDependencies));
 		const pageProps = {
@@ -355,4 +375,102 @@ export class RenderPreparationService {
 			currentIntegrationName,
 		);
 	}
+	private async buildEagerSsrLazyAssets(
+		components: (EcoComponent | Partial<EcoComponent>)[],
+		currentIntegrationName: string,
+	): Promise<ProcessedAsset[]> {
+		const dependencies = this.collectEagerSsrLazyDependencies(components);
+		if (dependencies.length === 0) {
+			return [];
+		}
+		return this.assetProcessingService.processDependencies(dependencies, `${currentIntegrationName}:ssr-lazy`);
+	}
+	private collectEagerSsrLazyDependencies(
+		components: (EcoComponent | Partial<EcoComponent>)[],
+	): ReturnType<AssetProcessingService['processDependencies']> extends Promise<infer _>
+		? Parameters<AssetProcessingService['processDependencies']>[0]
+		: never {
+		const dependencies = [] as Parameters<AssetProcessingService['processDependencies']>[0];
+		const visitedConfigs = new Set<EcoComponentConfig>();
+		const seenKeys = new Set<string>();
+		const normalizeAttributes = (attributes?: DependencyAttributes) => ({
+			type: 'module',
+			defer: '',
+			...(attributes ?? {}),
+		});
+		const collect = (config?: EcoComponentConfig) => {
+			if (!config || visitedConfigs.has(config)) {
+				return;
+			}
+			visitedConfigs.add(config);
+			const componentFile = config.__eco?.file;
+			if (componentFile) {
+				const componentDir = coreRequire('node:path').dirname(componentFile);
+				for (const script of config.dependencies?.scripts ?? []) {
+					if (typeof script === 'string' || !script.lazy || script.ssr !== true) {
+						continue;
+					}
+					const attributes = normalizeAttributes(script.attributes);
+					if (script.content) {
+						const key = `content:${script.content}:${JSON.stringify(attributes)}`;
+						if (seenKeys.has(key)) {
+							continue;
+						}
+						seenKeys.add(key);
+						dependencies.push(
+							AssetFactory.createContentScript({
+								position: 'head',
+								content: script.content,
+								attributes,
+							}),
+						);
+						continue;
+					}
+					if (!script.src) {
+						continue;
+					}
+					const resolvedPath = coreRequire('node:path').resolve(componentDir, script.src);
+					const key = `file:${resolvedPath}:${JSON.stringify(attributes)}`;
+					if (seenKeys.has(key)) {
+						continue;
+					}
+					seenKeys.add(key);
+					dependencies.push(
+						AssetFactory.createFileScript({
+							filepath: resolvedPath,
+							position: 'head',
+							attributes,
+						}),
+					);
+				}
+			}
+			if (config.layout?.config) {
+				collect(config.layout.config);
+			}
+			for (const nestedComponent of config.dependencies?.components ?? []) {
+				collect(nestedComponent?.config);
+			}
+		};
+		for (const component of components) {
+			collect(component.config);
+		}
+		return dependencies;
+	}
 }