@typed/template

Represents a dynamic attribute (e.g. src="${url}").

Represents every static or dynamic attribute-like AST node.

Represents a static attribute (e.g. class="foo").

Represents a boolean attribute (e.g. disabled).

Represents a dynamic boolean attribute (e.g. ?disabled="${isDisabled}").

Renders a stream of RenderEvents into a single HTML string.

This is a convenience function that collects all events from renderToHtml and joins them into a single string. It is an Effect that resolves when the stream completes.

Represents a dynamic class name part (e.g. class="${classes}").

Represents a sparse class name (e.g. class="foo ${bar}").

Represents a dynamic comment part.

Represents static, dynamic, or sparse comment content.

Represents a static comment.

Locates a compatible SSR template range for an advanced render context.

A service that provides the Document interface for rendering.

Defaults to the global document object. This can be overridden for testing or environments where the global document is not available or desired.

Mounts any Renderable to a specific DOM element.

This function lifts primitives, arrays, Effects, Streams, and Fx values into a render stream and keeps the target DOM element updated. It handles:

• Mounting the initial content.
• Updating the content as new events are emitted.
• Hydrating the content if hydration context is provided.

Computes the DOM value represented by a nullable RenderEvent.

Converts a Rendered value to an HTML string.

A Layer that provides the RenderTemplate service implemented for DOM rendering.

This layer enables templates to be rendered as actual DOM nodes. It handles:

• Parsing templates into DOM fragments.
• Caching parsed templates.
• Hydrating from existing DOM (if applicable).
• Setting up event listeners.
• Managing fine-grained updates to DOM nodes via Fx streams.

Represents a data attribute part (e.g. data-foo="${value}").

Modifies an EventHandler to call preventDefault() on the event.

An interface for managing event listeners on DOM nodes.

It abstracts the process of adding and removing event listeners, ensuring that they are properly cleaned up when the scope is closed or the element is removed.

Creates a new EventSource.

The created EventSource can efficiently manage multiple event listeners, grouping them by event type and handling setup/teardown lifecycles.

Represents a parsed DOCTYPE declaration.

A chunk representing a dynamic part (interpolation).

Represents a dynamic insertion point within the node structure (e.g. <div>${content}</div>).

Represents a single dynamic interpolation part in the template AST.

Represents a reference capture (e.g. ref="${ref}").

Represents an HTML, SVG, MathML, or foreign-content element with children.

Represents an AST node that can structurally contain template children.

Represents a self-closing HTML element (e.g. <br />, <img />).

Creates a new EventHandler.

The global symbol used to identify EventHandler values across module copies.

Checks if a value is an EventHandler.

Represents a DOM event handler that returns an Effect.

It encapsulates the event handler logic and any options (like preventDefault, once, etc.) that should be applied when the event is triggered.

Creates a published advanced Wire from a fragment and exact boundary comments.

A RenderQueue that schedules tasks using requestAnimationFrame. Good for visual updates that should happen before the next repaint.

Advanced mutable builder used by the published template-to-chunk compiler.

Represents a piece of a pre-compiled HTML template.

Chunks allow the renderer to stream static parts of the HTML immediately while waiting for dynamic parts to be resolved.

Converts a parsed Template into a sequence of HtmlChunks. This optimization pre-calculates the static HTML strings to minimize work at render time.

A boolean service that indicates whether the current rendering context is static.

If true, the HTML renderer will optimize for static output, potentially skipping dynamic placeholder generation or other interactive features not needed for static HTML.

Checks if a value is an HtmlRenderEvent.

The published advanced brand identifying renderer-owned HTML transport.

Recovers from errors in the EventHandler.

Extracts the typed error channel of an EventHandler.

Helper to ensure a value is an EventHandler.

If the input is already an EventHandler, it is returned as is. If it is an Effect, it is wrapped in an EventHandler that ignores the event argument.

Extracts the Effect service requirements of an EventHandler.

Provides services to the EventHandler.

This allows you to inject dependencies into the effect returned by the event handler.

A Layer that provides the RenderTemplate service implemented for HTML string generation.

Using this layer enables templates to be rendered as HTML strings (e.g., for SSR) rather than DOM nodes. It sets the RefSubject.CurrentComputedBehavior to "one", indicating a single-pass render approach typical for HTML generation.

Advanced renderer state describing the current hydration range.

Creates a hydration context starting from a root element.

This context allows the renderer to “attach” to existing DOM nodes (SSR output) instead of creating new ones.

Wraps the HTML chunks with comments containing the template hash. This is crucial for hydration to identify which template rendered a section of HTML.

A RenderQueue that schedules tasks using requestIdleCallback. Good for low-priority background work.

A RenderQueue that executes tasks synchronously and immediately.

Identifies a keyed collection descriptor without starting its source.

Recognizes a descriptor before a target chooses its keyed rendering path. This guard does not subscribe to the collection or validate its current keys; key uniqueness is checked when the target receives an array.

A collection source, stable key function, and per-item view supplied to a renderer. Describing the collection acquires nothing; the active target owns subscription and child lifetimes.

The DOM target retains each key’s subject and scope across moves. The HTML target consumes an initial collection for finite response output. Construct descriptors with many rather than assembling this protocol by hand.

Efficiently renders a reactive list of items by using keys to minimize DOM operations and maintain component state.

many returns a renderer descriptor rather than an Fx. The active renderer consumes its source directly and can therefore retain keyed entries without flattening each child back through a generic collection stream.

Produces the legacy closing marker for an already encoded keyed-list hole.

Modifies an EventHandler to run only once.

A composite RenderQueue that directs tasks to different queues based on their priority.

• High priority: Sync
• Medium priority: RAF (or setTimeout fallback)
• Low priority: IdleCallback (or setTimeout fallback)

A RenderEvent containing DOM nodes.

Checks if a value is a DomRenderEvent.

Checks if a rendered node is an Element.

Checks if a rendered node is an HTMLElement.

Checks if a rendered node is an SVGElement.

Represents an event listener part (e.g. @click="${handler}").

Applies event options to a native DOM event.

Extracts the native event type accepted by an EventHandler.

Options for applying native event behavior before an Effect handler runs.

Modifies an EventHandler to be passive (improves scrolling performance).

Checks if a rendered node is an Attr node.

Checks if a rendered node is a Comment node.

Checks if a rendered node is a DocumentFragment.

Checks if a rendered node is a standard DOM Node.

Checks if a rendered node is a Text node.

A union type representing all possible rendered values. Can be a single Node, a DocumentFragment, a Wire, or an array of these.

Extract the elements from a Rendered type

Single rendered value type.

Extract the values from a Rendered type

Checks if a rendered value is an array of nodes.

Wire is a data type that serves as a persistent, reusable DocumentFragment.

Unlike a standard DocumentFragment, which empties itself when appended to the DOM, a Wire retains references to its child nodes. This allows it to be moved around the DOM or updated without losing track of its content.

It is used internally to manage the lifecycle of template instances.

Creates a Wire from a DocumentFragment.

If the fragment has only one child, that child is returned directly. If it has multiple children, they are wrapped in a Wire structure (bounded by comments) to allow them to be treated as a single unit.

Modifies an EventHandler to call stopImmediatePropagation() on the event.

Modifies an EventHandler to call stopPropagation() on the event.

Represents a property assignment (e.g. .value="${value}").

Checks if a rendered node is a Wire.

Creates the advanced node adapter used by local DOM reconciliation.

Gets all sibling nodes between exact range boundaries, excluding both markers.

Defines priority levels for rendering tasks.

A service that provides the default priority for rendering tasks.

The default value is RenderPriority.Raf(10), which typically schedules updates to occur before the next repaint.

A service that manages the queue of DOM updates.

It ensures that DOM updates are batched and executed efficiently, often coordinating with browser painting cycles (e.g., via requestAnimationFrame).

Extracts the error type from a Renderable type.

Traverse all keys in an object and extract the error from each value. If the value is a function, extract the error from the return type of the function.

Represents any value that can be rendered into a template.

This includes:

• Primitives (string, number, boolean, null, undefined)
• Arrays of Renderables
• Effects that produce a Renderable
• Streams (Fx or Stream) that emit Renderables
• Objects (typically for setting properties or attributes)

A type alias for any Renderable value with any error/context.

Converts any Renderable into an Fx while preserving its nested errors and service requirements.

Recursively computes the terminal value emitted by a Renderable.

The Effect ecosystem producers recognized as reactive Renderables.

Extracts the required services from a Renderable type.

Traverse all keys in an object and extract the services from each value. If the value is a function, extract the services from the return type of the function.

Extracts all Elements from a Rendered value.

Represents the result of a rendering operation. Can be either a DOM-based event (containing actual Nodes) or an HTML-based event (containing strings).

The global discriminant key shared by DOM and HTML render events.

Checks if a value is a RenderEvent.

An abstract base class for managing the execution of rendering tasks. It allows prioritizing updates and scheduling them using different strategies (e.g., requestAnimationFrame, requestIdleCallback, setTimeout, or synchronous execution).

The nominal key implemented by every Typed render queue.

A RenderEvent containing an HTML string.

A chunk representing a sparse part (mixed static/dynamic text).

Represents a sparse attribute (e.g. class="foo ${bar}").

Represents a sparse comment.

Represents a “sparse” part, which is a text or attribute value composed of mix of static text and dynamic parts (e.g. id="prefix-${id}").

Represents sparse text content (e.g. Hello ${name}!).

Represents a spread of properties (e.g. ${...props}).

Reports whether a dynamic spread key may be serialized into SSR HTML.

A static text chunk.

A variant of HtmlRenderTemplate that enables static rendering optimizations.

This layer provides the RenderTemplate service for HTML generation but also sets StaticRendering to true, enabling optimizations for static content.

Renders a stream of RenderEvents into a stream of HTML strings.

This function transforms the output of a template rendering process (which produces RenderEvents) into a stream of strings suitable for HTML output (e.g., for Server-Side Rendering).

The main template tag function.

It creates a reactive Fx stream that renders the template. The actual rendering logic depends on the provided RenderTemplate service.

A service that defines how templates are rendered.

Different implementations can be provided for different environments (e.g., DomRenderTemplate for browsers, HtmlRenderTemplate for SSR).

Parses a template string array (from a tagged template literal) into a reusable Template object.

This parser handles:

• Standard HTML structure (elements, attributes, text, comments).
• Custom part syntax for interpolation (e.g., ${value}).
• Special attributes like .property, @event, ?boolean.
• Self-closing tags and text-only elements (script, style).

Each call returns a new Template instance containing the static AST and dynamic part locations. Render targets cache their compiled DOM fragments or HTML chunks independently by template-literal identity.

Advanced per-template DOM rendering state used by renderer extensions.

Represents any root or child node in the renderer-neutral template AST.

Represents a parsed HTML template.

A Template instance contains the static structure of an HTML template (nodes) and metadata about dynamic parts (interpolation points).

The basic primitive types that can be rendered directly.

Represents a dynamic text part (e.g. ${text}).

Represents static, dynamic, or sparse text content.

Represents a static text node.

Represents an element that contains only text (e.g. <script>, <style>).

A RenderQueue that schedules tasks using setTimeout(..., 0).

Public namespace exposed as EventHandler from @typed/template.