npm - @ecopages/core - Versions diffs - 0.2.0-beta.2 → 0.2.0-beta.21 - Mend

@ecopages/core 0.2.0-beta.2 → 0.2.0-beta.21

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (273) hide show

package/src/client/navigation-scripts/navigation-scripts.test.browser.js ADDED Viewed

@@ -0,0 +1,65 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { isNonExecutableHeadScript } from "./classification.js";
+import {
+  collectRerunScripts,
+  createRerunScriptUrl,
+  flushPendingRerunScripts,
+  resetRerunNonceForTests
+} from "./rerun-queue.js";
+import { RERUN_SRC_ATTR } from "./registry.js";
+describe("isNonExecutableHeadScript", () => {
+  it("treats JSON-LD scripts as non-executable", () => {
+    const script = document.createElement("script");
+    script.type = "application/ld+json";
+    expect(isNonExecutableHeadScript(script)).toBe(true);
+  });
+  it("treats untyped scripts as executable", () => {
+    const script = document.createElement("script");
+    expect(isNonExecutableHeadScript(script)).toBe(false);
+  });
+});
+describe("collectRerunScripts and flushPendingRerunScripts", () => {
+  afterEach(() => {
+    document.head.replaceChildren();
+    document.body.replaceChildren();
+    resetRerunNonceForTests();
+  });
+  it("replays registered rerun callbacks without duplicating script tags", () => {
+    const callback = vi.fn();
+    window.__ECO_PAGES__ = {
+      rerunScripts: { "eco-test": callback }
+    };
+    try {
+      flushPendingRerunScripts([
+        {
+          parent: "head",
+          attributes: [
+            ["data-eco-rerun", ""],
+            ["data-eco-script-id", "eco-test"]
+          ],
+          textContent: "",
+          src: null,
+          scriptId: "eco-test"
+        }
+      ]);
+      expect(callback).toHaveBeenCalledOnce();
+      expect(document.head.querySelector('script[data-eco-script-id="eco-test"]')).toBeNull();
+    } finally {
+      delete window.__ECO_PAGES__;
+    }
+  });
+  it("cache-busts external module rerun scripts", () => {
+    const html = '<html><head><script data-eco-rerun src="/app.js" type="module"><\/script></head></html>';
+    const parsed = new DOMParser().parseFromString(html, "text/html");
+    const scripts = collectRerunScripts(parsed);
+    flushPendingRerunScripts(scripts);
+    const inserted = document.head.querySelector(`script[${RERUN_SRC_ATTR}]`);
+    expect(inserted?.getAttribute("src")).toMatch(/__eco_rerun=1/);
+    expect(inserted?.getAttribute(RERUN_SRC_ATTR)).toBe("/app.js");
+  });
+  it("appends a unique nonce on each module rerun url", () => {
+    const first = createRerunScriptUrl("/app.js");
+    const second = createRerunScriptUrl("/app.js");
+    expect(first).not.toBe(second);
+  });
+});

package/src/client/navigation-scripts/registry.d.ts ADDED Viewed

@@ -0,0 +1,11 @@
+/**
+ * `__ECO_PAGES__.rerunScripts` registry access for navigation reruns.
+ * @module
+ */
+export type RerunScriptCallback = () => void;
+/** Attribute storing the original module `src` after cache-busting. */
+export declare const RERUN_SRC_ATTR = "data-eco-rerun-src";
+/**
+ * Returns a registered in-memory rerun callback for the given script id.
+ */
+export declare function getRegisteredRerunScript(scriptId: string | null): RerunScriptCallback | null;

package/src/client/navigation-scripts/registry.js ADDED Viewed

@@ -0,0 +1,12 @@
+const RERUN_SRC_ATTR = "data-eco-rerun-src";
+function getRegisteredRerunScript(scriptId) {
+  if (!scriptId) {
+    return null;
+  }
+  const runtimeWindow = window;
+  return runtimeWindow.__ECO_PAGES__?.rerunScripts?.[scriptId] ?? null;
+}
+export {
+  RERUN_SRC_ATTR,
+  getRegisteredRerunScript
+};

package/src/client/navigation-scripts/rerun-queue.d.ts ADDED Viewed

@@ -0,0 +1,37 @@
+/**
+ * Queueing and replay of `data-eco-rerun` scripts after navigation.
+ * @module
+ */
+export type PendingRerunScript = {
+    parent: 'head' | 'body';
+    attributes: Array<[string, string]>;
+    textContent: string;
+    src: string | null;
+    scriptId: string | null;
+};
+/**
+ * Collects rerun scripts from an incoming document.
+ */
+export declare function collectRerunScripts(document: Document, filter?: (script: HTMLScriptElement) => boolean): PendingRerunScript[];
+/**
+ * Returns whether a rerun script is an external ES module that needs cache busting.
+ */
+export declare function isExternalModuleRerunScript(script: PendingRerunScript): boolean;
+/**
+ * Finds an existing rerun script in `root` by id or by src and inline content.
+ */
+export declare function findExistingRerunScript(root: ParentNode, script: PendingRerunScript): HTMLScriptElement | null;
+/**
+ * Appends a nonce query parameter so module scripts re-execute after navigation.
+ */
+export declare function createRerunScriptUrl(src: string): string;
+/**
+ * Replays queued rerun scripts after the incoming page body is in place.
+ *
+ * @remarks
+ * Flushed elements keep `data-eco-rerun` so head cleanup does not treat them
+ * as persistable inline scripts on the next navigation.
+ */
+export declare function flushPendingRerunScripts(scripts: readonly PendingRerunScript[]): void;
+/** @remarks Test-only reset for nonce sequencing. */
+export declare function resetRerunNonceForTests(): void;

package/src/client/navigation-scripts/rerun-queue.js ADDED Viewed

@@ -0,0 +1,73 @@
+import { RERUN_SRC_ATTR, getRegisteredRerunScript } from "./registry.js";
+let rerunNonce = 0;
+function collectRerunScripts(document2, filter) {
+  return Array.from(document2.querySelectorAll("script[data-eco-rerun]")).filter((script) => filter ? filter(script) : true).map((script) => ({
+    parent: script.closest("body") ? "body" : "head",
+    attributes: Array.from(script.attributes).map((attribute) => [attribute.name, attribute.value]),
+    textContent: script.textContent ?? "",
+    src: script.getAttribute("src"),
+    scriptId: script.getAttribute("data-eco-script-id")
+  }));
+}
+function isExternalModuleRerunScript(script) {
+  if (!script.src) {
+    return false;
+  }
+  return script.attributes.some(([name, value]) => name === "type" && value === "module");
+}
+function findExistingRerunScript(root, script) {
+  const scripts = Array.from(root.querySelectorAll("script"));
+  if (script.scriptId) {
+    return scripts.find((candidate) => candidate.getAttribute("data-eco-script-id") === script.scriptId) ?? null;
+  }
+  return scripts.find(
+    (candidate) => (candidate.getAttribute(RERUN_SRC_ATTR) ?? candidate.getAttribute("src")) === script.src && (candidate.textContent ?? "") === script.textContent
+  ) ?? null;
+}
+function createRerunScriptUrl(src) {
+  const url = new URL(src, document.baseURI);
+  url.searchParams.set("__eco_rerun", String(++rerunNonce));
+  return url.toString();
+}
+function flushPendingRerunScripts(scripts) {
+  for (const script of scripts) {
+    const targetParent = script.parent === "body" ? document.body : document.head;
+    const registeredRerun = getRegisteredRerunScript(script.scriptId);
+    const replacement = document.createElement("script");
+    const shouldBustModuleSrc = isExternalModuleRerunScript(script) && !registeredRerun;
+    for (const [name, value] of script.attributes) {
+      if (name === "src" && shouldBustModuleSrc) {
+        replacement.setAttribute(RERUN_SRC_ATTR, value);
+        replacement.setAttribute("src", createRerunScriptUrl(value));
+        continue;
+      }
+      replacement.setAttribute(name, value);
+    }
+    replacement.textContent = script.textContent;
+    const existingScript = findExistingRerunScript(targetParent, script);
+    if (registeredRerun) {
+      const needsScriptElement = isExternalModuleRerunScript(script);
+      if (!existingScript && needsScriptElement) {
+        targetParent.appendChild(replacement);
+      }
+      registeredRerun();
+      continue;
+    }
+    if (existingScript) {
+      existingScript.replaceWith(replacement);
+      continue;
+    }
+    targetParent.appendChild(replacement);
+  }
+}
+function resetRerunNonceForTests() {
+  rerunNonce = 0;
+}
+export {
+  collectRerunScripts,
+  createRerunScriptUrl,
+  findExistingRerunScript,
+  flushPendingRerunScripts,
+  isExternalModuleRerunScript,
+  resetRerunNonceForTests
+};

package/src/client/scroll.d.ts ADDED Viewed

@@ -0,0 +1,17 @@
+/**
+ * Window scroll behavior during client-side navigations.
+ * @module
+ */
+export type WindowScrollBehavior = 'top' | 'preserve' | 'auto';
+export type ManageWindowScrollOptions = {
+    scrollBehavior: WindowScrollBehavior;
+    smoothScroll: boolean;
+};
+/**
+ * Updates window scroll position after a navigation commit.
+ *
+ * @remarks
+ * Hash navigations always scroll to the target element and ignore `scrollBehavior`.
+ * Fragment targets are resolved by element id (`#section` → `getElementById('section')`).
+ */
+export declare function manageWindowScroll(newUrl: URL, previousUrl: URL, options: ManageWindowScrollOptions): void;

package/src/client/scroll.js ADDED Viewed

@@ -0,0 +1,25 @@
+function manageWindowScroll(newUrl, previousUrl, options) {
+  const { scrollBehavior, smoothScroll } = options;
+  if (newUrl.hash) {
+    const target = document.getElementById(newUrl.hash.slice(1));
+    target?.scrollIntoView({ behavior: smoothScroll ? "smooth" : "instant" });
+    return;
+  }
+  const behavior = smoothScroll ? "smooth" : "instant";
+  switch (scrollBehavior) {
+    case "preserve":
+      break;
+    case "auto":
+      if (newUrl.pathname !== previousUrl.pathname) {
+        window.scrollTo({ top: 0, left: 0, behavior });
+      }
+      break;
+    case "top":
+    default:
+      window.scrollTo({ top: 0, left: 0, behavior });
+      break;
+  }
+}
+export {
+  manageWindowScroll
+};

package/src/client/scroll.test.browser.js ADDED Viewed

@@ -0,0 +1,37 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { manageWindowScroll } from "./scroll.js";
+const options = { scrollBehavior: "top", smoothScroll: false };
+describe("manageWindowScroll", () => {
+  afterEach(() => {
+    history.replaceState({}, "", "/");
+    document.body.replaceChildren();
+    vi.restoreAllMocks();
+  });
+  it("scrolls to top by default", () => {
+    const scrollTo = vi.spyOn(window, "scrollTo").mockImplementation(() => {
+    });
+    manageWindowScroll(new URL("/next", window.location.origin), new URL("/prev", window.location.origin), options);
+    expect(scrollTo).toHaveBeenCalledWith({ top: 0, left: 0, behavior: "instant" });
+  });
+  it("preserves scroll when scrollBehavior is preserve", () => {
+    const scrollTo = vi.spyOn(window, "scrollTo").mockImplementation(() => {
+    });
+    manageWindowScroll(new URL("/next", window.location.origin), new URL("/prev", window.location.origin), {
+      ...options,
+      scrollBehavior: "preserve"
+    });
+    expect(scrollTo).not.toHaveBeenCalled();
+  });
+  it("scrolls to hash target by element id", () => {
+    const section = document.createElement("section");
+    section.id = "section";
+    section.scrollIntoView = vi.fn();
+    document.body.append(section);
+    manageWindowScroll(
+      new URL("/page#section", window.location.origin),
+      new URL("/page", window.location.origin),
+      options
+    );
+    expect(section.scrollIntoView).toHaveBeenCalledWith({ behavior: "instant" });
+  });
+});

package/src/client/view-transitions.d.ts ADDED Viewed

@@ -0,0 +1,16 @@
+/**
+ * View Transition API helpers for `data-view-transition` markup.
+ * @module
+ */
+/**
+ * Assigns `view-transition-name` from `data-view-transition` and injects morph styles.
+ *
+ * @remarks
+ * Elements without `data-view-transition-animate="fade"` get a geometric morph:
+ * the old snapshot is hidden so cross-fade ghosting does not appear.
+ */
+export declare function applyViewTransitionNames(): void;
+/**
+ * Clears inline transition names and dynamic morph styles after a transition ends.
+ */
+export declare function clearViewTransitionNames(): void;

package/src/client/view-transitions.js ADDED Viewed

@@ -0,0 +1,63 @@
+const VIEW_TRANSITION_ATTR = "data-view-transition";
+const VIEW_TRANSITION_ANIMATE_ATTR = "data-view-transition-animate";
+const VIEW_TRANSITION_DURATION_ATTR = "data-view-transition-duration";
+const DYNAMIC_STYLES_ID = "eco-vt-dynamic-styles";
+function applyViewTransitionNames() {
+  const elements = document.querySelectorAll(`[${VIEW_TRANSITION_ATTR}]`);
+  const morphNames = [];
+  const customDurations = [];
+  elements.forEach((el) => {
+    const name = el.getAttribute(VIEW_TRANSITION_ATTR);
+    if (!name) {
+      return;
+    }
+    el.style.viewTransitionName = name;
+    const animate = el.getAttribute(VIEW_TRANSITION_ANIMATE_ATTR);
+    if (animate !== "fade") {
+      morphNames.push(name);
+    }
+    const duration = el.getAttribute(VIEW_TRANSITION_DURATION_ATTR);
+    if (duration) {
+      customDurations.push({ name, duration });
+    }
+  });
+  if (morphNames.length > 0 || customDurations.length > 0) {
+    injectDynamicStyles(morphNames, customDurations);
+  }
+}
+function clearViewTransitionNames() {
+  const elements = document.querySelectorAll(`[${VIEW_TRANSITION_ATTR}]`);
+  elements.forEach((el) => {
+    el.style.viewTransitionName = "";
+  });
+  const styleEl = document.getElementById(DYNAMIC_STYLES_ID);
+  if (styleEl) {
+    styleEl.textContent = "";
+  }
+}
+function injectDynamicStyles(morphNames, customDurations) {
+  let styleEl = document.getElementById(DYNAMIC_STYLES_ID);
+  if (!styleEl) {
+    styleEl = document.createElement("style");
+    styleEl.id = DYNAMIC_STYLES_ID;
+    styleEl.setAttribute("data-eco-persist", "");
+    document.head.append(styleEl);
+  }
+  const morphCss = morphNames.map(
+    (name) => `
+		::view-transition-old(${name}) { display: none !important; }
+		::view-transition-new(${name}) { animation: none !important; opacity: 1 !important; }
+	`
+  ).join("\n");
+  const durationCss = customDurations.map(
+    ({ name, duration }) => `
+		::view-transition-group(${name}) { animation-duration: ${duration} !important; }
+	`
+  ).join("\n");
+  styleEl.textContent = `${morphCss}
+${durationCss}`;
+}
+export {
+  applyViewTransitionNames,
+  clearViewTransitionNames
+};

package/src/config/config-builder.d.ts CHANGED Viewed

@@ -70,12 +70,7 @@ export declare class ConfigBuilder {
      *
      * - `'rolldown'` (default): Ecopages runs builds through
      *   {@link RolldownBuildAdapter}, creating a new `rolldown()` instance
-     *   per build. Best for one-shot production builds and benchmarks.
-     * - `'rolldown-dev'`: Ecopages runs builds through
-     *   {@link RolldownDevBuildAdapter}, which wraps Rolldown's experimental
-     *   `DevEngine` and reuses the cached module graph, resolver, and
-     *   transform cache across rebuilds. Best for HMR and watch mode where
-     *   the same entrypoints are rebuilt repeatedly.
+     *   per build.
      * - `'vite-host'`: a host runtime owns the build. Ecopages exposes a
      *   {@link ViteHostBuildAdapter} boundary marker that throws on direct
      *   use. Select this only for host-driven compatibility flows where
@@ -250,7 +245,17 @@ export declare class ConfigBuilder {
     private compareVersions;
     /**
      * Initializes default loaders that are required for EcoPages to function.
-     * This includes the eco-component-meta-plugin which auto-injects __eco metadata into component configs.
+     *
+     * @remarks
+     * `eco-component-meta` is registered twice on purpose:
+     *
+     * - `sourceTransforms` is the canonical browser/HMR path. The Rolldown bridge
+     *   runs these after first-wins `onLoad` plugins rewrite module source.
+     * - `loaders` keeps the same transform available to server-oriented builds
+     *   that still use competing `onLoad` handlers directly.
+     *
+     * Browser builds exclude the loader copy in {@link getAppBrowserBuildPlugins}
+     * when the transform name is already present in `sourceTransforms`.
      */
     private initializeDefaultLoaders;
     private reviewBaseUrl;

package/src/config/config-builder.js CHANGED Viewed

@@ -9,7 +9,6 @@ import {
   collectConfiguredAppBuildManifestContributions,
   createBuildAdapter,
   setAppBuildAdapter,
-  setAppBuildExecutor,
   updateAppBuildManifest
 } from "../build/build-adapter.js";
 import { GHTML_PLUGIN_NAME } from "../integrations/ghtml/ghtml.constants.js";
@@ -112,12 +111,7 @@ class ConfigBuilder {
    *
    * - `'rolldown'` (default): Ecopages runs builds through
    *   {@link RolldownBuildAdapter}, creating a new `rolldown()` instance
-   *   per build. Best for one-shot production builds and benchmarks.
-   * - `'rolldown-dev'`: Ecopages runs builds through
-   *   {@link RolldownDevBuildAdapter}, which wraps Rolldown's experimental
-   *   `DevEngine` and reuses the cached module graph, resolver, and
-   *   transform cache across rebuilds. Best for HMR and watch mode where
-   *   the same entrypoints are rebuilt repeatedly.
+   *   per build.
    * - `'vite-host'`: a host runtime owns the build. Ecopages exposes a
    *   {@link ViteHostBuildAdapter} boundary marker that throws on direct
    *   use. Select this only for host-driven compatibility flows where
@@ -547,7 +541,17 @@ class ConfigBuilder {
   }
   /**
    * Initializes default loaders that are required for EcoPages to function.
-   * This includes the eco-component-meta-plugin which auto-injects __eco metadata into component configs.
+   *
+   * @remarks
+   * `eco-component-meta` is registered twice on purpose:
+   *
+   * - `sourceTransforms` is the canonical browser/HMR path. The Rolldown bridge
+   *   runs these after first-wins `onLoad` plugins rewrite module source.
+   * - `loaders` keeps the same transform available to server-oriented builds
+   *   that still use competing `onLoad` handlers directly.
+   *
+   * Browser builds exclude the loader copy in {@link getAppBrowserBuildPlugins}
+   * when the transform name is already present in `sourceTransforms`.
    */
   async initializeDefaultLoaders() {
     const componentMetaTransform = createEcoComponentMetaTransform({ config: this.config });
@@ -593,7 +597,6 @@ class ConfigBuilder {
     updateAppBuildManifest(this.config, await collectConfiguredAppBuildManifestContributions(this.config));
     setAppServerInvalidationState(this.config, new CounterServerInvalidationState());
     setAppEntrypointDependencyGraph(this.config, new NoopEntrypointDependencyGraph());
-    setAppBuildExecutor(this.config, buildAdapter);
     return this.config;
   }
 }

package/src/dev/client-bridge-registry.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+import type { EcoPagesAppConfig } from '../types/public-types.js';
+import type { IClientBridge } from '../types/public-types.js';
+export declare function setAppDevClientBridge(appConfig: EcoPagesAppConfig, bridge: IClientBridge): void;
+export declare function getAppDevClientBridge(appConfig: EcoPagesAppConfig): IClientBridge | undefined;
+export declare function clearAppDevClientBridge(appConfig: EcoPagesAppConfig): void;

package/src/dev/client-bridge-registry.js ADDED Viewed

@@ -0,0 +1,15 @@
+const appDevClientBridges = /* @__PURE__ */ new WeakMap();
+function setAppDevClientBridge(appConfig, bridge) {
+  appDevClientBridges.set(appConfig, bridge);
+}
+function getAppDevClientBridge(appConfig) {
+  return appDevClientBridges.get(appConfig);
+}
+function clearAppDevClientBridge(appConfig) {
+  appDevClientBridges.delete(appConfig);
+}
+export {
+  clearAppDevClientBridge,
+  getAppDevClientBridge,
+  setAppDevClientBridge
+};

package/src/dev/dev-client-ownership.d.ts ADDED Viewed

@@ -0,0 +1,7 @@
+import type { ApplicationRuntimeOptions } from '../adapters/abstract/application-adapter.js';
+/**
+ * Returns whether the host dev server owns all browser dev-client bootstrap.
+ *
+ * When true, core must not inject the HMR runtime or signal full-page reloads.
+ */
+export declare function hostOwnsDevClient(runtime?: ApplicationRuntimeOptions): boolean;

package/src/dev/dev-client-ownership.js ADDED Viewed

@@ -0,0 +1,6 @@
+function hostOwnsDevClient(runtime) {
+  return runtime?.devClientOwner === "host" || runtime?.delegateBrowserReloadToHost === true;
+}
+export {
+  hostOwnsDevClient
+};

package/src/dev/hmr-manager-registry.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+/**
+ * Per-app registry for the shared HMR manager used by host-owned dev clients.
+ */
+import type { EcoPagesAppConfig } from '../types/public-types.js';
+import type { IHmrManager } from '../types/public-types.js';
+export declare function setAppHmrManager(appConfig: EcoPagesAppConfig, hmrManager: IHmrManager): void;
+export declare function getAppHmrManager(appConfig: EcoPagesAppConfig): IHmrManager | undefined;
+export declare function clearAppHmrManager(appConfig: EcoPagesAppConfig): void;

package/src/dev/hmr-manager-registry.js ADDED Viewed

@@ -0,0 +1,15 @@
+const appHmrManagers = /* @__PURE__ */ new WeakMap();
+function setAppHmrManager(appConfig, hmrManager) {
+  appHmrManagers.set(appConfig, hmrManager);
+}
+function getAppHmrManager(appConfig) {
+  return appHmrManagers.get(appConfig);
+}
+function clearAppHmrManager(appConfig) {
+  appHmrManagers.delete(appConfig);
+}
+export {
+  clearAppHmrManager,
+  getAppHmrManager,
+  setAppHmrManager
+};

package/src/dev/host-runtime.d.ts CHANGED Viewed

@@ -1,10 +1,13 @@
 import type { EcoPagesAppConfig } from '../types/public-types.js';
 import { type DevelopmentInvalidationPlan } from '../services/invalidation/development-invalidation.service.js';
+import type { ClientBridgeEvent } from '../types/public-types.js';
 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;
+    broadcastClientEvent(event: ClientBridgeEvent): void;
+    isServerRenderedTemplatePlan(plan: DevelopmentInvalidationPlan): boolean;
 }
 export declare function createDevelopmentHostRuntime(appConfig: EcoPagesAppConfig): DevelopmentHostRuntime;

package/src/dev/host-runtime.js CHANGED Viewed

@@ -1,6 +1,7 @@
 import {
   DevelopmentInvalidationService
 } from "../services/invalidation/development-invalidation.service.js";
+import { getAppDevClientBridge } from "./client-bridge-registry.js";
 import { setHostModuleLoader } from "../services/module-loading/host-module-loader-registry.js";
 function createDevelopmentHostRuntime(appConfig) {
   const invalidationService = new DevelopmentInvalidationService(appConfig);
@@ -16,6 +17,12 @@ function createDevelopmentHostRuntime(appConfig) {
     },
     resetRuntimeState(changedFiles) {
       invalidationService.resetRuntimeState(changedFiles);
+    },
+    broadcastClientEvent(event) {
+      getAppDevClientBridge(appConfig)?.broadcast(event);
+    },
+    isServerRenderedTemplatePlan(plan) {
+      return plan.category === "include-source" || plan.category === "explicit-server-view";
     }
   };
 }

package/src/dev/runtime-server-started-message.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export type EcopagesRuntimeLabel = 'Bun' \| 'Node';
2	+ export declare function formatRuntimeServerStartedMessage(runtime: EcopagesRuntimeLabel, origin: string): string;

package/src/dev/runtime-server-started-message.js ADDED Viewed

@@ -0,0 +1,6 @@
+function formatRuntimeServerStartedMessage(runtime, origin) {
+  return `${runtime} server running at ${origin.replace(/\/$/, "")}`;
+}
+export {
+  formatRuntimeServerStartedMessage
+};

package/src/eco/README.md CHANGED Viewed

@@ -279,6 +279,17 @@ export default eco.page({
 });
 ```
+**Nested layouts (outer → inner):**
+```tsx
+export default eco.page({
+	layout: [MarketingShell, DocsShell],
+	render: () => <h1>Hello</h1>,
+});
+```
+A single layout remains equivalent to a one-element array. Normalization stores the stack on `config.layouts` and `config.layoutEntries` at factory time.
 ### `eco.component()`
 Define a reusable component with dependencies.

package/src/eco/eco-declared-component.d.ts ADDED Viewed

@@ -0,0 +1,14 @@
+import type { EcoDeclaredComponent } from '../types/public-types.js';
+export { getUndeclaredComponentDependencyMessage } from '../errors/undeclared-component-dependency-error.js';
+/**
+ * @remarks
+ * Declared components are produced by `eco.component()`, `eco.layout()`, and
+ * `eco.html()` after the component-meta plugin injects `config.__eco`.
+ */
+export declare function isEcoDeclaredComponent(component: unknown): component is EcoDeclaredComponent;
+/**
+ * @throws {UndeclaredComponentDependencyError} When the value lacks `config.__eco`.
+ */
+export declare function assertEcoDeclaredComponent(component: unknown, context?: {
+    parentComponentFile?: string;
+}): asserts component is EcoDeclaredComponent;

package/src/eco/eco-declared-component.js ADDED Viewed

@@ -0,0 +1,16 @@
+import { UndeclaredComponentDependencyError } from "../errors/undeclared-component-dependency-error.js";
+import { getUndeclaredComponentDependencyMessage } from "../errors/undeclared-component-dependency-error.js";
+function isEcoDeclaredComponent(component) {
+  return typeof component === "function" && typeof component.config?.__eco?.file === "string" && typeof component.config?.__eco?.integration === "string";
+}
+function assertEcoDeclaredComponent(component, context = {}) {
+  if (isEcoDeclaredComponent(component)) {
+    return;
+  }
+  throw new UndeclaredComponentDependencyError(context.parentComponentFile);
+}
+export {
+  assertEcoDeclaredComponent,
+  getUndeclaredComponentDependencyMessage,
+  isEcoDeclaredComponent
+};

package/src/eco/eco.browser.js CHANGED Viewed

@@ -1,3 +1,4 @@
+import { applyPageLayoutConfig, mergeLayoutDependencies, normalizePageLayouts } from "./page-layout-normalization.js";
 function createComponentFactory(options) {
   const component2 = ((props) => options.render(props));
   component2.config = {
@@ -32,17 +33,15 @@ function page(options) {
     requires,
     middleware
   } = options;
+  const layoutEntries = normalizePageLayouts(pageLayout);
   const pageComponent = createComponentFactory({
     __eco: options.__eco,
     integration: options.integration,
-    dependencies: pageLayout ? {
-      ...dependencies,
-      components: [...dependencies?.components ?? [], pageLayout]
-    } : dependencies,
+    dependencies: mergeLayoutDependencies(dependencies, layoutEntries),
     render
   });
-  if (pageLayout && pageComponent.config) {
-    pageComponent.config.layout = pageLayout;
+  if (pageComponent.config) {
+    applyPageLayoutConfig(pageComponent.config, layoutEntries);
   }
   if (staticPaths2) {
     pageComponent.staticPaths = staticPaths2;