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

package/src/dev/sc-server.d.ts

@@ -0,0 +1,30 @@
+import type { Server } from 'bun';
+import type { EcoPagesAppConfig } from '../types/internal-types.js';
+type StaticContentServerOptions = {
+    port?: number;
+};
+/**
+ * Static content server for production builds.
+ * Serves pre-built static files from the dist directory with gzip compression support.
+ */
+export declare class StaticContentServer {
+    server: Server<unknown> | null;
+    private appConfig;
+    private options;
+    constructor({ appConfig, options }: {
+        appConfig: EcoPagesAppConfig;
+        options?: StaticContentServerOptions;
+    });
+    private shouldServeGzip;
+    private isHtml;
+    private sendNotFoundPage;
+    private serveFromDir;
+    fetch(request: Request): Promise<Response>;
+    private startServer;
+    stop(): void;
+    static createServer({ appConfig, options, }: {
+        appConfig: EcoPagesAppConfig;
+        options?: StaticContentServerOptions;
+    }): StaticContentServer;
+}
+export {};

package/src/dev/sc-server.js

@@ -0,0 +1,111 @@
+import { extname, join } from "node:path";
+import { STATUS_MESSAGE } from "../config/constants.js";
+import { fileSystem } from "@ecopages/file-system";
+import { ServerUtils } from "../utils/server-utils.module.js";
+import { getRequiredBunRuntime } from "../utils/runtime.js";
+class StaticContentServer {
+  server = null;
+  appConfig;
+  options = { port: 3e3 };
+  constructor({ appConfig, options }) {
+    this.appConfig = appConfig;
+    if (options) this.options = options;
+    this.startServer();
+  }
+  shouldServeGzip(contentType) {
+    return ["text/javascript", "text/css"].includes(contentType);
+  }
+  isHtml(contentType) {
+    return contentType === "text/html";
+  }
+  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), {
+      headers: { "Content-Type": "text/html" }
+    });
+    return response;
+  }
+  async serveFromDir({ path, request }) {
+    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);
+          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);
+        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);
+          return new Response(file, {
+            headers: {
+              "Content-Type": ServerUtils.getContentType(extname(candidate))
+            }
+          });
+        }
+      }
+      return this.sendNotFoundPage();
+    } catch {
+      return this.sendNotFoundPage();
+    }
+  }
+  async fetch(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
+    });
+  }
+  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
+  }) {
+    return new StaticContentServer({
+      appConfig,
+      options
+    });
+  }
+}
+export {
+  StaticContentServer
+};

package/src/eco/eco.browser.d.ts

@@ -0,0 +1,2 @@
+import type { Eco } from './eco.types.js';
+export declare const eco: Eco;

package/src/eco/eco.browser.js

@@ -0,0 +1,83 @@
+function createComponentFactory(options) {
+  const component2 = ((props) => options.render(props));
+  component2.config = {
+    __eco: options.__eco,
+    integration: options.integration,
+    dependencies: options.dependencies
+  };
+  return component2;
+}
+function component(options) {
+  return createComponentFactory(options);
+}
+function html(options) {
+  return createComponentFactory(options);
+}
+function layout(options) {
+  return createComponentFactory(options);
+}
+function page(options) {
+  const {
+    layout: pageLayout,
+    dependencies,
+    render,
+    staticPaths: staticPaths2,
+    staticProps: staticProps2,
+    metadata: metadata2,
+    cache,
+    requires,
+    middleware
+  } = options;
+  const pageComponent = createComponentFactory({
+    __eco: options.__eco,
+    integration: options.integration,
+    dependencies: pageLayout ? {
+      ...dependencies,
+      components: [...dependencies?.components ?? [], pageLayout]
+    } : dependencies,
+    render
+  });
+  if (pageLayout && pageComponent.config) {
+    pageComponent.config.layout = pageLayout;
+  }
+  if (staticPaths2) {
+    pageComponent.staticPaths = staticPaths2;
+  }
+  if (staticProps2) {
+    pageComponent.staticProps = staticProps2;
+  }
+  if (metadata2) {
+    pageComponent.metadata = metadata2;
+  }
+  if (cache) {
+    pageComponent.cache = cache;
+  }
+  if (requires) {
+    pageComponent.requires = requires;
+  }
+  if (middleware) {
+    pageComponent.middleware = middleware;
+  }
+  return pageComponent;
+}
+function metadata(fn) {
+  return fn;
+}
+function staticPaths(fn) {
+  return fn;
+}
+function staticProps(fn) {
+  return fn;
+}
+const eco = {
+  component,
+  html,
+  layout,
+  page,
+  metadata,
+  staticPaths,
+  staticProps
+};
+export {
+  eco
+};

package/src/eco/eco.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The eco namespace - unified component and page factory API
+ * @module
+ */
+import type { Eco } from './eco.types.js';
+/**
+ * The eco namespace - provides factories for components and pages
+ */
+export declare const eco: Eco;

package/src/eco/eco.js

@@ -0,0 +1,85 @@
+import {
+  finalizeComponentRender,
+  interceptComponentBoundary
+} from "../route-renderer/orchestration/component-render-context.js";
+import { isThenable } from "../route-renderer/orchestration/render-output.utils.js";
+function createComponentFactory(options) {
+  const integrationName = options.integration ?? options.__eco?.integration;
+  const comp = ((props) => {
+    const componentProps = props ?? {};
+    const renderInline = () => finalizeComponentRender(comp, options.render(props));
+    const boundaryRender = interceptComponentBoundary({
+      component: comp,
+      props: componentProps,
+      targetIntegration: integrationName
+    });
+    if (isThenable(boundaryRender)) {
+      return boundaryRender.then(
+        (resolvedBoundaryRender) => resolvedBoundaryRender !== void 0 ? resolvedBoundaryRender : renderInline()
+      );
+    }
+    if (boundaryRender !== void 0) {
+      return boundaryRender;
+    }
+    return renderInline();
+  });
+  comp.config = {
+    __eco: options.__eco,
+    integration: options.integration,
+    dependencies: options.dependencies
+  };
+  return comp;
+}
+function component(options) {
+  return createComponentFactory(options);
+}
+function html(options) {
+  return createComponentFactory(options);
+}
+function layout(options) {
+  return createComponentFactory(options);
+}
+function page(options) {
+  const { layout: layout2, dependencies, render, staticPaths: staticPaths2, staticProps: staticProps2, metadata: metadata2, cache, requires, middleware } = options;
+  const componentOptions = {
+    __eco: options.__eco,
+    integration: options.integration,
+    dependencies: layout2 ? {
+      ...dependencies,
+      components: [...dependencies?.components || [], layout2]
+    } : dependencies,
+    render
+  };
+  const pageComponent = createComponentFactory(componentOptions);
+  if (layout2 && pageComponent.config) {
+    pageComponent.config.layout = layout2;
+  }
+  if (staticPaths2) pageComponent.staticPaths = staticPaths2;
+  if (staticProps2) pageComponent.staticProps = staticProps2;
+  if (metadata2) pageComponent.metadata = metadata2;
+  if (cache) pageComponent.cache = cache;
+  if (requires) pageComponent.requires = requires;
+  if (middleware) pageComponent.middleware = middleware;
+  return pageComponent;
+}
+function metadata(fn) {
+  return fn;
+}
+function staticPaths(fn) {
+  return fn;
+}
+function staticProps(fn) {
+  return fn;
+}
+const eco = {
+  component,
+  html,
+  layout,
+  page,
+  metadata,
+  staticPaths,
+  staticProps
+};
+export {
+  eco
+};

package/src/eco/eco.types.d.ts

@@ -0,0 +1,178 @@
+/**
+ * Type definitions for the eco namespace API
+ * @module
+ */
+import type { DependencyLazyTrigger, EcoComponent, EcoComponentDependencies, EcoHtmlComponent, EcoInjectedMeta, EcoLayoutComponent, EcoPageLayoutComponent, EcoPagesElement, GetMetadata, GetStaticPaths, GetStaticProps, HtmlTemplateProps, LayoutProps, Middleware, RequestLocals, RequestPageContext } from '../types/public-types.js';
+import type { CacheStrategy } from '../services/cache/cache.types.js';
+type WithRequiredLocals<K extends keyof RequestLocals> = Omit<RequestLocals, K> & {
+    [P in K]-?: Exclude<RequestLocals[P], null | undefined>;
+};
+type RequiresKeys = keyof RequestLocals;
+export type PageRequires<K extends RequiresKeys = RequiresKeys> = K | readonly K[];
+/**
+ * Lazy trigger options map directly to scripts-injector attributes.
+ * Only one trigger type can be active at a time.
+ */
+export type LazyTrigger = DependencyLazyTrigger;
+/**
+ * Options for creating a component with eco.component()
+ * @template P - The props type for the component
+ * @template E - The element/return type (defaults to EcoPagesElement for Kita, use ReactNode for React)
+ */
+export interface ComponentOptions<P, E = EcoPagesElement> {
+    /** @internal Injected by eco-component-meta-plugin */
+    __eco?: EcoInjectedMeta;
+    integration?: string;
+    dependencies?: EcoComponentDependencies;
+    render: (props: P) => E | Promise<E>;
+}
+export type HtmlOptions<E = EcoPagesElement> = ComponentOptions<HtmlTemplateProps, E>;
+export type LayoutOptions<E = EcoPagesElement> = ComponentOptions<LayoutProps<E>, E>;
+/**
+ * Base options shared by all page variants
+ */
+export interface PageOptionsBase<T, E = EcoPagesElement> {
+    /** @internal Injected by eco-component-meta-plugin */
+    __eco?: EcoInjectedMeta;
+    integration?: string;
+    dependencies?: EcoComponentDependencies;
+    layout?: EcoPageLayoutComponent<E>;
+    /**
+     * Define static paths for dynamic routes (e.g., [slug].tsx).
+     * Returns all possible paths that should be pre-rendered at build time.
+     */
+    staticPaths?: GetStaticPaths;
+    /**
+     * Fetch data for the page at build time.
+     * Props returned here are passed to both render() and metadata().
+     */
+    staticProps?: GetStaticProps<T>;
+    /**
+     * Generate page metadata (title, description, etc.).
+     * Receives props from staticProps if defined.
+     */
+    metadata?: GetMetadata<T>;
+    /**
+     * Declares which `locals` keys must be present for this page.
+     *
+     * This is a typing and documentation feature; runtime enforcement must be done via handler/page middleware.
+     */
+    requires?: PageRequires;
+    render: (props: PagePropsFor<T> & Partial<RequestPageContext>) => E | Promise<E>;
+}
+/**
+ * Page options without middleware - allows any cache strategy
+ */
+interface PageOptionsWithoutMiddleware<T, E = EcoPagesElement> extends PageOptionsBase<T, E> {
+    /**
+     * Cache configuration for ISR (Incremental Static Regeneration).
+     * - `'static'`: Cache indefinitely (default)
+     * - `'dynamic'`: No caching, render on every request
+     * - `{ revalidate: number, tags?: string[] }`: Cache with time-based revalidation
+     */
+    cache?: CacheStrategy;
+    middleware?: undefined;
+}
+/**
+ * Page options with middleware - requires cache: 'dynamic'
+ */
+interface PageOptionsWithMiddleware<T, E = EcoPagesElement> extends PageOptionsBase<T, E> {
+    /**
+     * Cache must be 'dynamic' when using middleware.
+     * Middleware runs on every request, so caching would bypass middleware effects.
+     */
+    cache: 'dynamic';
+    /**
+     * Request-time middleware for file-based routes.
+     * Runs before rendering and can short-circuit by returning a Response.
+     */
+    middleware: Middleware[];
+}
+/**
+ * Options for creating a page with eco.page()
+ *
+ * Supports two patterns:
+ * 1. **Consolidated API** (recommended): Define staticPaths, staticProps, and metadata inline
+ * 2. **Separate exports** (legacy): Export getStaticPaths, getStaticProps, getMetadata separately
+ *
+ * When using `middleware`, `cache` must be set to `'dynamic'` because middleware
+ * runs on every request and caching would bypass middleware effects.
+ *
+ * @template T - The props type for the page
+ * @template E - The element/return type (defaults to EcoPagesElement for Kita, use ReactNode for React)
+ */
+export type PageOptions<T, E = EcoPagesElement> = PageOptionsWithoutMiddleware<T, E> | PageOptionsWithMiddleware<T, E>;
+export type PagePropsForWithLocals<T, K extends RequiresKeys | never = never> = PagePropsFor<T> & (K extends never ? Partial<RequestPageContext> : Omit<Partial<RequestPageContext>, 'locals'> & {
+    locals: WithRequiredLocals<Extract<K, keyof RequestLocals>>;
+});
+/**
+ * Extracts props type from getStaticProps return type, or uses T directly if it's a props object.
+ * Always includes params and query for page context.
+ */
+export type PagePropsFor<T> = T extends GetStaticProps<infer P> ? P & {
+    params?: Record<string, string>;
+    query?: Record<string, string>;
+} : T & {
+    params?: Record<string, string>;
+    query?: Record<string, string>;
+};
+/**
+ * A page component with optional attached static functions.
+ * Used by the consolidated eco.page() API where staticPaths, staticProps,
+ * and metadata are defined inline and attached to the component.
+ */
+export type EcoPageComponent<T> = EcoComponent<PagePropsFor<T> & Partial<RequestPageContext>> & {
+    staticPaths?: GetStaticPaths;
+    staticProps?: GetStaticProps<T>;
+    metadata?: GetMetadata<T>;
+    cache?: CacheStrategy;
+    requires?: PageRequires;
+    middleware?: Middleware[];
+};
+/**
+ * The eco namespace interface
+ */
+export interface Eco {
+    /**
+     * Create a reusable component with dependencies and optional lazy-loading.
+     * @template P - Props type
+     * @template E - Element/return type (EcoPagesElement for Kita, ReactNode for React)
+     */
+    component: <P = {}, E = EcoPagesElement>(options: ComponentOptions<P, E>) => EcoComponent<P, E>;
+    /**
+     * Create a document shell component for the HTML wrapper.
+     */
+    html: <E = EcoPagesElement>(options: HtmlOptions<E>) => EcoHtmlComponent<E>;
+    /**
+     * Create a route layout component.
+     */
+    layout: <E = EcoPagesElement>(options: LayoutOptions<E>) => EcoLayoutComponent<E>;
+    /**
+     * Create a page component with type-safe props from getStaticProps.
+     * Returns an EcoPageComponent with attached staticPaths, staticProps, and metadata.
+     *
+     * If `requires` is provided, the `render` callback receives `locals` as required and non-null for the required keys.
+     */
+    page: {
+        <T = {}, E = EcoPagesElement>(options: PageOptions<T, E> & {
+            requires?: undefined;
+        }): EcoPageComponent<T>;
+        <T = {}, E = EcoPagesElement, const K extends RequiresKeys = RequiresKeys>(options: Omit<PageOptions<T, E>, 'render' | 'requires'> & {
+            requires: PageRequires<K>;
+            render: (props: PagePropsForWithLocals<T, K>) => E | Promise<E>;
+        }): EcoPageComponent<T>;
+    };
+    /**
+     * Type-safe wrapper for page metadata (identity function)
+     */
+    metadata: <P = {}>(fn: GetMetadata<P>) => GetMetadata<P>;
+    /**
+     * Type-safe wrapper for static paths (identity function)
+     */
+    staticPaths: (fn: GetStaticPaths) => GetStaticPaths;
+    /**
+     * Type-safe wrapper for static props (identity function)
+     */
+    staticProps: <P>(fn: GetStaticProps<P>) => GetStaticProps<P>;
+}
+export {};

package/src/eco/eco.utils.d.ts

@@ -0,0 +1 @@
+export { addTriggerAttribute, isThenable, wrapWithScriptsInjector, } from '../route-renderer/orchestration/render-output.utils.js';

package/src/eco/eco.utils.js

@@ -0,0 +1,10 @@
+import {
+  addTriggerAttribute,
+  isThenable,
+  wrapWithScriptsInjector
+} from "../route-renderer/orchestration/render-output.utils.js";
+export {
+  addTriggerAttribute,
+  isThenable,
+  wrapWithScriptsInjector
+};

package/src/eco/global-injector-map.d.ts

@@ -0,0 +1,16 @@
+import type { ResolvedLazyTrigger } from '../types/public-types.js';
+/**
+ * Serializes resolved lazy triggers into a JSON string safe for embedding
+ * inside an inline `<script type="ecopages/global-injector-map">` tag.
+ *
+ * The `</script` sequence is escaped because an unescaped occurrence in inline
+ * script content causes the HTML parser to close the script tag prematurely,
+ * breaking page rendering. `JSON.stringify` does not perform this escape by
+ * default, so a targeted replacement is applied after serialization.
+ */
+export declare function buildGlobalInjectorMapScript(triggers: ResolvedLazyTrigger[]): string;
+/**
+ * Builds the module source that boots the global lazy injector on the client.
+ * Emitted once per page alongside the `ecopages/global-injector-map` script block.
+ */
+export declare function buildGlobalInjectorBootstrapContent(globalInjectorModuleSpecifier: string): string;

package/src/eco/global-injector-map.js

@@ -0,0 +1,80 @@
+function buildGlobalInjectorMap(triggers) {
+  const map = {};
+  for (const { triggerId, rules } of triggers) {
+    const entry = map[triggerId] ?? {};
+    for (const rule of rules) {
+      if ("on:idle" in rule) {
+        const { scripts } = rule["on:idle"];
+        entry["on:idle"] = {
+          scripts: Array.from(/* @__PURE__ */ new Set([...entry["on:idle"]?.scripts ?? [], ...scripts]))
+        };
+        continue;
+      }
+      if ("on:interaction" in rule) {
+        const { value, scripts } = rule["on:interaction"];
+        entry["on:interaction"] = {
+          value,
+          scripts: Array.from(/* @__PURE__ */ new Set([...entry["on:interaction"]?.scripts ?? [], ...scripts]))
+        };
+        continue;
+      }
+      if ("on:visible" in rule) {
+        const { value, scripts } = rule["on:visible"];
+        entry["on:visible"] = {
+          ...value ? { value } : {},
+          scripts: Array.from(/* @__PURE__ */ new Set([...entry["on:visible"]?.scripts ?? [], ...scripts]))
+        };
+        continue;
+      }
+    }
+    if (Object.keys(entry).length > 0) {
+      map[triggerId] = entry;
+    }
+  }
+  return map;
+}
+function buildGlobalInjectorMapScript(triggers) {
+  const map = buildGlobalInjectorMap(triggers);
+  return JSON.stringify(map).replace(/<\/script/gi, "<\\/script");
+}
+function buildGlobalInjectorBootstrapContent(globalInjectorModuleSpecifier) {
+  return `import { initGlobalInjector } from ${JSON.stringify(globalInjectorModuleSpecifier)};
+
+function pruneStaleTriggerMaps() {
+	const mapScripts = Array.from(document.querySelectorAll('script[type="ecopages/global-injector-map"]'));
+	if (mapScripts.length <= 1) {
+		return;
+	}
+
+	const latestMapScript = mapScripts[mapScripts.length - 1];
+	for (const mapScript of mapScripts) {
+		if (mapScript !== latestMapScript) {
+			mapScript.remove();
+		}
+	}
+}
+
+const globalScope = window;
+if (typeof globalScope.__ecoGlobalInjectorCleanup === 'function') {
+	globalScope.__ecoGlobalInjectorCleanup();
+}
+
+const injector = initGlobalInjector();
+
+const handleAfterSwap = () => {
+	pruneStaleTriggerMaps();
+	injector.refresh();
+};
+
+document.addEventListener('eco:after-swap', handleAfterSwap);
+pruneStaleTriggerMaps();
+
+globalScope.__ecoGlobalInjectorCleanup = () => {
+	document.removeEventListener('eco:after-swap', handleAfterSwap);
+	injector.cleanup();
+};`;
+}
+export {
+  buildGlobalInjectorBootstrapContent,
+  buildGlobalInjectorMapScript
+};

package/src/eco/lazy-injector-map.d.ts

@@ -0,0 +1,8 @@
+import type { ResolvedLazyScriptGroup } from '../types/public-types.js';
+/**
+ * Creates a safe JSON payload string for `<script type="ecopages/injector-map">`.
+ *
+ * @param lazyGroups Lazy script groups resolved during dependency processing.
+ * @returns Escaped JSON string safe for inline script embedding.
+ */
+export declare function buildInjectorMapScript(lazyGroups: readonly ResolvedLazyScriptGroup[]): string;