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

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

@@ -1,170 +0,0 @@
-/**
- * Type definitions for the eco namespace API
- * @module
- */
-import type { DependencyLazyTrigger, EcoComponent, EcoComponentDependencies, EcoInjectedMeta, EcoPagesElement, GetMetadata, GetStaticPaths, GetStaticProps, Middleware, RequestLocals, RequestPageContext } from '../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>;
-}
-/**
- * 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?: EcoComponent<{
-        children: E;
-    } & Partial<RequestPageContext>>;
-    /**
-     * 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 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

@@ -1,40 +0,0 @@
-import type { EcoComponent } from '../public-types.js';
-/**
- * Returns `true` when `value` is a thenable (Promise-like) object.
- *
- * Used to transparently handle both synchronous and asynchronous component
- * render results without requiring every caller to branch on `instanceof Promise`.
- *
- * @typeParam T Expected resolved type of the thenable.
- */
-export declare function isThenable<T>(value: unknown): value is PromiseLike<T>;
-/**
- * Injects `data-eco-trigger` into the first real HTML element opening tag of
- * a component's rendered output string.
- *
- * The scan skips over leading whitespace, HTML comments (`<!-- -->`), CDATA
- * sections, and doctype declarations so that the attribute is always placed on
- * the first actual element — not spurious markup that can precede it.
- *
- * The insertion point is the end of the element's tag name, before any existing
- * attributes or the closing `>`, which produces output like:
- *
- * ```html
- * <my-element data-eco-trigger="eco-trigger-abc123" class="foo">…</my-element>
- * ```
- *
- * When no eligible opening tag is found the original string is returned
- * unchanged so callers never receive a broken fragment.
- *
- * @param content Rendered HTML string (or any value coercible to string).
- * @param triggerId Stable trigger identifier produced by `buildResolvedLazyTriggers`.
- */
-export declare function addTriggerAttribute(content: unknown, triggerId: string): string;
-/**
- * Wraps rendered component output in a `<scripts-injector>` element that
- * carries an inline injector map for the legacy (non-global-injector) path.
- *
- * @param content Rendered component HTML.
- * @param lazyGroups Resolved lazy script groups attached to the component config.
- */
-export declare function wrapWithScriptsInjector(content: unknown, lazyGroups: NonNullable<EcoComponent['config']>['_resolvedLazyScripts']): string;

package/src/eco/eco.utils.js

@@ -1,40 +0,0 @@
-import { buildInjectorMapScript } from "./lazy-injector-map.js";
-function isThenable(value) {
-  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
-}
-function addTriggerAttribute(content, triggerId) {
-  const str = String(content);
-  let i = 0;
-  while (i < str.length) {
-    if (str[i] !== "<") {
-      i++;
-      continue;
-    }
-    const next = str[i + 1];
-    if (next === "!" || next === "?") {
-      const end = str.indexOf(">", i);
-      if (end === -1) break;
-      i = end + 1;
-      continue;
-    }
-    if (next && /[a-zA-Z]/.test(next)) {
-      const tagSlice = str.slice(i + 1);
-      const nameEnd = tagSlice.search(/[\s/>]/);
-      if (nameEnd === -1) break;
-      const insertAt = i + 1 + nameEnd;
-      return `${str.slice(0, insertAt)} data-eco-trigger="${triggerId}"${str.slice(insertAt)}`;
-    }
-    break;
-  }
-  return str;
-}
-function wrapWithScriptsInjector(content, lazyGroups) {
-  const wrappedContent = String(content);
-  const injectorMapScript = buildInjectorMapScript(lazyGroups ?? []);
-  return `<scripts-injector><script type="ecopages/injector-map">${injectorMapScript}<\/script>${wrappedContent}<\/scripts-injector>`;
-}
-export {
-  addTriggerAttribute,
-  isThenable,
-  wrapWithScriptsInjector
-};

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

@@ -1,16 +0,0 @@
-import type { ResolvedLazyTrigger } from '../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 inline module script 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(globalInjectorModuleUrl: string): string;

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

@@ -1,80 +0,0 @@
-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(globalInjectorModuleUrl) {
-  return `import { initGlobalInjector } from ${JSON.stringify(globalInjectorModuleUrl)};
-
-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

@@ -1,8 +0,0 @@
-import type { ResolvedLazyScriptGroup } from '../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: ResolvedLazyScriptGroup[]): string;

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

@@ -1,70 +0,0 @@
-function normalizeScripts(scripts) {
-  return scripts.split(",").map((scriptPath) => scriptPath.trim()).filter(Boolean).map((scriptPath) => {
-    if (scriptPath.startsWith("/")) {
-      return scriptPath;
-    }
-    const normalizedRelativePath = scriptPath.replace(/^\/+/, "").replace(/^(\.\/)+/, "");
-    return `/${normalizedRelativePath}`;
-  });
-}
-function dedupeCsvValues(values) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const value of values) {
-    for (const token of value.split(",").map((part) => part.trim()).filter(Boolean)) {
-      seen.add(token);
-    }
-  }
-  return Array.from(seen).join(",");
-}
-function buildInjectorMap(lazyGroups) {
-  const map = {};
-  for (const group of lazyGroups) {
-    const scripts = normalizeScripts(group.scripts);
-    const lazy = group.lazy;
-    if ("on:idle" in lazy) {
-      map["on:idle"] = {
-        scripts: [...map["on:idle"]?.scripts ?? [], ...scripts]
-      };
-      continue;
-    }
-    if ("on:interaction" in lazy) {
-      const currentValue = map["on:interaction"]?.value;
-      const nextValue = lazy["on:interaction"];
-      map["on:interaction"] = {
-        value: typeof currentValue === "string" ? dedupeCsvValues([currentValue, nextValue]) : nextValue,
-        scripts: [...map["on:interaction"]?.scripts ?? [], ...scripts]
-      };
-      continue;
-    }
-    if ("on:visible" in lazy) {
-      const currentValue = map["on:visible"]?.value;
-      const currentThreshold = typeof currentValue === "string" ? currentValue : void 0;
-      const nextValue = lazy["on:visible"];
-      map["on:visible"] = {
-        ...nextValue === true ? currentThreshold ? { value: currentThreshold } : {} : { value: String(nextValue) },
-        scripts: [...map["on:visible"]?.scripts ?? [], ...scripts]
-      };
-      continue;
-    }
-    throw new Error(
-      `Invalid lazy options: must specify on:idle, on:interaction, or on:visible. Received: ${JSON.stringify(lazy)}`
-    );
-  }
-  for (const key of Object.keys(map)) {
-    const scripts = map[key]?.scripts;
-    if (scripts) {
-      map[key] = {
-        ...map[key],
-        scripts: Array.from(new Set(scripts))
-      };
-    }
-  }
-  return map;
-}
-function buildInjectorMapScript(lazyGroups) {
-  const map = buildInjectorMap(lazyGroups);
-  return JSON.stringify(map).replace(/<\/script/gi, "<\\/script");
-}
-export {
-  buildInjectorMapScript
-};

package/src/eco/module-dependencies.d.ts

@@ -1,18 +0,0 @@
-export type ModuleDependencyDeclaration = {
-    from: string;
-    imports?: string[];
-};
-/**
- * Parses a module grammar declaration into normalized object form.
- *
- * Supported input examples:
- * - `react-aria-components`
- * - `react-aria-components{Table,Select}`
- */
-export declare function parseModuleDeclaration(value: string): ModuleDependencyDeclaration;
-/**
- * Normalizes and deduplicates module declarations from `modules`.
- *
- * Returns canonical object declarations suitable for downstream bundling logic.
- */
-export declare function normalizeModuleDeclarations(modules?: string[]): ModuleDependencyDeclaration[];

package/src/eco/module-dependencies.js

@@ -1,49 +0,0 @@
-function normalizeImports(imports) {
-  if (!imports || imports.length === 0) {
-    return void 0;
-  }
-  const normalized = Array.from(new Set(imports.map((entry) => entry.trim()).filter((entry) => entry.length > 0)));
-  return normalized.length > 0 ? normalized : void 0;
-}
-function parseModuleDeclaration(value) {
-  const source = value.trim();
-  if (source.length === 0) {
-    throw new Error("Module declaration cannot be empty");
-  }
-  const openBraceIndex = source.indexOf("{");
-  if (openBraceIndex < 0) {
-    return { from: source };
-  }
-  const closeBraceIndex = source.lastIndexOf("}");
-  if (closeBraceIndex !== source.length - 1 || closeBraceIndex <= openBraceIndex) {
-    throw new Error(`Invalid module declaration '${value}'`);
-  }
-  const from = source.slice(0, openBraceIndex).trim();
-  if (from.length === 0) {
-    throw new Error(`Invalid module declaration '${value}'`);
-  }
-  const importsSlice = source.slice(openBraceIndex + 1, closeBraceIndex);
-  const imports = normalizeImports(importsSlice.split(","));
-  return {
-    from,
-    imports
-  };
-}
-function normalizeModuleDeclarations(modules) {
-  const declarations = modules ?? [];
-  const output = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const declaration of declarations) {
-    const normalized = parseModuleDeclaration(declaration);
-    const key = `${normalized.from}::${(normalized.imports ?? []).join(",")}`;
-    if (!seen.has(key)) {
-      seen.add(key);
-      output.push(normalized);
-    }
-  }
-  return output;
-}
-export {
-  normalizeModuleDeclarations,
-  parseModuleDeclaration
-};

package/src/errors/http-error.d.ts

@@ -1,31 +0,0 @@
-export interface HttpErrorDetails {
-    [key: string]: unknown;
-}
-export interface HttpErrorJson {
-    error: string;
-    status: number;
-    details?: HttpErrorDetails;
-}
-/**
- * HTTP error class for structured error handling in route handlers.
- * Provides static factory methods for common HTTP error responses.
- */
-export declare class HttpError extends Error {
-    readonly status: number;
-    readonly details?: HttpErrorDetails;
-    constructor(status: number, message: string, details?: HttpErrorDetails);
-    /**
-     * Serialize error to JSON for API responses.
-     */
-    toJSON(): HttpErrorJson;
-    /**
-     * Create a Response object from this error.
-     */
-    toResponse(): Response;
-    static BadRequest(message?: string, details?: HttpErrorDetails): HttpError;
-    static Unauthorized(message?: string): HttpError;
-    static Forbidden(message?: string): HttpError;
-    static NotFound(message?: string): HttpError;
-    static Conflict(message?: string, details?: HttpErrorDetails): HttpError;
-    static InternalServerError(message?: string): HttpError;
-}

package/src/errors/http-error.js

@@ -1,50 +0,0 @@
-class HttpError extends Error {
-  status;
-  details;
-  constructor(status, message, details) {
-    super(message);
-    this.name = "HttpError";
-    this.status = status;
-    this.details = details;
-  }
-  /**
-   * Serialize error to JSON for API responses.
-   */
-  toJSON() {
-    const json = {
-      error: this.message,
-      status: this.status
-    };
-    if (this.details) {
-      json.details = this.details;
-    }
-    return json;
-  }
-  /**
-   * Create a Response object from this error.
-   */
-  toResponse() {
-    return Response.json(this.toJSON(), { status: this.status });
-  }
-  static BadRequest(message = "Bad Request", details) {
-    return new HttpError(400, message, details);
-  }
-  static Unauthorized(message = "Unauthorized") {
-    return new HttpError(401, message);
-  }
-  static Forbidden(message = "Forbidden") {
-    return new HttpError(403, message);
-  }
-  static NotFound(message = "Not Found") {
-    return new HttpError(404, message);
-  }
-  static Conflict(message = "Conflict", details) {
-    return new HttpError(409, message, details);
-  }
-  static InternalServerError(message = "Internal Server Error") {
-    return new HttpError(500, message);
-  }
-}
-export {
-  HttpError
-};

package/src/errors/index.d.ts

@@ -1,2 +0,0 @@
-export { HttpError } from './http-error.js';
-export type { HttpErrorDetails, HttpErrorJson } from './http-error.js';

package/src/errors/index.js

@@ -1,4 +0,0 @@
-import { HttpError } from "./http-error.js";
-export {
-  HttpError
-};

package/src/errors/locals-access-error.d.ts

@@ -1,4 +0,0 @@
-export declare class LocalsAccessError extends Error {
-    name: string;
-    constructor(message: string);
-}

package/src/errors/locals-access-error.js

@@ -1,9 +0,0 @@
-class LocalsAccessError extends Error {
-  name = "LocalsAccessError";
-  constructor(message) {
-    super(message);
-  }
-}
-export {
-  LocalsAccessError
-};

package/src/global/app-logger.d.ts

@@ -1,2 +0,0 @@
-import { Logger } from '@ecopages/logger';
-export declare const appLogger: Logger;

package/src/global/app-logger.js

@@ -1,6 +0,0 @@
-import { Logger } from "@ecopages/logger";
-const debug = process.env.ECOPAGES_LOGGER_DEBUG === "true";
-const appLogger = new Logger("[@ecopages/core]", { debug });
-export {
-  appLogger
-};

package/src/hmr/client/hmr-runtime.d.ts

@@ -1,10 +0,0 @@
-/**
- * Ecopages HMR Runtime
- * Injected into the browser to handle Hot Module Replacement updates.
- */
-interface HMRPayload {
-    type: 'reload' | 'error' | 'update' | 'css-update' | 'layout-update';
-    path?: string;
-    message?: string;
-    timestamp?: number;
-}