@ecopages/core 0.2.0-alpha.8 → 0.2.1

package/src/constants.ts

@@ -1,54 +0,0 @@
-/**
- * This file contains constants used throughout the project.
- * @module constants
- **/
-
-/**
- * Collection of status messages used in the application.
- */
-export const STATUS_MESSAGE = {
-	404: '404 Not Found',
-};
-
-/**
- *Variables used to determine if the app is running on Bun
- */
-export const IS_BUN = typeof Bun !== 'undefined';
-
-/**
- * Directory used for storing assets.
- */
-export const RESOLVED_ASSETS_DIR = 'assets';
-
-/**
- * Directory used for storing vendor assets.
- * This is a subdirectory of the assets directory.
- */
-export const RESOLVED_ASSETS_VENDORS_DIR: string = `${RESOLVED_ASSETS_DIR}/vendors`;
-
-/**
- * Base paths for generated project files.
- */
-export const GENERATED_BASE_PATHS = {
-	types: 'node_modules/@types',
-	cache: 'cache',
-} as const;
-
-export const DEFAULT_ECOPAGES_PORT = 3000;
-
-export const DEFAULT_ECOPAGES_HOSTNAME = 'localhost';
-
-/**
- * Default directory used for deployable output.
- */
-export const DEFAULT_ECOPAGES_DIST_DIR = 'dist';
-
-/**
- * Default internal working directory used for runtime-only artifacts.
- *
- * @remarks
- * This directory is a local tool workspace and is not intended for deployment.
- * It owns transpiled server modules, runtime manifests, and processor caches
- * so the export directory can remain a clean deployable tree.
- */
-export const DEFAULT_ECOPAGES_WORK_DIR = '.eco';

package/src/create-app.ts

@@ -1,87 +0,0 @@
-import type { EcopagesAppOptions as BunOptions } from './adapters/bun/create-app.ts';
-import type { EcopagesAppOptions as NodeOptions } from './adapters/node/create-app.ts';
-import { AbstractApplicationAdapter } from './adapters/abstract/application-adapter.ts';
-import type { ApiHandler } from './public-types.ts';
-import { SharedApplicationAdapter } from './adapters/shared/application-adapter.ts';
-
-export type EcopagesAppOptions = BunOptions | NodeOptions;
-export type UniversalEcopagesApp = AbstractApplicationAdapter<EcopagesAppOptions, any, Request>;
-
-async function createRuntimeApp<WebSocketData = undefined>(options: EcopagesAppOptions): Promise<UniversalEcopagesApp> {
-	const bun = (globalThis as { Bun?: unknown }).Bun;
-
-	if (bun) {
-		const { createApp: createBunApp } = await import('./adapters/bun/create-app.ts');
-		return (await createBunApp<WebSocketData>(options as BunOptions)) as unknown as UniversalEcopagesApp;
-	}
-
-	const { createNodeApp } = await import('./adapters/node/create-app.ts');
-	return (await createNodeApp(options as NodeOptions)) as unknown as UniversalEcopagesApp;
-}
-
-export async function createApp<WebSocketData = undefined>(options: EcopagesAppOptions): Promise<UniversalEcopagesApp> {
-	return createRuntimeApp<WebSocketData>(options);
-}
-
-export class EcopagesApp extends SharedApplicationAdapter<EcopagesAppOptions, unknown, Request> {
-	private readonly appOptions: EcopagesAppOptions;
-	private runtimeApp: UniversalEcopagesApp | null = null;
-	private runtimeAppPromise: Promise<UniversalEcopagesApp> | null = null;
-
-	constructor(options: EcopagesAppOptions) {
-		super(options);
-		this.appOptions = options;
-	}
-
-	private async getRuntimeApp(): Promise<UniversalEcopagesApp> {
-		if (this.runtimeApp) {
-			return this.runtimeApp;
-		}
-
-		if (!this.runtimeAppPromise) {
-			this.runtimeAppPromise = createRuntimeApp({
-				...this.appOptions,
-				clearOutput: false,
-			}).then((app) => {
-				for (const handler of this.apiHandlers) {
-					app.add(handler as ApiHandler<string, Request, any>);
-				}
-
-				for (const route of this.staticRoutes) {
-					app.static(route.path, route.loader);
-				}
-
-				if (this.errorHandler) {
-					app.onError(this.errorHandler);
-				}
-
-				this.runtimeApp = app;
-				return app;
-			});
-		}
-
-		return this.runtimeAppPromise;
-	}
-
-	protected async initializeServerAdapter(): Promise<UniversalEcopagesApp> {
-		return this.getRuntimeApp();
-	}
-
-	async start(): Promise<unknown> {
-		const runtimeApp = await this.getRuntimeApp();
-		return runtimeApp.start();
-	}
-
-	async fetch(request: Request): Promise<Response> {
-		const runtimeApp = await this.getRuntimeApp();
-		const candidate = runtimeApp as UniversalEcopagesApp & {
-			fetch?: (request: Request) => Promise<Response>;
-		};
-
-		if (!candidate.fetch) {
-			throw new Error('The selected runtime adapter does not expose fetch()');
-		}
-
-		return candidate.fetch(request);
-	}
-}

package/src/dev/sc-server.ts

@@ -1,143 +0,0 @@
-import { extname, join } from 'node:path';
-import { STATUS_MESSAGE } from '../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 '../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/component-render-context.d.ts

@@ -1,105 +0,0 @@
-import type { EcoComponent } from '../public-types.js';
-import type { MarkerNodeId } from '../route-renderer/component-graph/component-marker.js';
-/**
- * Outcome returned by boundary policy during one component render pass.
- *
- * - `inline`: render the target component immediately in the current pass
- * - `defer`: emit an `eco-marker` and resolve it during the marker graph phase
- */
-export type BoundaryRenderMode = 'inline' | 'defer';
-/**
- * Input provided to boundary policy when a component boundary is reached.
- *
- * This keeps `eco.component()` decoupled from concrete integration/plugin
- * objects while still giving policy enough information to decide whether the
- * boundary should render immediately or be deferred.
- */
-export type BoundaryRenderDecisionInput = {
-    currentIntegration: string;
-    targetIntegration?: string;
-    component: EcoComponent;
-};
-/**
- * Narrow render-pass facade used by `eco.component()` for boundary decisions.
- *
- * The boundary context is intentionally small so component rendering can remain
- * unaware of integration registries, plugin instances, or renderer lifecycles.
- */
-export type ComponentRenderBoundaryContext = {
-    /**
-     * Decides whether the next component boundary should render inline or defer to
-     * the marker graph stage.
-     *
-     * @param input Boundary metadata for the current render pass.
-     * @returns Boundary rendering mode for the target component.
-     */
-    decideBoundaryRender(input: BoundaryRenderDecisionInput): BoundaryRenderMode;
-};
-/**
- * Per-render mutable state used while collecting marker graph references.
- *
- * Counters generate deterministic ids within one render execution.
- */
-type ComponentRenderContext = {
-    currentIntegration: string;
-    boundaryContext: ComponentRenderBoundaryContext;
-    nextNodeId: number;
-    nextPropsRefId: number;
-    nextSlotRefId: number;
-    propsByRef: Record<string, Record<string, unknown>>;
-    slotChildrenByRef: Record<string, MarkerNodeId[]>;
-};
-/**
- * Serializable graph context captured from one render execution.
- *
- * This payload is merged with explicit page-module graph context before marker
- * resolution in the route renderer.
- */
-export type ComponentGraphContext = {
-    propsByRef: Record<string, Record<string, unknown>>;
-    slotChildrenByRef: Record<string, MarkerNodeId[]>;
-};
-/**
- * Returns the current component render context, if one is active.
- *
- * @returns Active render context or `undefined` outside render execution.
- */
-export declare function getComponentRenderContext(): ComponentRenderContext | undefined;
-/**
- * Allocates the next marker node id in the active render context.
- *
- * @param context Active render context.
- * @returns Stable marker node id for this render pass.
- */
-export declare function createNodeId(context: ComponentRenderContext): MarkerNodeId;
-/**
- * Allocates the next props reference id in the active render context.
- *
- * @param context Active render context.
- * @returns Props reference key.
- */
-export declare function createPropsRef(context: ComponentRenderContext): string;
-/**
- * Allocates the next slot reference id in the active render context.
- *
- * @param context Active render context.
- * @returns Slot reference key.
- */
-export declare function createSlotRef(context: ComponentRenderContext): string;
-/**
- * Runs render work under a fresh component render context and returns both:
- * - the render result value
- * - captured graph reference maps for downstream marker resolution
- *
- * @param input Execution metadata for current integration and boundary policy.
- * @param render Async render function to execute inside the context.
- * @returns Render result and captured graph context maps.
- */
-export declare function runWithComponentRenderContext<T>(input: {
-    currentIntegration: string;
-    boundaryContext: ComponentRenderBoundaryContext;
-}, render: () => Promise<T>): Promise<{
-    value: T;
-    graphContext: ComponentGraphContext;
-}>;
-export {};

package/src/eco/component-render-context.js

@@ -1,87 +0,0 @@
-const GLOBAL_COMPONENT_RENDER_CONTEXT_STATE_KEY = "__ECOPAGES_COMPONENT_RENDER_CONTEXT_STATE__";
-function getComponentRenderContextState() {
-  const globalScope = globalThis;
-  globalScope[GLOBAL_COMPONENT_RENDER_CONTEXT_STATE_KEY] ??= {
-    contextStack: [],
-    nodeContextStorage: null,
-    nodeContextStorageLoader: null
-  };
-  return globalScope[GLOBAL_COMPONENT_RENDER_CONTEXT_STATE_KEY];
-}
-async function getContextStorage() {
-  const state = getComponentRenderContextState();
-  if (state.nodeContextStorage) {
-    return state.nodeContextStorage;
-  }
-  if (state.nodeContextStorageLoader) {
-    return state.nodeContextStorageLoader;
-  }
-  state.nodeContextStorageLoader = import("node:async_hooks").then((module) => {
-    const storage = new module.AsyncLocalStorage();
-    state.nodeContextStorage = {
-      getStore: () => storage.getStore(),
-      run: (store, callback) => storage.run(store, callback)
-    };
-    return state.nodeContextStorage;
-  }).catch(() => {
-    state.nodeContextStorage = null;
-    return null;
-  }).finally(() => {
-    state.nodeContextStorageLoader = null;
-  });
-  return state.nodeContextStorageLoader;
-}
-function getComponentRenderContext() {
-  const state = getComponentRenderContextState();
-  return state.nodeContextStorage?.getStore() ?? state.contextStack[state.contextStack.length - 1];
-}
-function createNodeId(context) {
-  context.nextNodeId += 1;
-  return `n_${context.nextNodeId}`;
-}
-function createPropsRef(context) {
-  context.nextPropsRefId += 1;
-  return `p_${context.nextPropsRefId}`;
-}
-function createSlotRef(context) {
-  context.nextSlotRefId += 1;
-  return `s_${context.nextSlotRefId}`;
-}
-async function runWithComponentRenderContext(input, render) {
-  const context = {
-    currentIntegration: input.currentIntegration,
-    boundaryContext: input.boundaryContext,
-    nextNodeId: 0,
-    nextPropsRefId: 0,
-    nextSlotRefId: 0,
-    propsByRef: {},
-    slotChildrenByRef: {}
-  };
-  const storage = await getContextStorage();
-  let value;
-  if (storage) {
-    value = await storage.run(context, render);
-  } else {
-    const state = getComponentRenderContextState();
-    state.contextStack.push(context);
-    try {
-      value = await render();
-    } finally {
-      state.contextStack.pop();
-    }
-  }
-  return {
-    value,
-    graphContext: {
-      propsByRef: context.propsByRef,
-      slotChildrenByRef: context.slotChildrenByRef
-    }
-  };
-}
-export {
-  createNodeId,
-  createPropsRef,
-  createSlotRef,
-  getComponentRenderContext,
-  runWithComponentRenderContext
-};

package/src/eco/component-render-context.ts

@@ -1,224 +0,0 @@
-import type { EcoComponent } from '../public-types.ts';
-import type { MarkerNodeId } from '../route-renderer/component-graph/component-marker.ts';
-
-/**
- * Outcome returned by boundary policy during one component render pass.
- *
- * - `inline`: render the target component immediately in the current pass
- * - `defer`: emit an `eco-marker` and resolve it during the marker graph phase
- */
-export type BoundaryRenderMode = 'inline' | 'defer';
-
-/**
- * Input provided to boundary policy when a component boundary is reached.
- *
- * This keeps `eco.component()` decoupled from concrete integration/plugin
- * objects while still giving policy enough information to decide whether the
- * boundary should render immediately or be deferred.
- */
-export type BoundaryRenderDecisionInput = {
-	currentIntegration: string;
-	targetIntegration?: string;
-	component: EcoComponent;
-};
-
-/**
- * Narrow render-pass facade used by `eco.component()` for boundary decisions.
- *
- * The boundary context is intentionally small so component rendering can remain
- * unaware of integration registries, plugin instances, or renderer lifecycles.
- */
-export type ComponentRenderBoundaryContext = {
-	/**
-	 * Decides whether the next component boundary should render inline or defer to
-	 * the marker graph stage.
-	 *
-	 * @param input Boundary metadata for the current render pass.
-	 * @returns Boundary rendering mode for the target component.
-	 */
-	decideBoundaryRender(input: BoundaryRenderDecisionInput): BoundaryRenderMode;
-};
-
-/**
- * Per-render mutable state used while collecting marker graph references.
- *
- * Counters generate deterministic ids within one render execution.
- */
-type ComponentRenderContext = {
-	currentIntegration: string;
-	boundaryContext: ComponentRenderBoundaryContext;
-	nextNodeId: number;
-	nextPropsRefId: number;
-	nextSlotRefId: number;
-	propsByRef: Record<string, Record<string, unknown>>;
-	slotChildrenByRef: Record<string, MarkerNodeId[]>;
-};
-
-/**
- * Serializable graph context captured from one render execution.
- *
- * This payload is merged with explicit page-module graph context before marker
- * resolution in the route renderer.
- */
-export type ComponentGraphContext = {
-	propsByRef: Record<string, Record<string, unknown>>;
-	slotChildrenByRef: Record<string, MarkerNodeId[]>;
-};
-
-type ContextStorage = {
-	getStore(): ComponentRenderContext | undefined;
-	run<T>(store: ComponentRenderContext, callback: () => Promise<T>): Promise<T>;
-};
-
-type ComponentRenderContextState = {
-	contextStack: ComponentRenderContext[];
-	nodeContextStorage: ContextStorage | null;
-	nodeContextStorageLoader: Promise<ContextStorage | null> | null;
-};
-
-const GLOBAL_COMPONENT_RENDER_CONTEXT_STATE_KEY = '__ECOPAGES_COMPONENT_RENDER_CONTEXT_STATE__';
-
-function getComponentRenderContextState(): ComponentRenderContextState {
-	const globalScope = globalThis as typeof globalThis & {
-		__ECOPAGES_COMPONENT_RENDER_CONTEXT_STATE__?: ComponentRenderContextState;
-	};
-
-	globalScope[GLOBAL_COMPONENT_RENDER_CONTEXT_STATE_KEY] ??= {
-		contextStack: [],
-		nodeContextStorage: null,
-		nodeContextStorageLoader: null,
-	};
-
-	return globalScope[GLOBAL_COMPONENT_RENDER_CONTEXT_STATE_KEY];
-}
-
-/**
- * Lazily initializes async context storage for Node runtimes.
- *
- * Falls back to in-memory stack mode when async_hooks is unavailable.
- *
- * @returns Async context storage when available; otherwise `null`.
- */
-async function getContextStorage(): Promise<ContextStorage | null> {
-	const state = getComponentRenderContextState();
-
-	if (state.nodeContextStorage) {
-		return state.nodeContextStorage;
-	}
-
-	if (state.nodeContextStorageLoader) {
-		return state.nodeContextStorageLoader;
-	}
-
-	state.nodeContextStorageLoader = import('node:async_hooks')
-		.then((module) => {
-			const storage = new module.AsyncLocalStorage<ComponentRenderContext>();
-			state.nodeContextStorage = {
-				getStore: () => storage.getStore(),
-				run: (store, callback) => storage.run(store, callback),
-			};
-			return state.nodeContextStorage;
-		})
-		.catch(() => {
-			state.nodeContextStorage = null;
-			return null;
-		})
-		.finally(() => {
-			state.nodeContextStorageLoader = null;
-		});
-
-	return state.nodeContextStorageLoader;
-}
-
-/**
- * Returns the current component render context, if one is active.
- *
- * @returns Active render context or `undefined` outside render execution.
- */
-export function getComponentRenderContext(): ComponentRenderContext | undefined {
-	const state = getComponentRenderContextState();
-	return state.nodeContextStorage?.getStore() ?? state.contextStack[state.contextStack.length - 1];
-}
-
-/**
- * Allocates the next marker node id in the active render context.
- *
- * @param context Active render context.
- * @returns Stable marker node id for this render pass.
- */
-export function createNodeId(context: ComponentRenderContext): MarkerNodeId {
-	context.nextNodeId += 1;
-	return `n_${context.nextNodeId}`;
-}
-
-/**
- * Allocates the next props reference id in the active render context.
- *
- * @param context Active render context.
- * @returns Props reference key.
- */
-export function createPropsRef(context: ComponentRenderContext): string {
-	context.nextPropsRefId += 1;
-	return `p_${context.nextPropsRefId}`;
-}
-
-/**
- * Allocates the next slot reference id in the active render context.
- *
- * @param context Active render context.
- * @returns Slot reference key.
- */
-export function createSlotRef(context: ComponentRenderContext): string {
-	context.nextSlotRefId += 1;
-	return `s_${context.nextSlotRefId}`;
-}
-
-/**
- * Runs render work under a fresh component render context and returns both:
- * - the render result value
- * - captured graph reference maps for downstream marker resolution
- *
- * @param input Execution metadata for current integration and boundary policy.
- * @param render Async render function to execute inside the context.
- * @returns Render result and captured graph context maps.
- */
-export async function runWithComponentRenderContext<T>(
-	input: {
-		currentIntegration: string;
-		boundaryContext: ComponentRenderBoundaryContext;
-	},
-	render: () => Promise<T>,
-): Promise<{ value: T; graphContext: ComponentGraphContext }> {
-	const context: ComponentRenderContext = {
-		currentIntegration: input.currentIntegration,
-		boundaryContext: input.boundaryContext,
-		nextNodeId: 0,
-		nextPropsRefId: 0,
-		nextSlotRefId: 0,
-		propsByRef: {},
-		slotChildrenByRef: {},
-	};
-
-	const storage = await getContextStorage();
-
-	let value: T;
-	if (storage) {
-		value = await storage.run(context, render);
-	} else {
-		const state = getComponentRenderContextState();
-		state.contextStack.push(context);
-		try {
-			value = await render();
-		} finally {
-			state.contextStack.pop();
-		}
-	}
-
-	return {
-		value,
-		graphContext: {
-			propsByRef: context.propsByRef,
-			slotChildrenByRef: context.slotChildrenByRef,
-		},
-	};
-}