@threadplane/renderClassv0.3.4

RenderElementComponent

Recursive element renderer.

For each element key it:

Looks up the UIElement from spec.elements
Resolves the component class from the registry
Evaluates visibility
Resolves prop expressions and bindings
Renders via NgComponentOutlet with resolved inputs

For elements with repeat, it iterates over the state array, creating a child Injector with RepeatScope for each item.

import { RenderElementComponent } from '@threadplane/render';

Declaration

export declare class RenderElementComponent implements OnInit  {
  constructor();
  readonly componentClass: Signal<AngularComponentRenderer | null>;
  readonly element: Signal<UIElement | undefined>;
  readonly elementKey: import("@angular/core").InputSignal<string>;
  readonly entry: Signal<NormalizedEntry | undefined>;
  readonly filteredRepeatInputs: Signal<Record<string, unknown>[]>;
  readonly filteredResolvedInputs: Signal<Record<string, unknown>>;
  readonly host: RenderHost;
  readonly mountClass: Signal<AngularComponentRenderer | null>;
  ngOnInit(): void;
  readonly notReady: Signal<boolean>;
  readonly parentInjector: Injector;
  readonly repeatInjectors: Signal<import("@angular/core").DestroyableInjector[]>;
  readonly repeatInputs: Signal<{
        bindings: Record<string, string> | undefined;
        emit: (event: string) => void;
        loading: boolean;
        childKeys: string[];
        spec: Spec;
    }[]>;
  readonly repeatMountClasses: Signal<(AngularComponentRenderer | null)[]>;
  readonly repeatNotReady: Signal<boolean[]>;
  readonly repeatVisible: Signal<boolean[]>;
  readonly resolvedInputs: Signal<{}>;
  readonly spec: import("@angular/core").InputSignal<Spec>;
  readonly visible: Signal<boolean>;
}

Angular template API

Selector: render-element

Inputs

elementKey · required: string
spec · required: Spec

Members

Constructor · overload 1

Constructs a new instance of the RenderElementComponent class

constructor();

componentClass

The Angular component class for this element type.

readonly componentClass: Signal<AngularComponentRenderer | null>;

element

The UIElement definition from the spec. Only propagates when reference changes.

readonly element: Signal<UIElement | undefined>;

elementKey

readonly elementKey: import("@angular/core").InputSignal<string>;

entry

The full normalized registry entry for this element type.

readonly entry: Signal<NormalizedEntry | undefined>;

filteredRepeatInputs

repeatInputs filtered per-item to declared component inputs — against that item's own mount class, which may be the fallback while a sibling already shows the real component.

readonly filteredRepeatInputs: Signal<Record<string, unknown>[]>;

filteredResolvedInputs

resolvedInputs filtered down to keys the target component actually declares — silences NG0303 dev-mode warnings from framework-only inputs (bindings/emit/loading/childKeys/spec) passed to simple view components that don't declare them.

readonly filteredResolvedInputs: Signal<Record<string, unknown>>;

host

Element-scoped host injected by mounted view components via injectRenderHost(). set writes the store; emit routes element handlers; result surfaces a RenderResultEvent for this element.

readonly host: RenderHost;

mountClass

Picks fallback or real based on notReady. The mountedReal latch is driven by a constructor effect (not this computed) — Angular forbids signal writes inside computed.

readonly mountClass: Signal<AngularComponentRenderer | null>;

ngOnInit · overload 1

ngOnInit(): void;

Returns

void

notReady

True when the element is not yet ready to mount the real component. Delegates to isElementReady which checks:

Any undefined-valued resolved prop (state binding still loading).
A sync Standard-Schema gate if the registry entry declares a schema. Framework-injected keys (bindings, emit, loading, childKeys, spec) are excluded — only consumer-resolved props matter for readiness.

readonly notReady: Signal<boolean>;

parentInjector

readonly parentInjector: Injector;

repeatInjectors

One child Injector per repeat item, providing RepeatScope and a row-scoped RenderHost (so injectRenderHost().emit(…) carries the row).

readonly repeatInjectors: Signal<import("@angular/core").DestroyableInjector[]>;

repeatInputs

Resolved inputs for each repeat item.

readonly repeatInputs: Signal<{
        bindings: Record<string, string> | undefined;
        emit: (event: string) => void;
        loading: boolean;
        childKeys: string[];
        spec: Spec;
    }[]>;

repeatMountClasses

Per-item counterpart of mountClass.

readonly repeatMountClasses: Signal<(AngularComponentRenderer | null)[]>;

repeatNotReady

Per-item counterpart of notReady: a row whose $item-bound props have not resolved yet shows the fallback while its ready siblings mount the real component. Latched per index, exactly as the single mount is.

readonly repeatNotReady: Signal<boolean[]>;

repeatVisible

Per-item visibility for repeat elements. The element's own visible condition is evaluated once per item, in that item's scope, so { $item: … } and { $index: … } conditions can hide individual rows — the same rule the non-repeat branch applies to a single mount.

readonly repeatVisible: Signal<boolean[]>;

resolvedInputs

Resolved inputs for non-repeat elements.

readonly resolvedInputs: Signal<{}>;

spec

readonly spec: import("@angular/core").InputSignal<Spec>;

visible

Whether the element is visible (non-repeat path).

readonly visible: Signal<boolean>;