@llui/vike 0.4.10 → 0.5.1

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { onRenderHtml, createOnRenderHtml } from './on-render-html.js';
-export type { PageContext, DocumentContext, RenderHtmlResult, RenderHtmlOptions, } from './on-render-html.js';
-export { onRenderClient, createOnRenderClient, fromTransition } from './on-render-client.js';
-export type { ClientPageContext, RenderClientOptions } from './on-render-client.js';
+export type { PageContext, DocumentContext, RenderHtmlResult, RenderHtmlOptions, AnyLayer, } from './on-render-html.js';
+export { onRenderClient, createOnRenderClient, fromTransition, getLayoutChain, } from './on-render-client.js';
+export type { ClientPageContext, RenderClientOptions, LayerHandle } from './on-render-client.js';
 export { pageSlot } from './page-slot.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AACtE,YAAY,EACV,WAAW,EACX,eAAe,EACf,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,qBAAqB,CAAA;AAE5B,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAC5F,YAAY,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAEnF,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AACtE,YAAY,EACV,WAAW,EACX,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,QAAQ,GACT,MAAM,qBAAqB,CAAA;AAE5B,OAAO,EACL,cAAc,EACd,oBAAoB,EACpB,cAAc,EACd,cAAc,GACf,MAAM,uBAAuB,CAAA;AAC9B,YAAY,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAEhG,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA"}

package/dist/index.js

@@ -1,4 +1,4 @@
 export { onRenderHtml, createOnRenderHtml } from './on-render-html.js';
-export { onRenderClient, createOnRenderClient, fromTransition } from './on-render-client.js';
+export { onRenderClient, createOnRenderClient, fromTransition, getLayoutChain, } from './on-render-client.js';
 export { pageSlot } from './page-slot.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AAQtE,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAG5F,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA","sourcesContent":["export { onRenderHtml, createOnRenderHtml } from './on-render-html.js'\nexport type {\n  PageContext,\n  DocumentContext,\n  RenderHtmlResult,\n  RenderHtmlOptions,\n} from './on-render-html.js'\n\nexport { onRenderClient, createOnRenderClient, fromTransition } from './on-render-client.js'\nexport type { ClientPageContext, RenderClientOptions } from './on-render-client.js'\n\nexport { pageSlot } from './page-slot.js'\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AAStE,OAAO,EACL,cAAc,EACd,oBAAoB,EACpB,cAAc,EACd,cAAc,GACf,MAAM,uBAAuB,CAAA;AAG9B,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA","sourcesContent":["export { onRenderHtml, createOnRenderHtml } from './on-render-html.js'\nexport type {\n  PageContext,\n  DocumentContext,\n  RenderHtmlResult,\n  RenderHtmlOptions,\n  AnyLayer,\n} from './on-render-html.js'\n\nexport {\n  onRenderClient,\n  createOnRenderClient,\n  fromTransition,\n  getLayoutChain,\n} from './on-render-client.js'\nexport type { ClientPageContext, RenderClientOptions, LayerHandle } from './on-render-client.js'\n\nexport { pageSlot } from './page-slot.js'\n"]}

package/dist/on-render-client.d.ts

@@ -1,6 +1,20 @@
-import type { AnyComponentDef, AppHandle, TransitionOptions, Lifetime } from '@llui/dom';
+import type { SignalComponentHandle } from '@llui/dom';
+import type { TransitionOptions } from '@llui/dom';
 import type { VikePageContextData } from './vike-namespace.js';
 export { pageSlot } from './page-slot.js';
+/** A type-erased signal component as the adapter handles it (type params unused
+ * at runtime). Method syntax + a single `unknown` view-bag param so any concrete
+ * `SignalComponentDef<S,M,E>` assigns in (see on-render-html's AnyLayer note —
+ * ComponentBag's state/send variance rules out the `<unknown,…>` erasure). */
+export interface AnyLayer {
+    readonly name?: string;
+    init(): unknown;
+    update(state: unknown, msg: unknown): unknown;
+    view(bag: unknown): readonly Node[];
+    onEffect?(effect: unknown, api: unknown): void | (() => void);
+}
+/** The live handle a mounted/hydrated layer exposes (send/getState/subscribe). */
+export type LayerHandle = SignalComponentHandle<unknown, unknown>;
 declare global {
     interface Window {
         __LLUI_STATE__?: unknown;
@@ -12,59 +26,31 @@ declare global {
  * Vike resolved for the current route.
  *
  * `data` is derived from the global `Vike.PageContext` namespace — the
- * convention users already know from Vike. Consumer augmentations of
- * `Vike.PageContext { interface PageContext { data?: MyData } }` flow
- * through to every callback here without a cast. Unaugmented projects
+ * convention users already know from Vike. Consumer augmentations flow
+ * through to every callback here without a cast; unaugmented projects
  * fall back to `unknown`.
  *
+ * In the signal runtime a component's `init()` takes no data argument, so
+ * each layer's `data` slice is used directly as that layer's seed STATE
+ * when present; when absent, the layer's own `init()` provides the seed.
+ *
  * `lluiLayoutData` is optional and carries per-layer data for the layout
  * chain configured via `createOnRenderClient({ Layout })`. It's indexed
- * outermost-to-innermost, one entry per layout layer. Absent entries
- * mean the corresponding layout's `init()` receives `undefined`. Users
- * wire this from their Vike `+data.ts` files by merging layout-owned
- * data under the `lluiLayoutData` key.
+ * outermost-to-innermost, one entry per layout layer.
  */
 export interface ClientPageContext {
-    Page: AnyComponentDef;
+    Page: AnyLayer;
     data?: VikePageContextData;
     lluiLayoutData?: readonly unknown[];
     isHydration?: boolean;
 }
-type LayoutChain = ReadonlyArray<AnyComponentDef>;
+type LayoutChain = ReadonlyArray<AnyLayer>;
 /**
  * Page-lifecycle hooks that fire around the dispose → mount cycle on
  * client navigation. With persistent layouts in play the cycle only
  * tears down the *divergent* suffix of the layout chain — any layers
  * shared between the old and new routes stay mounted.
  *
- * Navigation sequence for an already-mounted app:
- *
- * ```
- *   client nav triggered
- *     │
- *     ▼
- *   compare old chain to new chain → find first mismatch index K
- *     │
- *     ▼
- *   onLeave(leaveTarget)   ← awaited; leaveTarget is the slot element
- *     │                      at depth K-1 (or the root container if K=0)
- *     │                      whose contents are about to be replaced
- *     ▼
- *   dispose chainHandles[K..end] innermost first
- *     │
- *     ▼
- *   leaveTarget.textContent = ''
- *     │
- *     ▼
- *   mount newChain[K..end] into leaveTarget, outermost first
- *     │
- *     ▼
- *   onEnter(leaveTarget)   ← fire-and-forget; fresh DOM in place
- *     │
- *     ▼
- *   onMount()
- * ```
- *
  * On the initial hydration render, `onLeave` and `onEnter` are NOT
  * called — there's no outgoing page to leave and no animation to enter.
  * Use `onMount` for code that should run on every render including the
@@ -76,26 +62,21 @@ export interface RenderClientOptions {
     /**
      * Persistent layout chain. One of:
      *
-     * - A single `ComponentDef` — becomes a one-layout chain.
-     * - An array of `ComponentDef`s — outermost layout first, innermost
-     *   layout last. Every layer except the innermost must call
+     * - A single `SignalComponentDef` — becomes a one-layout chain.
+     * - An array of `SignalComponentDef`s — outermost layout first,
+     *   innermost layout last. Every layer except the innermost must call
      *   `pageSlot()` in its view to declare where nested content renders.
-     * - A function that returns a chain from the current `pageContext` —
-     *   lets different routes use different chains, e.g. by reading
-     *   Vike's `pageContext.urlPathname` or `pageContext.config.Layout`.
+     * - A function that returns a chain from the current `pageContext`.
      *
-     * Layers that are shared between the previous and next navigation
-     * stay mounted. Only the divergent suffix is disposed and re-mounted.
-     * Dialogs, focus traps, and effect subscriptions rooted in a surviving
-     * layer are unaffected by the nav.
+     * Layers shared between the previous and next navigation stay mounted.
+     * Only the divergent suffix is disposed and re-mounted.
      */
-    Layout?: AnyComponentDef | LayoutChain | ((pageContext: ClientPageContext) => LayoutChain);
+    Layout?: AnyLayer | LayoutChain | ((pageContext: ClientPageContext) => LayoutChain);
     /**
      * Called on the slot element whose contents are about to be replaced,
      * BEFORE the divergent suffix is disposed and re-mounted. The slot's
-     * current DOM is still attached when this runs — the only moment a
-     * leave animation can read/write it. Return a promise to defer the
-     * swap until the animation completes.
+     * current DOM is still attached when this runs. Return a promise to
+     * defer the swap until the animation completes.
      *
      * For a plain no-layout setup, the slot element is the root container.
      * Not called on the initial hydration render.
@@ -103,105 +84,47 @@ export interface RenderClientOptions {
     onLeave?: (el: HTMLElement) => void | Promise<void>;
     /**
      * Called after the new divergent suffix is mounted, on the same slot
-     * element that was passed to `onLeave`. Use this to kick off an enter
-     * animation. Fire-and-forget — promise returns are ignored.
-     *
-     * Not called on the initial hydration render.
+     * element that was passed to `onLeave`. Fire-and-forget. Not called on
+     * the initial hydration render.
      */
     onEnter?: (el: HTMLElement) => void;
     /**
      * Called after mount or hydration completes. Fires on every render
-     * including the initial hydration. Use for per-render side effects
-     * that don't fit the animation hooks.
-     *
-     * Receives the live layout chain — `[...layouts, page]`, outermost
-     * first — as `AppHandle`s. Consumers wiring observability bridges,
-     * the LAP agent client, custom devtools, or any tool that needs
-     * `getState` / `send` / `subscribe` for the *outermost layout*
-     * (which `window.__lluiComponents` did not reliably expose for
-     * hydrated apps until @llui/dom@0.0.31) can read it from here:
-     *
-     * ```ts
-     * createOnRenderClient({
-     *   Layout: AppLayout,
-     *   onMount: (chain) => {
-     *     const layout = chain[0]    // outermost layout
-     *     const page = chain.at(-1)  // current page
-     *   },
-     * })
-     * ```
-     *
-     * The array is a snapshot at call time; consumers should not retain
-     * references to handles past the next navigation, since surviving
-     * layers stay live but disposed layers do not.
+     * including the initial hydration. Receives the live layout chain —
+     * `[...layouts, page]`, outermost first — as `LayerHandle`s.
      */
-    onMount?: (chain: readonly AppHandle[]) => void;
+    onMount?: (chain: readonly LayerHandle[]) => void;
     /**
      * Called for each surviving layout layer whose `lluiLayoutData[i]`
-     * slice changed across a client navigation. Surviving layers are
-     * layers shared between the previous and current chain — they stay
-     * mounted, but their state needs a fresh injection of nav-driven
-     * data (pathname, breadcrumbs, session, …).
-     *
-     * The framework gives you the layer's `AppHandle` and the changed
-     * data; you decide how to translate it into a state-update message
-     * and dispatch it through `handle.send(msg)`. Typically:
-     *
-     * ```ts
-     * createOnRenderClient({
-     *   Layout: NavAwareLayout,
-     *   onLayerDataChange: ({ def, handle, newData }) => {
-     *     if (def === NavAwareLayout) {
-     *       handle.send({ type: 'navChanged', data: newData as NavData })
-     *     }
-     *   },
-     * })
-     * ```
-     *
-     * Not called for layers whose data slice is unchanged (shallow-key
-     * `Object.is` diff on records, whole-value `Object.is` for
-     * primitives). Not called on the initial hydration render — `init`
-     * handles the initial data injection there. Not called for the
-     * page layer (the innermost entry); the page always disposes and
-     * remounts, so its `init(data)` receives the fresh data directly.
+     * slice changed across a client navigation. Surviving layers stay
+     * mounted but need a fresh injection of nav-driven data. You decide how
+     * to translate the new data into a message and dispatch it through
+     * `handle.send(msg)`.
      *
-     * If omitted, surviving layers retain their existing state across
-     * navigations. Opt in only when the layout needs to react to
-     * nav-scoped data changes.
+     * Not called for unchanged slices, not on the initial hydration render,
+     * and not for the page layer (it always disposes and remounts, so its
+     * `init`/seed receives the fresh data directly).
      */
     onLayerDataChange?: (ctx: {
-        def: AnyComponentDef;
-        handle: AppHandle;
+        def: AnyLayer;
+        handle: LayerHandle;
         newData: unknown;
         prevData: unknown;
     }) => void;
     /**
-     * Forwarded to `@llui/dom`'s `hydrateApp` / `hydrateAtAnchor` for
-     * every layer in the layout chain on initial hydration. When `true`,
-     * effects returned by each component's `init()` are dispatched
-     * post-swap on the client. When `false` (default), they are skipped
-     * — the SSR pass already ran them on the server, and re-running on
-     * the client typically produces duplicate fetches / subscriptions.
+     * Forwarded to the signal hydrate path for every layer on initial
+     * hydration. When `true`, effects returned by each component's `init()`
+     * are dispatched post-swap on the client. When `false` (default), they
+     * are skipped — the SSR pass already ran them.
      *
-     * Opt in only when:
-     *   - `init()` returns no effects, OR
-     *   - all returned effects are idempotent / client-only (e.g. attaching
-     *     a `window` listener), AND
-     *   - the SSR path didn't run them (typically because `init()` checks
-     *     a `loaded` flag in state and returns `[]` when serverState
-     *     already has the data loaded).
-     *
-     * Subsequent client-side navigation always uses `mountApp` /
-     * `mountAtAnchor` (fresh mount), which always fires init effects
-     * regardless of this flag.
+     * Subsequent client-side navigation always uses a fresh mount, which
+     * always fires init effects regardless of this flag.
      */
     runInitEffectsOnHydrate?: boolean;
 }
 /**
- * Adapt a `TransitionOptions` object (e.g. the output of
- * `routeTransition()` from `@llui/transitions`, or a preset like `fade`
- * / `slide`) into the `onLeave` / `onEnter` pair expected by
- * `createOnRenderClient`.
+ * Adapt a `TransitionOptions` object into the `onLeave` / `onEnter` pair
+ * expected by `createOnRenderClient`.
  *
  * ```ts
  * import { createOnRenderClient, fromTransition } from '@llui/vike/client'
@@ -214,15 +137,13 @@ export interface RenderClientOptions {
  * ```
  *
  * The transition operates on the slot element — in a no-layout setup,
- * the root container; in a layout setup, the innermost surviving
- * layer's `pageSlot()` element. Opacity / transform fades apply to the
- * outgoing page content, then the new page fades in.
+ * the root container; in a layout setup, the innermost surviving layer's
+ * `pageSlot()` element.
  */
 export declare function fromTransition(t: TransitionOptions): Pick<RenderClientOptions, 'onLeave' | 'onEnter'>;
 /**
- * @internal — test helper. Disposes every layer in the current chain
- * and clears the module state so subsequent calls behave as a first
- * mount. Not part of the public API; subject to change without notice.
+ * @internal — test helper. Disposes every layer in the current chain and
+ * clears the module state so subsequent calls behave as a first mount.
  */
 export declare function _resetChainForTest(): void;
 /**
@@ -233,75 +154,45 @@ export declare function _resetChainForTest(): void;
 export declare function _resetCurrentHandleForTest(): void;
 /**
  * Default onRenderClient hook — no layout, no animation hooks. Hydrates
- * on first load, mounts fresh on subsequent navs. Use `createOnRenderClient`
- * for the customizable factory form.
+ * on first load, mounts fresh on subsequent navs.
  */
 export declare function onRenderClient(pageContext: ClientPageContext): Promise<void>;
 /**
- * Factory to create a customized onRenderClient hook. See `RenderClientOptions`
- * for the full option surface — this is the entry point for persistent
- * layouts, route transitions, and lifecycle hooks.
+ * Factory to create a customized onRenderClient hook. See
+ * `RenderClientOptions` for the full option surface.
  *
  * **Do not name your layout file `+Layout.ts`.** Vike reserves the `+`
- * prefix for its own framework config conventions, and `+Layout.ts` is
- * interpreted by `vike-react` / `vike-vue` / `vike-solid` framework
- * adapters as a native layout config. `@llui/vike` isn't a framework
- * adapter in that sense — it's a render adapter, and `createOnRenderClient`
- * consumes the layout component directly via the `Layout` option. Name
- * the file `Layout.ts`, `app-layout.ts`, or anywhere outside `/pages`
- * that Vike won't scan, and import it here by path.
- *
- * ```ts
- * // pages/+onRenderClient.ts
- * import { createOnRenderClient, fromTransition } from '@llui/vike/client'
- * import { routeTransition } from '@llui/transitions'
- * import { AppLayout } from './Layout.js' // ← NOT './+Layout'
- *
- * export const onRenderClient = createOnRenderClient({
- *   Layout: AppLayout,
- *   ...fromTransition(routeTransition({ duration: 200 })),
- *   onMount: () => console.log('page rendered'),
- * })
- * ```
+ * prefix for its own framework config conventions. Name the file
+ * `Layout.ts`, `app-layout.ts`, or anywhere outside `/pages` that Vike
+ * won't scan, and import it here by path.
  */
 export declare function createOnRenderClient(options: RenderClientOptions): (pageContext: ClientPageContext) => Promise<void>;
 /**
- * Public read of the current layout chain. Returns the live
- * `AppHandle`s for `[...layouts, page]`, outermost first. Empty array
- * before the first mount; updates after every navigation.
- *
- * Returns a fresh array each call, but the AppHandle references are
- * shared with the live chain — calling `.send()` / `.dispose()` /
- * `.subscribe()` operates on the same instance the framework manages.
- *
- * Prefer the `onMount(chain)` callback for lifecycle-coupled wiring
- * (the framework guarantees the chain is fully populated when it
- * fires); use this getter for ad-hoc reads where the caller can't
- * thread state through `onMount`.
+ * Public read of the current layout chain — live `LayerHandle`s for
+ * `[...layouts, page]`, outermost first. Empty before the first mount.
  */
-export declare function getLayoutChain(): readonly AppHandle[];
+export declare function getLayoutChain(): readonly LayerHandle[];
 interface MountOpts {
     mode: 'mount' | 'hydrate';
     /** For hydration: the full `window.__LLUI_STATE__` envelope. */
     serverStateEnvelope?: unknown;
-    /** Forwarded to `hydrateApp` / `hydrateAtAnchor`. Mount mode ignores. */
+    /** Forwarded to the signal hydrate path. Mount mode ignores. */
     runInitEffectsOnHydrate?: boolean;
 }
 /**
- * Mount (or hydrate) `chain[startAt..end]` into `initialTarget`, with
- * the initial layer's rootLifetime parented at `initialParentLifetime`.
- * Threads slot → next-target → next-parentLifetime through the chain.
+ * Mount (or hydrate) `chain[startAt..end]` into `initialTarget`, replaying
+ * `initialContexts` into the first layer's build. Threads each layer's slot
+ * (anchor + captured contexts) into the next layer's target + contexts.
  *
- * `initialTarget` is `HTMLElement` for the outermost layer (container-
- * based mount/hydrate) and `Comment` for inner layers that mount relative
- * to a `pageSlot()` anchor.
+ * `initialTarget` is an `HTMLElement` for the outermost layer (container mount/
+ * hydrate) and a `Comment` for inner layers mounting relative to a `pageSlot()`
+ * anchor.
  *
- * Fails loudly if a non-innermost layer forgot to call `pageSlot()`,
- * or if the innermost layer called `pageSlot()` unnecessarily.
+ * Fails loudly if a non-innermost layer forgot to call `pageSlot()`, or if the
+ * innermost layer called `pageSlot()` unnecessarily.
  *
- * @internal — test helper. Exported so `client-page-slot.test.ts` can
- * test anchor-mount/dispose contracts directly with hand-built DOM.
- * Not part of the public API.
+ * @internal — test helper. Exported so `client-page-slot.test.ts` can exercise
+ * anchor-mount/dispose contracts directly with hand-built DOM.
  */
-export declare function _mountChainSuffix(chain: LayoutChain, chainData: readonly unknown[], startAt: number, initialTarget: HTMLElement | Comment, initialParentLifetime: Lifetime | undefined, opts: MountOpts): void;
+export declare function _mountChainSuffix(chain: LayoutChain, chainData: readonly unknown[], startAt: number, initialTarget: HTMLElement | Comment, initialContexts: ReadonlyMap<symbol, unknown> | undefined, opts: MountOpts): void;
 //# sourceMappingURL=on-render-client.d.ts.map

package/dist/on-render-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"on-render-client.d.ts","sourceRoot":"","sources":["../src/on-render-client.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"on-render-client.d.ts","sourceRoot":"","sources":["../src/on-render-client.ts"],"names":[],"mappings":"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"}