@ecopages/core 0.2.0-alpha.23 → 0.2.0-alpha.25

package/src/adapters/shared/hmr-html-response.js

@@ -1,32 +0,0 @@
-const HMR_RUNTIME_IMPORT = "import '/_hmr_runtime.js'";
-const HMR_RUNTIME_SCRIPT = `<script type="module">${HMR_RUNTIME_IMPORT};<\/script>`;
-function isHtmlResponse(response) {
-  const contentType = response.headers.get("Content-Type");
-  return contentType !== null && contentType.startsWith("text/html");
-}
-function shouldInjectHmrHtmlResponse(watch, hmrManager) {
-  return watch && hmrManager?.isEnabled() === true;
-}
-async function injectHmrRuntimeIntoHtmlResponse(response) {
-  const html = await response.text();
-  if (html.includes(HMR_RUNTIME_IMPORT)) {
-    return new Response(html, {
-      status: response.status,
-      statusText: response.statusText,
-      headers: response.headers
-    });
-  }
-  const updatedHtml = html.replace(/<\/html>/i, `${HMR_RUNTIME_SCRIPT}</html>`);
-  const headers = new Headers(response.headers);
-  headers.delete("Content-Length");
-  return new Response(updatedHtml, {
-    status: response.status,
-    statusText: response.statusText,
-    headers
-  });
-}
-export {
-  injectHmrRuntimeIntoHtmlResponse,
-  isHtmlResponse,
-  shouldInjectHmrHtmlResponse
-};

package/src/adapters/shared/render-context.d.ts

@@ -1,15 +0,0 @@
-import type { RenderContext } from '../../types/public-types.js';
-import type { IntegrationPlugin } from '../../plugins/integration-plugin.js';
-export interface CreateRenderContextOptions {
-    integrations: IntegrationPlugin[];
-    rendererModules?: unknown;
-}
-/**
- * Creates a render context for route handlers.
- * Provides render(), renderPartial(), json(), and html() methods that can be used
- * within route handlers to generate responses.
- *
- * @param options - Configuration options including available integrations
- * @returns A RenderContext object with methods for rendering views and creating responses
- */
-export declare function createRenderContext(options: CreateRenderContextOptions): RenderContext;

package/src/adapters/shared/render-context.js

@@ -1,72 +0,0 @@
-import { invariant } from "../../utils/invariant.js";
-function mergePropsWithLocals(props, locals) {
-  if (!locals || typeof props !== "object" || props === null) {
-    return props;
-  }
-  return { ...props, locals };
-}
-function createRenderContext(options) {
-  const { integrations } = options;
-  const getRendererForView = (view) => {
-    const integrationName = view.config?.integration ?? view.config?.__eco?.integration;
-    invariant(
-      !!integrationName,
-      "Cannot determine integration for view. Set view.config.integration explicitly or ensure the view is defined with eco.page() in a file with a recognized extension."
-    );
-    const integration = integrations.find((i) => i.name === integrationName);
-    invariant(!!integration, `No integration found for: ${integrationName}`);
-    return integration.initializeRenderer({
-      rendererModules: options.rendererModules
-    });
-  };
-  const renderContext = {
-    async render(view, props, renderOptions) {
-      const locals = this?.locals;
-      const mergedProps = mergePropsWithLocals(props ?? {}, locals);
-      const renderer = getRendererForView(view);
-      const ctx = {
-        partial: false,
-        status: renderOptions?.status,
-        headers: renderOptions?.headers
-      };
-      return renderer.renderToResponse(view, mergedProps, ctx);
-    },
-    async renderPartial(view, props, renderOptions) {
-      const locals = this?.locals;
-      const mergedProps = mergePropsWithLocals(props, locals);
-      const renderer = getRendererForView(view);
-      const ctx = {
-        partial: true,
-        status: renderOptions?.status,
-        headers: renderOptions?.headers
-      };
-      return renderer.renderToResponse(view, mergedProps, ctx);
-    },
-    json(data, responseOptions) {
-      const headers = new Headers({ "Content-Type": "application/json; charset=utf-8" });
-      if (responseOptions?.headers) {
-        const incomingHeaders = new Headers(responseOptions.headers);
-        incomingHeaders.forEach((value, key) => headers.set(key, value));
-      }
-      return new Response(JSON.stringify(data), {
-        status: responseOptions?.status ?? 200,
-        headers
-      });
-    },
-    html(content, responseOptions) {
-      const headers = new Headers({ "Content-Type": "text/html; charset=utf-8" });
-      if (responseOptions?.headers) {
-        const incomingHeaders = new Headers(responseOptions.headers);
-        incomingHeaders.forEach((value, key) => headers.set(key, value));
-      }
-      return new Response(content, {
-        status: responseOptions?.status ?? 200,
-        headers
-      });
-    }
-  };
-  return renderContext;
-}
-export {
-  createRenderContext
-};

package/src/adapters/shared/runtime-bootstrap.d.ts

@@ -1,38 +0,0 @@
-import { type BuildExecutor } from '../../build/build-adapter.js';
-import type { EcoBuildPlugin } from '../../build/build-types.js';
-import type { EcoPagesAppConfig, IClientBridge, IHmrManager } from '../../types/internal-types.js';
-/**
- * Installs and returns the app-owned runtime build executor used by adapter
- * startup and follow-up runtime work.
- */
-export declare function installSharedRuntimeBuildExecutor(appConfig: EcoPagesAppConfig, options: {
-    development: boolean;
-}): BuildExecutor;
-/**
- * Copies app public assets into dist and ensures the resolved assets directory
- * exists before request handling begins.
- */
-export declare function prepareSharedRuntimePublicDir(appConfig: EcoPagesAppConfig): void;
-/**
- * Runs runtime plugin setup against app-owned config/runtime state and optional
- * host plugin registration hooks.
- */
-export declare function initializeSharedRuntimePlugins(options: {
-    appConfig: EcoPagesAppConfig;
-    runtimeOrigin: string;
-    hmrManager?: IHmrManager;
-    onRuntimePlugin?: (plugin: unknown) => void;
-}): Promise<void>;
-/**
- * Starts shared project watching for runtime adapters.
- */
-export declare function startSharedProjectWatching(options: {
-    appConfig: EcoPagesAppConfig;
-    refreshRouterRoutesCallback: () => Promise<void>;
-    hmrManager: IHmrManager;
-    bridge: IClientBridge;
-}): Promise<void>;
-/**
- * Binds a runtime HMR manager to app-owned plugin and integration state.
- */
-export declare function bindSharedRuntimeHmrManager(appConfig: EcoPagesAppConfig, hmrManager: IHmrManager): EcoBuildPlugin[];

package/src/adapters/shared/runtime-bootstrap.js

@@ -1,43 +0,0 @@
-import path from "node:path";
-import { fileSystem } from "@ecopages/file-system";
-import { getAppBrowserBuildPlugins, setupAppRuntimePlugins } from "../../build/build-adapter.js";
-import { installAppRuntimeBuildExecutor } from "../../build/runtime-build-executor.js";
-import { RESOLVED_ASSETS_DIR } from "../../config/constants.js";
-import { ProjectWatcher } from "../../watchers/project-watcher.js";
-function installSharedRuntimeBuildExecutor(appConfig, options) {
-  return installAppRuntimeBuildExecutor(appConfig, options);
-}
-function prepareSharedRuntimePublicDir(appConfig) {
-  const srcPublicDir = path.join(appConfig.rootDir, appConfig.srcDir, appConfig.publicDir);
-  if (fileSystem.exists(srcPublicDir)) {
-    fileSystem.copyDir(srcPublicDir, path.join(appConfig.rootDir, appConfig.distDir));
-  }
-  fileSystem.ensureDir(path.join(appConfig.absolutePaths.distDir, RESOLVED_ASSETS_DIR));
-}
-async function initializeSharedRuntimePlugins(options) {
-  await setupAppRuntimePlugins(options);
-}
-async function startSharedProjectWatching(options) {
-  const watcher = new ProjectWatcher({
-    config: options.appConfig,
-    refreshRouterRoutesCallback: options.refreshRouterRoutesCallback,
-    hmrManager: options.hmrManager,
-    bridge: options.bridge
-  });
-  await watcher.createWatcherSubscription();
-}
-function bindSharedRuntimeHmrManager(appConfig, hmrManager) {
-  const browserBuildPlugins = getAppBrowserBuildPlugins(appConfig);
-  hmrManager.setPlugins(browserBuildPlugins);
-  for (const integration of appConfig.integrations) {
-    integration.setHmrManager(hmrManager);
-  }
-  return browserBuildPlugins;
-}
-export {
-  bindSharedRuntimeHmrManager,
-  initializeSharedRuntimePlugins,
-  installSharedRuntimeBuildExecutor,
-  prepareSharedRuntimePublicDir,
-  startSharedProjectWatching
-};

package/src/adapters/shared/server-adapter.d.ts

@@ -1,97 +0,0 @@
-import { AbstractServerAdapter } from '../abstract/server-adapter.js';
-import type { ServerAdapterOptions, ServerAdapterResult } from '../abstract/server-adapter.js';
-import { RouteRendererFactory } from '../../route-renderer/route-renderer.js';
-import { FSRouter } from '../../router/server/fs-router.js';
-import { SchemaValidationService } from '../../services/validation/schema-validation-service.js';
-import { StaticSiteGenerator } from '../../static-site-generator/static-site-generator.js';
-import { ServerStaticBuilder } from './server-static-builder.js';
-import { FileSystemResponseMatcher } from './fs-server-response-matcher.js';
-import { ServerRouteHandler } from './server-route-handler.js';
-import type { ApiHandler, CacheInvalidator, ErrorHandler, RenderContext, StaticRoute } from '../../types/public-types.js';
-export declare abstract class SharedServerAdapter<TOptions extends ServerAdapterOptions, TResult extends ServerAdapterResult> extends AbstractServerAdapter<TOptions, TResult> {
-    protected router: FSRouter;
-    protected fileSystemResponseMatcher: FileSystemResponseMatcher;
-    protected routeRendererFactory: RouteRendererFactory;
-    protected routeHandler: ServerRouteHandler;
-    protected staticSiteGenerator: StaticSiteGenerator;
-    protected staticBuilder: ServerStaticBuilder;
-    protected readonly schemaValidator: SchemaValidationService;
-    protected initializeSharedRouteHandling(options: {
-        staticRoutes: StaticRoute[];
-        hmrManager?: any;
-    }): Promise<void>;
-    protected createSharedWatchRefreshCallback(options: {
-        staticRoutes: StaticRoute[];
-        hmrManager?: any;
-        onRoutesReady?: () => Promise<void> | void;
-        onError?: (error: Error) => Promise<void> | void;
-    }): () => Promise<void>;
-    /**
-     * Scans the filesystem and dynamically constructs the universal router map.
-     *
-     * This process runs identically across both Bun and Node wrappers. It analyzes the configured pages
-     * directory, building a map of all available UI routes and API endpoints.
-     * The resulting `FSRouter` instance becomes the central nervous system for mapping WinterCG incoming
-     * Web Requests (`Request`) to their corresponding internal execution paths.
-     */
-    protected initSharedRouter(): Promise<void>;
-    /**
-     * Sets up the unified rendering pipeline and response matching chain.
-     *
-     * It bridges several sub-systems together so that when an incoming request is received, the adapter knows:
-     * 1. How to render React/Lit pages via `RouteRendererFactory`
-     * 2. How to match logical routes to physical filesystem artifacts via `FileSystemResponseMatcher`
-     * 3. Whether to serve the response from the embedded `PageCacheService` or generate it fresh on the fly.
-     *
-     * Because `HmrManager` implementations rely heavily on runtime-specific WebSocket APIs (e.g. Bun.serve Websockets vs Node WS),
-     * we leave it untyped (`any`) here at the common denominator core.
-     *
-     * @param staticRoutes - A map of explicitly served static assets.
-     * @param hmrManager - The runtime-specific Hot Module Replacement orchestrator (if watching).
-     */
-    protected configureSharedResponseHandlers(staticRoutes: StaticRoute[], hmrManager?: any): void;
-    protected getCacheService(): CacheInvalidator | null;
-    protected getRenderContext(): RenderContext;
-    /**
-     * Executes an Application Programming Interface (API) handler in an environment-agnostic manner.
-     *
-     * API routes in Ecopages are universally written using standard WinterCG `Request` and `Response` objects.
-     * This execution pipeline takes the raw `Request`, extracts its dynamic segments, runs our high-speed JSON schema
-     * validator against the body/query/headers, and triggers the developer's middleware chain sequentially.
-     *
-     * If the execution throws an error, it is gracefully caught, logged, and mutated into a standardized Http error payload,
-     * ensuring the consuming client receives a parsable response even upon internal catastrophic failure.
-     *
-     * @param request - The incoming Web standard `Request`.
-     * @param params - The extracted dynamic URL parameters (e.g., `{ id: '123' }`).
-     * @param routeConfig - The user-defined API handler object containing their business logic (`handler`) and `middleware`.
-     * @param serverInstance - Untyped reference to the underlying native server instance (BunServer/NodeServer) for potential escape hatches.
-     * @param errorHandler - Optional global error trap defined in project configuration.
-     * @returns The resulting Web standard `Response` constructed by the user's handler.
-     */
-    protected executeApiHandler(request: Request, params: Record<string, string | string[]>, routeConfig: ApiHandler, serverInstance: any, errorHandler?: ErrorHandler): Promise<Response>;
-    private normalizePath;
-    private matchApiPath;
-    private getApiPathScore;
-    protected matchApiHandler(request: Request, apiHandlers: ApiHandler[]): {
-        routeConfig: ApiHandler;
-        params: Record<string, string | string[]>;
-    } | null;
-    /**
-     * Universally processes an incoming WinterCG Web standard Request.
-     *
-     * 1. Resolves static Hot Module Replacement runtime blobs if development.
-     * 2. Checks if the incoming request matches any parsed API route schemas.
-     *   - Routes through `executeApiHandler` which performs strict validation.
-     * 3. Falls through to standard `ServerRouteHandler` for React/Lit filesystem pages.
-     *
-     * Both Bun and Node bindings fall back to this exact function once they have mapped their
-     * native HTTP objects into Web Standard Requests.
-     */
-    handleSharedRequest(request: Request, context: {
-        apiHandlers: ApiHandler[];
-        errorHandler?: ErrorHandler;
-        serverInstance?: any;
-        hmrManager?: any;
-    }): Promise<Response>;
-}