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

package/src/config/config-builder.typecheck.test.ts

@@ -1,96 +0,0 @@
-import path from 'node:path';
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
-import { describe, expect, test } from 'vitest';
-
-type PackageManifest = {
-	name?: string;
-	private?: boolean;
-	dependencies?: Record<string, string>;
-	peerDependencies?: Record<string, string>;
-};
-
-function readManifest(relativePath: string): PackageManifest {
-	const manifestPath = path.resolve(import.meta.dirname, '../../../..', relativePath);
-	return JSON.parse(readFileSync(manifestPath, 'utf-8')) as PackageManifest;
-}
-
-function resolveRepoPath(relativePath: string): string {
-	return path.resolve(import.meta.dirname, '../../../..', relativePath);
-}
-
-function collectPackageManifestPaths(relativeDir: string): string[] {
-	const dirPath = resolveRepoPath(relativeDir);
-	if (!existsSync(dirPath) || !statSync(dirPath).isDirectory()) {
-		return [];
-	}
-
-	return readdirSync(dirPath, { withFileTypes: true })
-		.filter((entry) => entry.isDirectory())
-		.map((entry) => path.posix.join(relativeDir, entry.name, 'package.json'))
-		.filter((manifestPath) => existsSync(resolveRepoPath(manifestPath)));
-}
-
-function collectCorePeerPackagePaths(): string[] {
-	const packagePaths = [
-		...collectPackageManifestPaths('packages/integrations'),
-		...collectPackageManifestPaths('packages/processors'),
-		'packages/browser-router/package.json',
-		'packages/react-router/package.json',
-	];
-
-	return packagePaths.filter((packagePath) => {
-		const manifest = readManifest(packagePath);
-		return manifest.name?.startsWith('@ecopages/') && !manifest.private;
-	});
-}
-
-function collectTypeScriptFiles(dirPath: string): string[] {
-	const results: string[] = [];
-
-	const visit = (currentPath: string): void => {
-		for (const entry of readdirSync(currentPath, { withFileTypes: true })) {
-			const fullPath = path.join(currentPath, entry.name);
-			if (entry.isDirectory()) {
-				visit(fullPath);
-				continue;
-			}
-
-			if (entry.name.endsWith('.ts') && !entry.name.endsWith('.d.ts')) {
-				results.push(fullPath);
-			}
-		}
-	};
-
-	visit(dirPath);
-	return results;
-}
-
-describe('ConfigBuilder published package compatibility', () => {
-	test('public integrations and processors peer @ecopages/core', () => {
-		const packages = collectCorePeerPackagePaths();
-		expect(packages.length).toBeGreaterThan(0);
-
-		for (const packagePath of packages) {
-			const manifest = readManifest(packagePath);
-			expect(manifest.peerDependencies?.['@ecopages/core'], packagePath).toBeDefined();
-			expect(manifest.dependencies?.['@ecopages/core'], packagePath).toBeUndefined();
-		}
-	});
-
-	test('built npm artifacts do not ship raw TypeScript sources', () => {
-		const distDirs = [
-			'packages/core/dist',
-			'packages/integrations/react/dist',
-			'packages/processors/postcss-processor/dist',
-		];
-
-		for (const relativeDistDir of distDirs) {
-			const distDir = resolveRepoPath(relativeDistDir);
-			if (!existsSync(distDir) || !statSync(distDir).isDirectory()) {
-				continue;
-			}
-
-			expect(collectTypeScriptFiles(distDir), relativeDistDir).toEqual([]);
-		}
-	});
-});

package/src/dev/host-runtime.ts

@@ -1,34 +0,0 @@
-import type { EcoPagesAppConfig } from '../types/public-types.ts';
-import {
-	DevelopmentInvalidationService,
-	type DevelopmentInvalidationPlan,
-} from '../services/invalidation/development-invalidation.service.ts';
-import { setHostModuleLoader } from '../services/module-loading/host-module-loader-registry.ts';
-
-export type HostRuntimeModuleLoader = (id: string) => Promise<unknown>;
-
-export interface DevelopmentHostRuntime {
-	registerHostModuleLoader(loader: HostRuntimeModuleLoader): void;
-	planFileChange(filePath: string): DevelopmentInvalidationPlan;
-	invalidateServerModules(changedFiles?: string[]): void;
-	resetRuntimeState(changedFiles?: string[]): void;
-}
-
-export function createDevelopmentHostRuntime(appConfig: EcoPagesAppConfig): DevelopmentHostRuntime {
-	const invalidationService = new DevelopmentInvalidationService(appConfig);
-
-	return {
-		registerHostModuleLoader(loader) {
-			setHostModuleLoader(loader);
-		},
-		planFileChange(filePath) {
-			return invalidationService.planFileChange(filePath);
-		},
-		invalidateServerModules(changedFiles) {
-			invalidationService.invalidateServerModules(changedFiles);
-		},
-		resetRuntimeState(changedFiles) {
-			invalidationService.resetRuntimeState(changedFiles);
-		},
-	};
-}

package/src/dev/sc-server.ts

@@ -1,143 +0,0 @@
-import { extname, join } from 'node:path';
-import { STATUS_MESSAGE } from '../config/constants.ts';
-import { fileSystem } from '@ecopages/file-system';
-import { ServerUtils } from '../utils/server-utils.module.ts';
-import type { Server } from 'bun';
-import type { EcoPagesAppConfig } from '../types/internal-types.ts';
-import { getRequiredBunRuntime } from '../utils/runtime.ts';
-
-type StaticContentServerOptions = {
-	port?: number;
-};
-
-/**
- * Static content server for production builds.
- * Serves pre-built static files from the dist directory with gzip compression support.
- */
-export class StaticContentServer {
-	server: Server<unknown> | null = null;
-	private appConfig: EcoPagesAppConfig;
-	private options: StaticContentServerOptions = { port: 3000 };
-
-	constructor({ appConfig, options }: { appConfig: EcoPagesAppConfig; options?: StaticContentServerOptions }) {
-		this.appConfig = appConfig;
-		if (options) this.options = options;
-		this.startServer();
-	}
-
-	private shouldServeGzip(contentType: ReturnType<typeof ServerUtils.getContentType>) {
-		return ['text/javascript', 'text/css'].includes(contentType);
-	}
-
-	private isHtml(contentType: string) {
-		return contentType === 'text/html';
-	}
-
-	private async sendNotFoundPage() {
-		const error404TemplatePath = `${this.appConfig.absolutePaths.distDir}/404.html`;
-
-		try {
-			fileSystem.exists(error404TemplatePath);
-		} catch {
-			return new Response(STATUS_MESSAGE[404], {
-				status: 404,
-			});
-		}
-
-		const response = new Response(fileSystem.readFileAsBuffer(error404TemplatePath) as BodyInit, {
-			headers: { 'Content-Type': 'text/html' },
-		});
-
-		return response;
-	}
-
-	private async serveFromDir({ path, request }: { path: string; request: Request }): Promise<Response> {
-		const { absolutePaths } = this.appConfig;
-		const basePath = join(absolutePaths.distDir, path);
-		const contentType = ServerUtils.getContentType(extname(basePath));
-		const acceptsGzip = request.headers.get('Accept-Encoding')?.includes('gzip');
-
-		try {
-			if (acceptsGzip && this.shouldServeGzip(contentType)) {
-				const gzipPath = `${basePath}.gz`;
-				if (fileSystem.exists(gzipPath)) {
-					const file = fileSystem.readFileAsBuffer(gzipPath) as BodyInit;
-					return new Response(file, {
-						headers: {
-							'Content-Type': contentType,
-							'Content-Encoding': 'gzip',
-							Vary: 'Accept-Encoding',
-						},
-					});
-				}
-			}
-
-			if (path.includes('.') && fileSystem.exists(basePath)) {
-				const file = fileSystem.readFileAsBuffer(basePath) as BodyInit;
-				return new Response(file, {
-					headers: { 'Content-Type': contentType },
-				});
-			}
-
-			const htmlCandidates = [`${basePath}.html`, `${basePath}/index.html`];
-
-			for (const candidate of htmlCandidates) {
-				if (fileSystem.exists(candidate)) {
-					const file = fileSystem.readFileAsBuffer(candidate) as BodyInit;
-					return new Response(file, {
-						headers: {
-							'Content-Type': ServerUtils.getContentType(extname(candidate)),
-						},
-					});
-				}
-			}
-
-			return this.sendNotFoundPage();
-		} catch {
-			return this.sendNotFoundPage();
-		}
-	}
-
-	async fetch(request: Request) {
-		let reqPath = new URL(request.url).pathname;
-
-		if (reqPath === '/') reqPath = '/index.html';
-
-		const response = this.serveFromDir({
-			path: reqPath,
-			request,
-		});
-
-		if (response) return response;
-
-		return new Response(STATUS_MESSAGE[404], {
-			status: 404,
-		});
-	}
-
-	private startServer() {
-		this.server = getRequiredBunRuntime().serve({
-			fetch: this.fetch.bind(this),
-			port: this.options.port,
-		});
-	}
-
-	stop() {
-		if (this.server) {
-			this.server.stop(true);
-		}
-	}
-
-	static createServer({
-		appConfig,
-		options,
-	}: {
-		appConfig: EcoPagesAppConfig;
-		options?: StaticContentServerOptions;
-	}) {
-		return new StaticContentServer({
-			appConfig: appConfig,
-			options,
-		});
-	}
-}

package/src/eco/eco.browser.test.ts

@@ -1,43 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import type { FileRouteMiddleware } from '../types/public-types.ts';
-import { eco } from './eco.browser.ts';
-
-describe('browser eco facade', () => {
-	test('creates browser-safe page components without server runtime imports', () => {
-		const Layout = eco.layout({
-			render: ({ children }) => `<main>${children ?? ''}</main>`,
-		});
-
-		const staticPaths = async () => ({ paths: [{ params: { slug: 'intro' } }] });
-		const metadata = async () => ({ title: 'Docs', description: 'Docs page' });
-		const middleware: FileRouteMiddleware[] = [async (_ctx, next) => next()];
-
-		const Page = eco.page({
-			layout: Layout,
-			dependencies: {
-				components: [Layout],
-			},
-			cache: 'dynamic',
-			staticPaths,
-			metadata,
-			middleware,
-			render: () => '<article>Docs</article>',
-		});
-
-		expect(Page({})).toBe('<article>Docs</article>');
-		expect(Page.config?.layout).toBe(Layout);
-		expect(Page.config?.dependencies?.components).toEqual([Layout, Layout]);
-		expect(Page.staticPaths).toBe(staticPaths);
-		expect(Page.metadata).toBe(metadata);
-		expect(Page.middleware).toBe(middleware);
-	});
-
-	test('preserves the metadata helper contract', async () => {
-		const getMetadata = eco.metadata(async () => ({ title: 'Browser title', description: 'Browser desc' }));
-
-		await expect(getMetadata({} as never)).resolves.toEqual({
-			title: 'Browser title',
-			description: 'Browser desc',
-		});
-	});
-});

package/src/eco/eco.browser.ts

@@ -1,118 +0,0 @@
-import type {
-	EcoComponent,
-	EcoHtmlComponent,
-	EcoLayoutComponent,
-	EcoPagesElement,
-	EcoPageComponent,
-	FileRouteMiddleware,
-	GetMetadata,
-	GetStaticPaths,
-	GetStaticProps,
-	RequestPageContext,
-} from '../types/public-types.ts';
-import type { CacheStrategy } from '../services/cache/cache.types.ts';
-import type { ComponentOptions, Eco, HtmlOptions, LayoutOptions, PageOptionsBase, PagePropsFor } from './eco.types.ts';
-
-function createComponentFactory<P, E>(options: ComponentOptions<P, E>): EcoComponent<P, E> {
-	const component = ((props: P) => options.render(props)) as EcoComponent<P, E>;
-
-	component.config = {
-		__eco: options.__eco,
-		integration: options.integration,
-		dependencies: options.dependencies,
-	};
-
-	return component;
-}
-
-function component<P = {}, E = EcoPagesElement>(options: ComponentOptions<P, E>): EcoComponent<P, E> {
-	return createComponentFactory(options);
-}
-
-function html<E = EcoPagesElement>(options: HtmlOptions<E>): EcoHtmlComponent<E> {
-	return createComponentFactory(options) as EcoHtmlComponent<E>;
-}
-
-function layout<E = EcoPagesElement>(options: LayoutOptions<E>): EcoLayoutComponent<E> {
-	return createComponentFactory(options) as EcoLayoutComponent<E>;
-}
-
-function page<T, E>(
-	options: PageOptionsBase<T, E> & { cache?: CacheStrategy; middleware?: FileRouteMiddleware[] },
-): EcoPageComponent<T> {
-	const {
-		layout: pageLayout,
-		dependencies,
-		render,
-		staticPaths,
-		staticProps,
-		metadata,
-		cache,
-		requires,
-		middleware,
-	} = options;
-
-	const pageComponent = createComponentFactory({
-		__eco: options.__eco,
-		integration: options.integration,
-		dependencies: pageLayout
-			? {
-					...dependencies,
-					components: [...(dependencies?.components ?? []), pageLayout],
-				}
-			: dependencies,
-		render,
-	} as ComponentOptions<PagePropsFor<T> & Partial<RequestPageContext>, E>) as EcoPageComponent<T>;
-
-	if (pageLayout && pageComponent.config) {
-		pageComponent.config.layout = pageLayout;
-	}
-
-	if (staticPaths) {
-		pageComponent.staticPaths = staticPaths;
-	}
-
-	if (staticProps) {
-		pageComponent.staticProps = staticProps;
-	}
-
-	if (metadata) {
-		pageComponent.metadata = metadata;
-	}
-
-	if (cache) {
-		pageComponent.cache = cache;
-	}
-
-	if (requires) {
-		pageComponent.requires = requires;
-	}
-
-	if (middleware) {
-		pageComponent.middleware = middleware;
-	}
-
-	return pageComponent;
-}
-
-function metadata<T = Record<string, unknown>>(fn: GetMetadata<T>): GetMetadata<T> {
-	return fn;
-}
-
-function staticPaths(fn: GetStaticPaths): GetStaticPaths {
-	return fn;
-}
-
-function staticProps<P>(fn: GetStaticProps<P>): GetStaticProps<P> {
-	return fn;
-}
-
-export const eco: Eco = {
-	component,
-	html,
-	layout,
-	page,
-	metadata,
-	staticPaths,
-	staticProps,
-};