@contentful/experiences-angular 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,189 @@
+## 0.2.0 (2026-09-28)
+
+### 🧱 Updated Dependencies
+
+- Updated live-preview to 0.2.0
+- Updated client to 0.5.0
+- Updated design to 0.9.0
+- Updated core to 0.9.0
+
+## 0.1.11 (2026-09-28)
+
+### 🚀 Features
+
+- add shared Experiences client runtime ([#206](https://github.com/contentful/experiences/pull/206))
+- add ExO event builder ([caf2772](https://github.com/contentful/experiences/commit/caf2772))
+
+### 🧱 Updated Dependencies
+
+- Updated live-preview to 0.1.9
+- Updated client to 0.4.9
+- Updated design to 0.8.7
+- Updated core to 0.8.7
+
+## 0.1.10 (2026-09-22)
+
+### 🧱 Updated Dependencies
+
+- Updated live-preview to 0.1.8
+- Updated client to 0.4.8
+
+## 0.1.9 (2026-09-22)
+
+### 🚀 Features
+
+- add destination node ID and path resolution to fetchExperience [AIS-567] ([#200](https://github.com/contentful/experiences/pull/200))
+
+### 🧱 Updated Dependencies
+
+- Updated live-preview to 0.1.7
+- Updated client to 0.4.7
+- Updated design to 0.8.6
+- Updated core to 0.8.6
+
+## 0.1.8 (2026-09-22)
+
+### 🧱 Updated Dependencies
+
+- Updated live-preview to 0.1.6
+- Updated client to 0.4.6
+- Updated design to 0.8.5
+- Updated core to 0.8.5
+
+## 0.1.7 (2026-09-22)
+
+### 🚀 Features
+
+- **live-preview:** expose connection errors [SPA-5151] ([#198](https://github.com/contentful/experiences/pull/198))
+
+### 🧱 Updated Dependencies
+
+- Updated live-preview to 0.1.5
+
+## 0.1.6 (2026-09-21)
+
+### 🚀 Features
+
+- deprecate the SDK viewport surface, guard absent viewports [SPA-5272] ([4a74473](https://github.com/contentful/experiences/commit/4a74473))
+
+### 🩹 Fixes
+
+- reword deprecation notices, drop internal ticket link [SPA-5272] ([8361460](https://github.com/contentful/experiences/commit/8361460))
+
+### 🧱 Updated Dependencies
+
+- Updated live-preview to 0.1.4
+- Updated client to 0.4.5
+- Updated design to 0.8.4
+- Updated core to 0.8.4
+
+## 0.1.5 (2026-09-21)
+
+### 🧱 Updated Dependencies
+
+- Updated live-preview to 0.1.3
+- Updated client to 0.4.4
+
+## 0.1.4 (2026-09-18)
+
+### 🚀 Features
+
+- **live-preview:** support resource resolution [SPA-5369] ([#193](https://github.com/contentful/experiences/pull/193))
+
+### 🧱 Updated Dependencies
+
+- Updated live-preview to 0.1.2
+
+## 0.1.3 (2026-09-11)
+
+### 🚀 Features
+
+- **live-preview:** expose preview status helper [SPA-5289] ([#170](https://github.com/contentful/experiences/pull/170))
+- **live-preview:** add framework adapters [SPA-5161] ([#165](https://github.com/contentful/experiences/pull/165))
+
+### 🧱 Updated Dependencies
+
+- Updated live-preview to 0.1.1
+- Updated client to 0.4.3
+- Updated design to 0.8.3
+- Updated core to 0.8.3
+
+## 0.1.2 (2026-09-10)
+
+### 🧱 Updated Dependencies
+
+- Updated client to 0.4.2
+- Updated design to 0.8.2
+- Updated core to 0.8.2
+
+## 0.1.1 (2026-09-02)
+
+### 🧱 Updated Dependencies
+
+- Updated client to 0.4.1
+- Updated design to 0.8.1
+- Updated core to 0.8.1
+
+## 0.1.0 (2026-08-28)
+
+### 🧱 Updated Dependencies
+
+- Updated client to 0.4.0
+- Updated design to 0.8.0
+- Updated core to 0.8.0
+
+## 0.0.6 (2026-08-28)
+
+### 🚀 Features
+
+- error handling and sensible fallbacks for non-happy-path rendering [AIS-364] ([#156](https://github.com/contentful/experiences/pull/156))
+
+### 🧱 Updated Dependencies
+
+- Updated client to 0.3.11
+- Updated design to 0.7.11
+- Updated core to 0.7.11
+
+## 0.0.5 (2026-08-27)
+
+### 🧱 Updated Dependencies
+
+- Updated client to 0.3.10
+- Updated design to 0.7.10
+- Updated core to 0.7.10
+
+## 0.0.4 (2026-08-26)
+
+### 🧱 Updated Dependencies
+
+- Updated client to 0.3.9
+- Updated design to 0.7.9
+- Updated core to 0.7.9
+
+## 0.0.3 (2026-08-24)
+
+### 🧱 Updated Dependencies
+
+- Updated client to 0.3.8
+- Updated design to 0.7.8
+- Updated core to 0.7.8
+
+## 0.0.2 (2026-08-21)
+
+### 🧱 Updated Dependencies
+
+- Updated client to 0.3.7
+- Updated design to 0.7.7
+- Updated core to 0.7.7
+
+## 0.0.1 (2026-08-20)
+
+### 🚀 Features
+
+- **adapter-angular:** scaffold @contentful/experiences-angular [AIS-361] ([#134](https://github.com/contentful/experiences/pull/134))
+
+### 🧱 Updated Dependencies
+
+- Updated client to 0.3.6
+- Updated design to 0.7.6
+- Updated core to 0.7.6

package/README.md

@@ -0,0 +1,368 @@
+# @contentful/experiences-angular
+
+> ⚠️ **Alpha.** Published to npm. APIs are unstable and will change.
+
+The Angular adapter for the Contentful Experiences SDK. You bring your own standalone Angular components; it renders Experience payloads from the Experience Delivery API (XDA) with them.
+
+```sh
+npm install @contentful/experiences-angular
+```
+
+Supports Angular **20, 21, and 22**. The package ships partial-Ivy output compiled by the lowest supported compiler, so the Angular linker in your app can consume it on any of the three.
+
+This is the **only SDK package you install**. It re-exports everything you need from `@contentful/experiences-sdk-core` and `@contentful/experiences-design`. The other packages are workspace-internal.
+
+The public API mirrors `@contentful/experiences-react` and `@contentful/experiences-svelte` in shape; only the rendering primitives change (standalone `Type<unknown>` components, `PortableRenderNode[]` slot inputs instead of `children: ReactNode`, and `injectDesignValues()` instead of `useDesignValues()`). See [Parity table](#parity-table) for the full mapping.
+
+---
+
+## Public API
+
+### Authoring
+
+```ts
+defineComponent<Props>(config); // Type-narrowing identity for component-type configs
+defineExperienceTemplate<Props>(config); // Same shape, for coded Experience Template configs
+```
+
+### Fetching
+
+```ts
+fetchExperience(experienceOptions, clientOptions, resolveOptions); // Async; fetches from XDA and resolves in one call
+fetchPreviewSession(previewSessionOptions, clientOptions, resolveOptions); // Async; fetches and resolves a Preview Session Experience
+```
+
+Use `fetchPreviewSession` for the initial render when the Contentful app
+provides a `preview_session_id`. It fetches the current Preview Session
+snapshot and resolves it into a `PortableRenderPlan`. Use `injectLivePreview`
+to receive subsequent WebSocket updates:
+
+```ts
+const plan = await fetchPreviewSession(
+  { spaceId, environmentId, sessionId },
+  { previewToken },
+  { config: experienceConfig }
+);
+```
+
+If the Preview Session references resources from other spaces, pass the same
+encoded `resourceResolution` value in the `previewSessionOptions` passed to
+`fetchPreviewSession` and `injectLivePreview`.
+
+### Resolver
+
+```ts
+resolveExperience(payload, config, opts?); // Async; walks payload, runs resolveData, returns a PortableRenderPlan
+```
+
+### Live preview
+
+Use `injectLivePreview()` when the app should subscribe to Preview Session
+updates, resolve each payload, and render the resulting plan from `data`:
+
+```ts
+readonly livePreview = injectLivePreview(() => ({
+  previewSessionOptions,
+  initialPayload,
+  initialPlan,
+  resolveOptions: { config: experienceConfig },
+}));
+```
+
+For separate access to the raw payload and rendered plan, use
+`injectLivePreviewExperience()` and `injectExperiencePlan()`. The first returns
+the raw Experience payload. The second passes that payload to
+`resolveExperience()` and returns the `PortableRenderPlan` consumed by the
+renderer. Keeping the values separate lets an app use the raw payload when it
+needs it.
+
+Both helpers take a getter. Angular can call an injection helper before it has
+assigned component inputs, so the getter reads the current values when Angular
+runs the helper. Each helper returns an object with a `data` signal, matching
+the other framework adapters.
+
+```ts
+// page.component.ts
+import { Component } from '@angular/core';
+import {
+  ClientExperienceRenderer,
+  injectLivePreviewExperience,
+  injectExperiencePlan,
+  type PortableRenderPlan,
+} from '@contentful/experiences-angular';
+import { experienceConfig } from './experience-config';
+
+@Component({
+  selector: 'app-page',
+  imports: [ClientExperienceRenderer],
+  template: `<cf-experience [experience]="plan.data()" [config]="experienceConfig" />`,
+})
+export class PageComponent {
+  readonly livePreviewOptions = {
+    previewSessionOptions: {
+      spaceId: 'space-id',
+      environmentId: 'environment-id',
+      previewToken: 'preview-token',
+      sessionId: 'session-id',
+    },
+  };
+  readonly initialPlan: PortableRenderPlan | undefined = undefined;
+
+  readonly livePreview = injectLivePreviewExperience(() => this.livePreviewOptions);
+  readonly plan = injectExperiencePlan(() => ({
+    payload: this.livePreview.data(),
+    initialPlan: this.initialPlan,
+    resolveOptions: { config: experienceConfig },
+  }));
+
+  protected readonly experienceConfig = experienceConfig;
+}
+```
+
+`injectLivePreviewExperience()` starts its subscription after the first browser render.
+Set both `previewToken` and `sessionId` to receive Preview Session updates. The
+initial payload remains available while updates arrive. The browser SDK sends
+the token as the WebSocket URL's `access_token` parameter.
+
+`injectExperiencePlan()` calls `resolveExperience()` for each new raw
+payload. It updates `plan.data()` after the resolver returns a complete
+plan. The current plan stays in place until the new plan is ready.
+
+The live-preview results also expose an `error` signal when the Preview Session
+connection fails. The last valid `data` remains available.
+
+### Renderers
+
+Every renderer is standalone; add it to your own component's `imports`.
+
+```ts
+ServerExperienceRenderer; // <cf-server-experience>  SSR-safe; active viewport seeded from initialViewportId
+ClientExperienceRenderer; // <cf-experience>         Subscribes to window.matchMedia
+MissingComponent; // <cf-missing-component>  Default fallback for unregistered component types
+NodesRenderer; // *cfNodes                Renders a slot's raw nodes (see Slot children)
+NodeRenderer; // *cfNode                 Renders one node; NodesRenderer loops over it
+DebugExperience; // <cf-debug-experience>   Auto-mounted by the renderers when debug is set
+injectActiveViewport; // Signal-backed viewport index; you'll rarely need it directly
+injectLivePreviewExperience; // Signal-backed raw Experience payload
+injectExperiencePlan; // Signal-backed PortableRenderPlan
+```
+
+`NodesRenderer` and `NodeRenderer` are **structural directives**, not components, so they add no element of their own — see [Slot children](#slot-children).
+
+Each is also exported under its Angular-suffixed class name (`ServerExperienceRendererComponent`, `NodesRendererDirective`, and so on), and `ExperienceRenderer` is an alias for `ClientExperienceRenderer`.
+
+### Styling + runtime context (helpers)
+
+All four are `inject()`-based: call them from a field initializer or a constructor, like any other Angular injection API.
+
+```ts
+injectDesignValues<T>(); // Signal of the resolved design record that auto-fills inputs
+toCss(design, options?); // Turns a design record into a plain style object for [ngStyle]
+injectExperience(); // Signal<RenderContext>: debug, metadata, viewports, activeViewport
+injectContentfulComponent(); // Signal of the raw payload for the enclosing node (or undefined)
+injectContentfulExperienceTemplate(); // Same, for an enclosing coded Experience Template node
+type ToCssOptions;
+```
+
+Resolved design values (viewport-cascaded + token-resolved server-side) are **auto-filled onto your component's inputs** by key, alongside content. Declaring an `@Input()` per design key you style with is the one recommended path — and in Angular it is also what makes the key arrive, since binding an undeclared input is an error. `injectDesignValues()` returns the same record as a `Signal`, as an escape hatch and as the way to read keys your component didn't declare, which are **dropped** rather than passed (see [Parity table](#parity-table)). Reach for it only for a nested child that isn't itself a registered component, or for design needed outside the render path (an effect, an imperative measurement) — see [Styling components](../../README.md#styling-components). Token resolution is configured with `resolveToken` on your `Config` (`type ResolveToken`).
+
+### Re-exported types and utilities
+
+```ts
+// From core
+type Config, Components, ExperienceTemplates, Registration, ExperienceTemplateRegistration,
+type ComponentConfig, ExperienceTemplateConfig,
+type ContentfulComponent, ContentfulExperienceTemplate,
+type RenderContext, RenderUnknown, ResolveToken, SlotNodes,
+type ExperiencePayload, ExperienceNode, ComponentNode, ExperienceTemplateNode,
+type ComponentRef, ExperienceTemplateRef, ExperienceSys,
+type PortableRenderPlan, PortableRenderNode, PortableRegistration,
+type DesignPropValue, ManualDesignValue, DesignToken, ValuesByViewport,
+type ViewportDef, ExperienceContext, ResolveContext,
+type ResolverConfig, ResolveExperienceOptions
+
+// From live preview and the Angular adapter
+type PreviewSessionOptions, LivePreviewClient,
+type InjectLivePreviewExperienceOptions, InjectLivePreviewExperienceResult,
+type ExperiencePlanResolveOptions, InjectExperiencePlanOptions,
+type InjectExperiencePlanResult
+
+// From design (if you want to do your own viewport-aware resolution)
+getValueForViewport, getViewportIndex, resolveDesignProperties, toCssMediaQuery,
+isCssProperty, toCssKey, CSS_PROPERTIES
+
+// From client
+createClient, fetchExperience, fetchPreviewSession, ContentfulViewDelivery,
+ContentfulViewDeliveryClient, NotFoundError, PreviewSessionFetchError,
+LivePreviewConnectionError,
+DELIVERY_HOST, PREVIEW_HOST, PREVIEW_WEBSOCKET_HOST
+
+type ExperienceOptions, PreviewSessionExperienceOptions, PreviewSessionClientOptions,
+  PreviewSessionResolveOptions, ClientOptions, ResolveOptions, CreateClientOptions
+```
+
+---
+
+## Quick reference
+
+```ts
+// button.component.ts — content + resolved design both arrive as inputs
+import { Component, Input, signal } from '@angular/core';
+
+@Component({
+  selector: 'app-button',
+  template: `
+    @if (urlValue()) {
+      <a [href]="urlValue()" [style.background]="bgValue()" [style.color]="colorValue()">
+        {{ labelValue() }}
+      </a>
+    } @else {
+      <button type="button" [style.background]="bgValue()" [style.color]="colorValue()">
+        {{ labelValue() }}
+      </button>
+    }
+  `,
+})
+export class ButtonComponent {
+  protected readonly labelValue = signal('Button');
+  protected readonly urlValue = signal<string | undefined>(undefined);
+  protected readonly bgValue = signal<string | undefined>(undefined);
+  protected readonly colorValue = signal<string | undefined>(undefined);
+
+  // Decorator inputs bridged into signals, not signal input(): see the parity
+  // table. The input name is what the payload key binds to; the readable signal
+  // needs a different name, and must be `protected`, not `private`, to stay
+  // template-readable under strictTemplates.
+  @Input() set label(value: string | undefined) {
+    this.labelValue.set(value ?? 'Button');
+  }
+  @Input() set url(value: string | undefined) {
+    this.urlValue.set(value);
+  }
+  @Input() set backgroundColor(value: string | undefined) {
+    this.bgValue.set(value);
+  }
+  @Input() set color(value: string | undefined) {
+    this.colorValue.set(value);
+  }
+}
+```
+
+```ts
+// experience-config.ts
+import {
+  defineComponent,
+  type Components,
+  type Config,
+  type ResolveToken,
+} from '@contentful/experiences-angular';
+import { ButtonComponent } from './components/button.component';
+
+interface ButtonProps {
+  label?: string;
+  url?: string;
+  backgroundColor?: string; // resolved design, auto-filled
+  color?: string;
+}
+
+const components: Components = {
+  // Bare component class, or defineComponent({...}) when you need defaults/resolveData.
+  Button: defineComponent<ButtonProps>({
+    resolveData: ({ content }) => ({ url: ensureScheme(content.url) }),
+    component: ButtonComponent,
+  }),
+};
+
+const resolveToken: ResolveToken = (token) => designTokens[token.value];
+
+export const experienceConfig: Config = { components, resolveToken };
+```
+
+```ts
+// page.component.ts
+import { Component, Input } from '@angular/core';
+import { ServerExperienceRenderer, type PortableRenderPlan } from '@contentful/experiences-angular';
+import { experienceConfig } from './experience-config';
+
+@Component({
+  selector: 'app-page',
+  imports: [ServerExperienceRenderer],
+  template: `<cf-server-experience [experience]="experience" [config]="config" />`,
+})
+export class PageComponent {
+  @Input() experience!: PortableRenderPlan;
+  protected readonly config = experienceConfig;
+}
+```
+
+### Slot children
+
+Every slot arrives as an input named after the slot, holding an **array of nodes** (`PortableRenderNode[]`, aliased `SlotNodes`) — not renderable children. Hand the array to `*cfNodes` to render it; to wrap, reorder, or drop children individually, loop the array yourself and render each with `*cfNode`.
+
+```ts
+// section.component.ts
+import { Component, Input, signal } from '@angular/core';
+import { NodesRenderer, type SlotNodes } from '@contentful/experiences-angular';
+
+@Component({
+  selector: 'app-section',
+  imports: [NodesRenderer],
+  // Common case — render them all:
+  template: `<div><ng-container *cfNodes="nodes()"></ng-container></div>`,
+  // Or take control of each child, with NodeRenderer in imports instead:
+  //   <div>
+  //     @for (child of nodes() ?? []; track $index) {
+  //       <div class="cell"><ng-container *cfNode="child"></ng-container></div>
+  //     }
+  //   </div>
+})
+export class SectionComponent {
+  protected readonly nodes = signal<SlotNodes | undefined>(undefined);
+
+  @Input() set children(value: SlotNodes | undefined) {
+    this.nodes.set(value);
+  }
+}
+```
+
+Slot children stay **lazy**: a component that never renders a slot input never instantiates those subtrees.
+
+Both are **structural directives**, so the adapter puts no element of its own between you and your children: they render as direct children of the element you wrapped them in, exactly as in React and Svelte. `display: grid` with `gap` on the `<div>` above lays out **the slot children**; `> .card`, `:nth-child(2)`, `:first-child`, and the `+`/`~` combinators all work. (Each directive leaves a comment anchor, as Svelte does — comments are not elements, so they affect neither layout nor any of those selectors.)
+
+`children` is not special — it is simply the conventional name for the default slot. **Every** slot in the payload becomes a same-named `SlotNodes` input, so a component with a `header` slot just declares `header` and renders it the same way. This applies identically to coded Experience Templates: a template with a `content` slot receives a `content` input.
+
+The same nodes are also on the payload at `injectContentfulComponent()().slots` (a `Record<string, PortableRenderNode[]>`).
+
+---
+
+## Parity table
+
+Everything below is a deliberate divergence from React and Svelte, forced by an Angular primitive. Semantics — merge precedence, the viewport cascade, degradation behaviour, context walk-up — are identical across all three adapters and covered by the same ported test suite.
+
+| Concern                                          | React                                                                                        | Svelte                                                       | Angular                                                                          | Why                                                                                                                                                                                       |
+| ------------------------------------------------ | -------------------------------------------------------------------------------------------- | ------------------------------------------------------------ | -------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Runtime accessors                                | `useExperience()`, `useDesignValues()`                                                       | `getExperience()`, `getDesignValues()`                       | `injectExperience()`, `injectDesignValues()`                                     | Angular's DI idiom. Must be called from an injection context.                                                                                                                             |
+| Accessor return type                             | plain value (re-renders)                                                                     | plain value (read in `$derived`)                             | `Signal<T>` — call it to read                                                    | Signals are Angular's reactive primitive.                                                                                                                                                 |
+| Renderer usage                                   | `<ServerExperienceRenderer …/>`                                                              | `<ServerExperienceRenderer …/>`                              | `<cf-server-experience …/>` after adding `ServerExperienceRenderer` to `imports` | Angular components are referenced by selector, imported by class.                                                                                                                         |
+| Slot children                                    | `children: ReactNode` — render directly                                                      | `Snippet[]` — `{@render child()}`                            | `PortableRenderNode[]` — render with `*cfNodes`                                  | Angular has no lazy named-slot primitive; `projectableNodes` is positional and eager.                                                                                                     |
+| `NodesRenderer`                                  | not exported                                                                                 | exported (escape hatch)                                      | exported and **load-bearing**                                                    | It is the only way to render a slot.                                                                                                                                                      |
+| Undeclared merged keys                           | passed through as props                                                                      | passed through as props                                      | **dropped**                                                                      | Binding an input a component does not declare is an error, so the merged record is filtered via `reflectComponentType`. Still readable through `injectDesignValues()`.                    |
+| Reading dropped keys                             | n/a                                                                                          | n/a                                                          | `injectDesignValues()`                                                           | The full resolved design record is always available regardless of declared inputs.                                                                                                        |
+| Component inputs                                 | props                                                                                        | `$props()`                                                   | `@Input()` setter → `signal`                                                     | Signal `input()` is AOT-only; a JIT consumer reports zero declared inputs, which would break `reflectComponentType` filtering.                                                            |
+| Input naming                                     | any                                                                                          | any                                                          | setter takes the payload key; the readable signal needs a distinct name          | A class cannot declare a field and an accessor under one name, and under `useDefineForClassFields: false` the field initializer would assign straight through the setter.                 |
+| `injectActiveViewport` args                      | values                                                                                       | values                                                       | **getters** (`() => viewports`)                                                  | An injection context runs before inputs are bound. Every `Signal` is already a getter, so passing one works unchanged.                                                                    |
+| Missing-component warning                        | effect                                                                                       | effect                                                       | `ngOnInit`                                                                       | So the diagnostic also fires during server rendering.                                                                                                                                     |
+| Prop-shape types                                 | inferred                                                                                     | separate `*.ts` per component                                | not needed                                                                       | Angular components are `.ts`, so `tsc --noEmit` already resolves them.                                                                                                                    |
+| Style helper output                              | `CSSProperties`                                                                              | plain record                                                 | plain record for `[ngStyle]`                                                     | Scalar-only, same as Svelte.                                                                                                                                                              |
+| `component-render-error` under SSR               | caught (internal `<Suspense>` degrades gracefully under both legacy and streaming renderers) | **not caught** — `<svelte:boundary>` doesn't run server-side | caught, identically to CSR                                                       | Angular has no separate server renderer — `createComponent` is the same call either way. See the root README's [error-handling section](../../README.md#error-handling--troubleshooting). |
+| `component-render-error` after a later re-render | caught (standard class boundary)                                                             | caught (standard `<svelte:boundary>`)                        | **not caught** — creation-time only                                              | `ApplicationRef` resolves `ErrorHandler` once from the root injector, so a per-node override can't catch a later change-detection throw. Documented gap; see the root README.             |
+
+**Not** a divergence: the DOM around slot children. React renders them through a fragment, Svelte through no element, and Angular through structural directives — no adapter element in any of the three. Dispatch deliberately does not use components, because an Angular component always has a host element and no configuration removes it; `display: contents` would hide such a wrapper from layout but not from `> .card`, `:nth-child(n)`, or the sibling combinators.
+
+For the full getting-started walkthrough, the merge-precedence rules, viewport handling, and design rationale, see the [root README](../../README.md) and [`AGENTS.md`](../../AGENTS.md).
+
+---
+
+## License
+
+MIT. See the repository [`LICENSE`](../../LICENSE) and [`NOTICE`](../../NOTICE) for full attribution.

package/dist/client-experience-renderer.component.d.ts

@@ -0,0 +1,42 @@
+import { type Type } from '@angular/core';
+import type { PortableRenderPlan } from '@contentful/experiences-sdk-core';
+import type { Config } from './types.js';
+import * as i0 from "@angular/core";
+export declare class ClientExperienceRendererComponent {
+    protected readonly experienceValue: import("@angular/core").WritableSignal<PortableRenderPlan | null>;
+    private readonly debugValue;
+    protected readonly resolvedDebug: import("@angular/core").Signal<boolean>;
+    private readonly configValue;
+    private readonly initialViewportIdValue;
+    private readonly metadataValue;
+    private readonly renderUnknownValue;
+    private readonly renderErrorValue;
+    /** A resolved render plan, or `null` while one is still being fetched. */
+    set experience(value: PortableRenderPlan | null | undefined);
+    set config(value: Config);
+    /**
+     * Viewport to render for until `matchMedia` takes over after the first render.
+     * Set it to whatever the server rendered with so hydration does not flicker.
+     */
+    set initialViewportId(value: string | undefined);
+    /** Shallow-merges over the plan's `metadata`. Only needed to override it. */
+    set metadata(value: Record<string, unknown> | undefined);
+    /**
+     * Renders the resolved plan above the experience for inspection. Defaults to
+     * the plan's `debug`; `[debug]="false"` overrides a debug-on plan.
+     */
+    set debug(value: boolean | undefined);
+    /** Replaces the default missing-component box. Receives `componentId` and `nodeId`. */
+    set renderUnknown(value: Type<unknown> | undefined);
+    /** Replaces the default error box rendered when a registered component throws. */
+    set renderError(value: Type<unknown> | undefined);
+    private readonly tracker;
+    private readonly renderContext;
+    private readonly scope;
+    /** Resolve-time + render-time diagnostics, merged for `<cf-debug-experience>`. */
+    protected readonly errors: import("@angular/core").Signal<Error[]>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClientExperienceRendererComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClientExperienceRendererComponent, "cf-experience", never, { "experience": { "alias": "experience"; "required": true; }; "config": { "alias": "config"; "required": true; }; "initialViewportId": { "alias": "initialViewportId"; "required": false; }; "metadata": { "alias": "metadata"; "required": false; }; "debug": { "alias": "debug"; "required": false; }; "renderUnknown": { "alias": "renderUnknown"; "required": false; }; "renderError": { "alias": "renderError"; "required": false; }; }, {}, never, never, true, never>;
+}
+//# sourceMappingURL=client-experience-renderer.component.d.ts.map

package/dist/client-experience-renderer.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-experience-renderer.component.d.ts","sourceRoot":"","sources":["../src/client-experience-renderer.component.ts"],"names":[],"mappings":"AAaA,OAAO,EAIL,KAAK,IAAI,EAIV,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AAS3E,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,YAAY,CAAC;;AAExD,qBAqBa,iCAAiC;IAC5C,SAAS,CAAC,QAAQ,CAAC,eAAe,oEAA2C;IAE7E,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA0C;IACrE,SAAS,CAAC,QAAQ,CAAC,aAAa,0CAE9B;IACF,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA+B;IAC3D,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAyC;IAChF,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA0D;IACxF,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAoD;IACvF,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAkD;IAEnF,0EAA0E;IAC1E,IAA+B,UAAU,CAAC,KAAK,EAAE,kBAAkB,GAAG,IAAI,GAAG,SAAS,EAErF;IAED,IAA+B,MAAM,CAAC,KAAK,EAAE,MAAM,EAElD;IAED;;;OAGG;IACH,IAAa,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAEvD;IAED,6EAA6E;IAC7E,IAAa,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAE/D;IAED;;;OAGG;IACH,IAAa,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,EAE5C;IAED,uFAAuF;IACvF,IAAa,aAAa,CAAC,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,SAAS,EAE1D;IAED,kFAAkF;IAClF,IAAa,WAAW,CAAC,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,SAAS,EAExD;IAID,OAAO,CAAC,QAAQ,CAAC,OAAO,CAStB;IAEF,OAAO,CAAC,QAAQ,CAAC,aAAa,CAgB3B;IAEH,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA2B;IAEjD,kFAAkF;IAClF,SAAS,CAAC,QAAQ,CAAC,MAAM,0CAGtB;;yCA1FQ,iCAAiC;2CAAjC,iCAAiC;CAkG7C"}