@microsoft/fast-element 2.0.0-beta.9 → 2.0.0

package/dist/dts/templating/render.d.ts

@@ -1,9 +1,11 @@
 import type { FASTElement } from "../components/fast-element.js";
+import type { DOMPolicy } from "../dom.js";
 import { Constructable } from "../interfaces.js";
+import { Binding, BindingDirective } from "../binding/binding.js";
 import type { Subscriber } from "../observation/notifier.js";
 import type { ExecutionContext, Expression, ExpressionObserver } from "../observation/observable.js";
-import { ContentTemplate, ContentView } from "./binding.js";
-import { AddViewBehaviorFactory, Binding, HTMLDirective, ViewBehavior, ViewBehaviorFactory, ViewController } from "./html-directive.js";
+import type { ContentTemplate, ContentView } from "./html-binding-directive.js";
+import { AddViewBehaviorFactory, HTMLDirective, ViewBehavior, ViewBehaviorFactory, ViewController } from "./html-directive.js";
 import { CaptureType, SyntheticViewTemplate, TemplateValue, ViewTemplate } from "./template.js";
 /**
  * A Behavior that enables advanced rendering.
@@ -35,24 +37,21 @@ export declare class RenderBehavior<TSource = any> implements ViewBehavior, Subs
     unbind(controller: ViewController): void;
     /** @internal */
     handleChange(source: any, observer: ExpressionObserver): void;
+    private bindView;
     private refreshView;
 }
 /**
  * A Directive that enables use of the RenderBehavior.
  * @public
  */
-export declare class RenderDirective<TSource = any> implements HTMLDirective, ViewBehaviorFactory {
+export declare class RenderDirective<TSource = any> implements HTMLDirective, ViewBehaviorFactory, BindingDirective {
     readonly dataBinding: Binding<TSource>;
     readonly templateBinding: Binding<TSource, ContentTemplate>;
     readonly templateBindingDependsOnData: boolean;
-    /**
-     * The unique id of the factory.
-     */
-    id: string;
     /**
      * The structural id of the DOM node to which the created behavior will apply.
      */
-    nodeId: string;
+    targetNodeId: string;
     /**
      * Creates an instance of RenderDirective.
      * @param dataBinding - A binding expression that returns the data to render.
@@ -123,12 +122,41 @@ export declare type TemplateRenderOptions = CommonRenderOptions & {
 export declare type BaseElementRenderOptions<TSource = any, TParent = any> = CommonRenderOptions & {
     /**
      * Attributes to use when creating the element template.
+     * @remarks
+     * This API should be used with caution. When providing attributes, if not done properly,
+     * you can open up the application to XSS attacks. When using this API, provide a strong
+     * DOMPolicy that can properly sanitize and also be sure to manually sanitize attribute
+     * values particularly if they can come from user input.
      */
     attributes?: Record<string, string | TemplateValue<TSource, TParent>>;
     /**
      * Content to use when creating the element template.
+     * @remarks
+     * This API should be used with caution. When providing content, if not done properly,
+     * you can open up the application to XSS attacks. When using this API, provide a strong
+     * DOMPolicy that can properly sanitize and also be sure to manually sanitize content
+     * particularly if it can come from user input. Prefer passing a template
+     * created by the the html tag helper rather than passing a raw string, as that will
+     * enable the JS runtime to help secure the static strings.
      */
     content?: string | SyntheticViewTemplate;
+    /**
+     * The DOMPolicy to create the render instruction with.
+     */
+    policy?: DOMPolicy;
+};
+/**
+ * Render options for directly creating an element with {@link RenderInstruction.createElementTemplate}
+ * @public
+ */
+export declare type ElementCreateOptions<TSource = any, TParent = any> = Omit<BaseElementRenderOptions, "type" | "name"> & {
+    /**
+     * Directives to use when creating the element template. These directives are applied directly to the specified tag.
+     *
+     * @remarks
+     * Directives supported by this API are: `ref`, `children`, `slotted`, or any custom `HTMLDirective` that can be used on a HTML tag.
+     */
+    directives?: TemplateValue<TSource, TParent>[];
 };
 /**
  * Render options used to specify an element.
@@ -150,7 +178,7 @@ export declare type TagNameRenderOptions<TSource = any, TParent = any> = BaseEle
      */
     tagName: string;
 };
-declare function createElementTemplate<TSource = any, TParent = any>(tagName: string, attributes?: Record<string, string | TemplateValue<TSource, TParent>>, content?: string | ContentTemplate): ViewTemplate<TSource, TParent>;
+declare function createElementTemplate<TSource = any, TParent = any>(tagName: string, options?: ElementCreateOptions): ViewTemplate<TSource, TParent>;
 declare function create(options: TagNameRenderOptions): RenderInstruction;
 declare function create(options: ElementConstructorRenderOptions): RenderInstruction;
 declare function create(options: TemplateRenderOptions): RenderInstruction;
@@ -175,6 +203,11 @@ export declare const RenderInstruction: Readonly<{
     /**
      * Creates a RenderInstruction for a set of options.
      * @param options - The options to use when creating the RenderInstruction.
+     * @remarks
+     * This API should be used with caution. When providing attributes or content,
+     * if not done properly, you can open up the application to XSS attacks. When using this API,
+     * provide a strong DOMPolicy that can properly sanitize and also be sure to manually sanitize
+     * content and attribute values particularly if they can come from user input.
      */
     create: typeof create;
     /**
@@ -182,7 +215,13 @@ export declare const RenderInstruction: Readonly<{
      * @param tagName - The tag name to use when creating the template.
      * @param attributes - The attributes to apply to the element.
      * @param content - The content to insert into the element.
+     * @param policy - The DOMPolicy to create the template with.
      * @returns A template based on the provided specifications.
+     * @remarks
+     * This API should be used with caution. When providing attributes or content,
+     * if not done properly, you can open up the application to XSS attacks. When using this API,
+     * provide a strong DOMPolicy that can properly sanitize and also be sure to manually sanitize
+     * content and attribute values particularly if they can come from user input.
      */
     createElementTemplate: typeof createElementTemplate;
     /**
@@ -251,6 +290,7 @@ export declare class NodeTemplate implements ContentTemplate, ContentView {
     insertBefore(refNode: Node): void;
     remove(): void;
     create(): ContentView;
+    hydrate(first: Node, last: Node): ContentView;
 }
 /**
  * Creates a RenderDirective for use in advanced rendering scenarios.

package/dist/dts/templating/repeat-basic-reverse.bench.d.ts

@@ -0,0 +1,3 @@
+declare const itemRenderer: () => HTMLElement;
+export default itemRenderer;
+export { tests } from "@tensile-perf/web-components";

package/dist/dts/templating/repeat-basic-shift.bench.d.ts

@@ -0,0 +1,3 @@
+declare const itemRenderer: () => HTMLElement;
+export default itemRenderer;
+export { tests } from "@tensile-perf/web-components";

package/dist/dts/templating/repeat.d.ts

@@ -1,8 +1,10 @@
+import { Splice } from "../observation/arrays.js";
 import type { Subscriber } from "../observation/notifier.js";
 import { Expression, ExpressionObserver } from "../observation/observable.js";
-import { Splice } from "../observation/arrays.js";
-import { AddViewBehaviorFactory, Binding, HTMLDirective, ViewBehavior, ViewBehaviorFactory, ViewController } from "./html-directive.js";
+import type { Binding, BindingDirective } from "../binding/binding.js";
+import { AddViewBehaviorFactory, HTMLDirective, ViewBehavior, ViewBehaviorFactory, ViewController } from "./html-directive.js";
 import type { CaptureType, SyntheticViewTemplate, ViewTemplate } from "./template.js";
+import { SyntheticView } from "./view.js";
 /**
  * Options for configuring repeat behavior.
  * @public
@@ -17,6 +19,28 @@ export interface RepeatOptions {
      */
     recycle?: boolean;
 }
+export declare class HydrationRepeatError extends Error {
+    readonly propertyBag: {
+        index: number;
+        hydrationStage: string;
+        itemsLength?: number;
+        viewsState: string[];
+        viewTemplateString?: string;
+        rootNodeContent: string;
+    };
+    constructor(
+    /**
+     * The error message
+     */
+    message: string | undefined, propertyBag: {
+        index: number;
+        hydrationStage: string;
+        itemsLength?: number;
+        viewsState: string[];
+        viewTemplateString?: string;
+        rootNodeContent: string;
+    });
+}
 /**
  * A behavior that renders a template for each item in an array.
  * @public
@@ -25,13 +49,14 @@ export declare class RepeatBehavior<TSource = any> implements ViewBehavior, Subs
     private directive;
     private location;
     private controller;
-    private views;
     private template;
     private templateBindingObserver;
     private items;
     private itemsObserver;
     private itemsBindingObserver;
     private bindView;
+    /** @internal */
+    views: SyntheticView[];
     /**
      * Creates an instance of RepeatBehavior.
      * @param location - The location in the DOM to render the repeat.
@@ -61,23 +86,20 @@ export declare class RepeatBehavior<TSource = any> implements ViewBehavior, Subs
     private updateViews;
     private refreshAllViews;
     private unbindAllViews;
+    private hydrateViews;
 }
 /**
  * A directive that configures list rendering.
  * @public
  */
-export declare class RepeatDirective<TSource = any> implements HTMLDirective, ViewBehaviorFactory {
+export declare class RepeatDirective<TSource = any> implements HTMLDirective, ViewBehaviorFactory, BindingDirective {
     readonly dataBinding: Binding<TSource>;
     readonly templateBinding: Binding<TSource, SyntheticViewTemplate>;
     readonly options: RepeatOptions;
-    /**
-     * The unique id of the factory.
-     */
-    id: string;
     /**
      * The structural id of the DOM node to which the created behavior will apply.
      */
-    nodeId: string;
+    targetNodeId: string;
     /**
      * Creates a placeholder string based on the directive's index within the template.
      * @param index - The index of the directive within the template.

package/dist/dts/templating/template.d.ts

@@ -1,5 +1,7 @@
+import type { DOMPolicy } from "../dom.js";
+import { Binding } from "../binding/binding.js";
 import type { Expression } from "../observation/observable.js";
-import { Binding, HTMLDirective, ViewBehaviorFactory } from "./html-directive.js";
+import { AddViewBehaviorFactory, CompiledViewBehaviorFactory, HTMLDirective, ViewBehaviorFactory } from "./html-directive.js";
 import type { ElementView, HTMLView, SyntheticView } from "./view.js";
 /**
  * A template capable of creating views specifically for rendering custom elements.
@@ -20,6 +22,16 @@ export interface ElementViewTemplate<TSource = any, TParent = any> {
      */
     render(source: TSource, host: Node, hostBindingTarget?: Element): ElementView<TSource, TParent>;
 }
+export interface HydratableElementViewTemplate<TSource = any, TParent = any> extends ElementViewTemplate<TSource, TParent> {
+    hydrate(firstChild: Node, lastChild: Node, hostBindingTarget?: Element): ElementView<TSource, TParent>;
+}
+/**
+ * A marker interface used to capture types when interpolating Directive helpers
+ * into templates.
+ * @public
+ */
+export interface CaptureType<TSource, TParent> {
+}
 /**
  * A template capable of rendering views not specifically connected to custom elements.
  * @public
@@ -29,6 +41,13 @@ export interface SyntheticViewTemplate<TSource = any, TParent = any> {
      * Creates a SyntheticView instance based on this template definition.
      */
     create(): SyntheticView<TSource, TParent>;
+    /**
+     * Returns a directive that can inline the template.
+     */
+    inline(): CaptureType<TSource, TParent>;
+}
+export interface HydratableSyntheticViewTemplate<TSource = any, TParent = any> extends SyntheticViewTemplate {
+    hydrate(firstChild: Node, lastChild: Node): SyntheticView<TSource, TParent>;
 }
 /**
  * The result of a template compilation operation.
@@ -40,12 +59,41 @@ export interface HTMLTemplateCompilationResult<TSource = any, TParent = any> {
      * @param hostBindingTarget - The host binding target for the view.
      */
     createView(hostBindingTarget?: Element): HTMLView<TSource, TParent>;
+    readonly factories: CompiledViewBehaviorFactory[];
+}
+/**
+ * Represents the types of values that can be interpolated into a template.
+ * @public
+ */
+export declare type TemplateValue<TSource, TParent = any> = Expression<TSource, any, TParent> | Binding<TSource, any, TParent> | HTMLDirective | CaptureType<TSource, TParent>;
+/**
+ * Inlines a template into another template.
+ * @public
+ */
+export declare class InlineTemplateDirective implements HTMLDirective {
+    private html;
+    private factories;
+    /**
+     * An empty template partial.
+     */
+    static readonly empty: InlineTemplateDirective;
+    /**
+     * Creates an instance of InlineTemplateDirective.
+     * @param template - The template to inline.
+     */
+    constructor(html: string, factories?: Record<string, ViewBehaviorFactory>);
+    /**
+     * Creates HTML to be used within a template.
+     * @param add - Can be used to add  behavior factories to a template.
+     */
+    createHTML(add: AddViewBehaviorFactory): string;
 }
 /**
  * A template capable of creating HTMLView instances or rendering directly to DOM.
  * @public
  */
 export declare class ViewTemplate<TSource = any, TParent = any> implements ElementViewTemplate<TSource, TParent>, SyntheticViewTemplate<TSource, TParent> {
+    private policy?;
     private result;
     /**
      * The html representing what this template will
@@ -60,13 +108,31 @@ export declare class ViewTemplate<TSource = any, TParent = any> implements Eleme
      * Creates an instance of ViewTemplate.
      * @param html - The html representing what this template will instantiate, including placeholders for directives.
      * @param factories - The directives that will be connected to placeholders in the html.
+     * @param policy - The security policy to use when compiling this template.
      */
-    constructor(html: string | HTMLTemplateElement, factories: Record<string, ViewBehaviorFactory>);
+    constructor(html: string | HTMLTemplateElement, factories?: Record<string, ViewBehaviorFactory>, policy?: DOMPolicy | undefined);
+    /**
+     * @internal
+     */
+    compile(): HTMLTemplateCompilationResult<TSource, TParent>;
     /**
      * Creates an HTMLView instance based on this template definition.
      * @param hostBindingTarget - The element that host behaviors will be bound to.
      */
     create(hostBindingTarget?: Element): HTMLView<TSource, TParent>;
+    /**
+     * Returns a directive that can inline the template.
+     */
+    inline(): CaptureType<TSource, TParent>;
+    /**
+     * Sets the DOMPolicy for this template.
+     * @param policy - The policy to associated with this template.
+     * @returns The modified template instance.
+     * @remarks
+     * The DOMPolicy can only be set once for a template and cannot be
+     * set after the template is compiled.
+     */
+    withPolicy(policy: DOMPolicy): this;
     /**
      * Creates an HTMLView from this template, binds it to the source, and then appends it to the host.
      * @param source - The data source to bind the template to.
@@ -75,19 +141,38 @@ export declare class ViewTemplate<TSource = any, TParent = any> implements Eleme
      * host that the template is being attached to.
      */
     render(source: TSource, host: Node, hostBindingTarget?: Element): HTMLView<TSource, TParent>;
+    /**
+     * Creates a template based on a set of static strings and dynamic values.
+     * @param strings - The static strings to create the template with.
+     * @param values - The dynamic values to create the template with.
+     * @param policy - The DOMPolicy to associated with the template.
+     * @returns A ViewTemplate.
+     * @remarks
+     * This API should not be used directly under normal circumstances because constructing
+     * a template in this way, if not done properly, can open up the application to XSS
+     * attacks. When using this API, provide a strong DOMPolicy that can properly sanitize
+     * and also be sure to manually sanitize all static strings particularly if they can
+     * come from user input.
+     */
+    static create<TSource = any, TParent = any>(strings: string[], values: TemplateValue<TSource, TParent>[], policy?: DOMPolicy): ViewTemplate<TSource, TParent>;
 }
 /**
- * A marker interface used to capture types when interpolating Directive helpers
- * into templates.
- * @public
- */
-export interface CaptureType<TSource, TParent> {
-}
-/**
- * Represents the types of values that can be interpolated into a template.
+ * Transforms a template literal string into a ViewTemplate.
+ * @param strings - The string fragments that are interpolated with the values.
+ * @param values - The values that are interpolated with the string fragments.
+ * @remarks
+ * The html helper supports interpolation of strings, numbers, binding expressions,
+ * other template instances, and Directive instances.
  * @public
  */
-export declare type TemplateValue<TSource, TParent = any> = Expression<TSource, any, TParent> | Binding<TSource, any, TParent> | HTMLDirective | CaptureType<TSource, TParent>;
+export declare type HTMLTemplateTag = (<TSource = any, TParent = any>(strings: TemplateStringsArray, ...values: TemplateValue<TSource, TParent>[]) => ViewTemplate<TSource, TParent>) & {
+    /**
+     * Transforms a template literal string into partial HTML.
+     * @param html - The HTML string fragment to interpolate.
+     * @public
+     */
+    partial(html: string): InlineTemplateDirective;
+};
 /**
  * Transforms a template literal string into a ViewTemplate.
  * @param strings - The string fragments that are interpolated with the values.
@@ -97,4 +182,4 @@ export declare type TemplateValue<TSource, TParent = any> = Expression<TSource,
  * other template instances, and Directive instances.
  * @public
  */
-export declare function html<TSource = any, TParent = any>(strings: TemplateStringsArray, ...values: TemplateValue<TSource, TParent>[]): ViewTemplate<TSource, TParent>;
+export declare const html: HTMLTemplateTag;

package/dist/dts/templating/view.d.ts

@@ -1,6 +1,9 @@
+import { Hydratable } from "../components/hydration.js";
+import { ViewBehaviorBoundaries } from "../hydration/target-builder.js";
+import type { ViewTemplate } from "../templating/template.js";
 import type { Disposable } from "../interfaces.js";
 import { ExecutionContext, SourceLifetime } from "../observation/observable.js";
-import type { ViewBehaviorFactory, ViewBehaviorTargets, ViewController } from "./html-directive.js";
+import type { CompiledViewBehaviorFactory, ViewBehaviorFactory, ViewBehaviorTargets, ViewController } from "./html-directive.js";
 /**
  * Represents a collection of DOM nodes which can be bound to a data source.
  * @public
@@ -14,6 +17,10 @@ export interface View<TSource = any, TParent = any> extends Disposable {
      * The data that the view is bound to.
      */
     readonly source: TSource | null;
+    /**
+     * Indicates whether the controller is bound.
+     */
+    readonly isBound: boolean;
     /**
      * Binds a view's behaviors to its binding source.
      * @param source - The binding source for the view's binding behaviors.
@@ -29,6 +36,17 @@ export interface View<TSource = any, TParent = any> extends Disposable {
  * @public
  */
 export interface ElementView<TSource = any, TParent = any> extends View<TSource, TParent> {
+    /**
+     * Indicates how the source's lifetime relates to the controller's lifetime.
+     */
+    readonly sourceLifetime?: SourceLifetime;
+    /**
+     * Registers an unbind handler with the controller.
+     * @param behavior - An object to call when the controller unbinds.
+     */
+    onUnbind(behavior: {
+        unbind(controller: ViewController<TSource, TParent>): any;
+    }): void;
     /**
      * Appends the view's DOM nodes to the referenced node.
      * @param node - The parent node to append the view's DOM nodes to.
@@ -59,32 +77,7 @@ export interface SyntheticView<TSource = any, TParent = any> extends View<TSourc
      */
     remove(): void;
 }
-/**
- * The standard View implementation, which also implements ElementView and SyntheticView.
- * @public
- */
-export declare class HTMLView<TSource = any, TParent = any> implements ElementView<TSource, TParent>, SyntheticView<TSource, TParent>, ExecutionContext<TParent> {
-    private fragment;
-    private factories;
-    readonly targets: ViewBehaviorTargets;
-    private behaviors;
-    private unbindables;
-    /**
-     * The data that the view is bound to.
-     */
-    source: TSource | null;
-    /**
-     * Indicates whether the controller is bound.
-     */
-    isBound: boolean;
-    /**
-     * Indicates how the source's lifetime relates to the controller's lifetime.
-     */
-    readonly sourceLifetime: SourceLifetime;
-    /**
-     * The execution context the view is running within.
-     */
-    context: ExecutionContext<TParent>;
+declare class DefaultExecutionContext<TParent> implements ExecutionContext<TParent> {
     /**
      * The index of the current item within a repeat context.
      */
@@ -138,6 +131,33 @@ export declare class HTMLView<TSource = any, TParent = any> implements ElementVi
      * Returns the typed event target of the event.
      */
     eventTarget<TTarget extends EventTarget>(): TTarget;
+}
+/**
+ * The standard View implementation, which also implements ElementView and SyntheticView.
+ * @public
+ */
+export declare class HTMLView<TSource = any, TParent = any> extends DefaultExecutionContext<TParent> implements ElementView<TSource, TParent>, SyntheticView<TSource, TParent>, ExecutionContext<TParent> {
+    private fragment;
+    private factories;
+    readonly targets: ViewBehaviorTargets;
+    private behaviors;
+    private unbindables;
+    /**
+     * The data that the view is bound to.
+     */
+    source: TSource | null;
+    /**
+     * Indicates whether the controller is bound.
+     */
+    isBound: boolean;
+    /**
+     * Indicates how the source's lifetime relates to the controller's lifetime.
+     */
+    readonly sourceLifetime: SourceLifetime;
+    /**
+     * The execution context the view is running within.
+     */
+    context: ExecutionContext<TParent>;
     /**
      * The first DOM node in the range of nodes that make up the view.
      */
@@ -151,7 +171,7 @@ export declare class HTMLView<TSource = any, TParent = any> implements ElementVi
      * @param fragment - The html fragment that contains the nodes for this view.
      * @param behaviors - The behaviors to be applied to this view.
      */
-    constructor(fragment: DocumentFragment, factories: ReadonlyArray<ViewBehaviorFactory>, targets: ViewBehaviorTargets);
+    constructor(fragment: DocumentFragment, factories: ReadonlyArray<CompiledViewBehaviorFactory>, targets: ViewBehaviorTargets);
     /**
      * Appends the view's DOM nodes to the referenced node.
      * @param node - The parent node to append the view's DOM nodes to.
@@ -173,7 +193,7 @@ export declare class HTMLView<TSource = any, TParent = any> implements ElementVi
      */
     dispose(): void;
     onUnbind(behavior: {
-        unbind(controller: ViewController<TSource, TParent>): any;
+        unbind(controller: ViewController<TSource, TParent>): void;
     }): void;
     /**
      * Binds a view's behaviors to its binding source.
@@ -192,3 +212,100 @@ export declare class HTMLView<TSource = any, TParent = any> implements ElementVi
      */
     static disposeContiguousBatch(views: SyntheticView[]): void;
 }
+/** @public */
+export interface HydratableView<TSource = any, TParent = any> extends ElementView, SyntheticView, DefaultExecutionContext<TParent> {
+    [Hydratable]: symbol;
+    readonly bindingViewBoundaries: Record<string, ViewNodes>;
+    readonly hydrationStage: keyof typeof HydrationStage;
+}
+export interface ViewNodes {
+    first: Node;
+    last: Node;
+}
+export declare const HydrationStage: {
+    readonly unhydrated: "unhydrated";
+    readonly hydrating: "hydrating";
+    readonly hydrated: "hydrated";
+};
+/** @public */
+export declare class HydrationBindingError extends Error {
+    /**
+     * The factory that was unable to be bound
+     */
+    readonly factory: ViewBehaviorFactory;
+    /**
+     * A DocumentFragment containing a clone of the
+     * view's Nodes.
+     */
+    readonly fragment: DocumentFragment;
+    /**
+     * String representation of the HTML in the template that
+     * threw the binding error.
+     */
+    readonly templateString: string;
+    constructor(
+    /**
+     * The error message
+     */
+    message: string | undefined, 
+    /**
+     * The factory that was unable to be bound
+     */
+    factory: ViewBehaviorFactory, 
+    /**
+     * A DocumentFragment containing a clone of the
+     * view's Nodes.
+     */
+    fragment: DocumentFragment, 
+    /**
+     * String representation of the HTML in the template that
+     * threw the binding error.
+     */
+    templateString: string);
+}
+export declare class HydrationView<TSource = any, TParent = any> extends DefaultExecutionContext<TParent> implements HydratableView {
+    readonly firstChild: Node;
+    readonly lastChild: Node;
+    private sourceTemplate;
+    private hostBindingTarget?;
+    [Hydratable]: symbol;
+    context: ExecutionContext<any>;
+    source: TSource | null;
+    isBound: boolean;
+    get hydrationStage(): "unhydrated" | "hydrating" | "hydrated";
+    get targets(): ViewBehaviorTargets;
+    get bindingViewBoundaries(): ViewBehaviorBoundaries;
+    readonly sourceLifetime: SourceLifetime;
+    private unbindables;
+    private fragment;
+    private behaviors;
+    private factories;
+    private _hydrationStage;
+    private _bindingViewBoundaries;
+    private _targets;
+    constructor(firstChild: Node, lastChild: Node, sourceTemplate: ViewTemplate, hostBindingTarget?: Element | undefined);
+    /**
+     * no-op. Hydrated views are don't need to be moved from a documentFragment
+     * to the target node.
+     */
+    insertBefore(node: Node): void;
+    /**
+     * Appends the view to a node. In cases where this is called before the
+     * view has been removed, the method will no-op.
+     * @param node - the node to append the view to.
+     */
+    appendTo(node: Node): void;
+    remove(): void;
+    bind(source: TSource, context?: ExecutionContext<any>): void;
+    unbind(): void;
+    /**
+     * Removes the view and unbinds its behaviors, disposing of DOM nodes afterward.
+     * Once a view has been disposed, it cannot be inserted or bound again.
+     */
+    dispose(): void;
+    onUnbind(behavior: {
+        unbind(controller: ViewController<TSource, TParent>): void;
+    }): void;
+    private evaluateUnbindables;
+}
+export {};

package/dist/dts/templating/when-basic.bench.d.ts

@@ -0,0 +1,3 @@
+declare const itemRenderer: () => HTMLElement;
+export default itemRenderer;
+export { tests } from "@tensile-perf/web-components";

package/dist/dts/templating/when-conditional.bench.d.ts

@@ -0,0 +1,3 @@
+declare const itemRenderer: () => HTMLElement;
+export default itemRenderer;
+export { tests } from "@tensile-perf/web-components";

package/dist/dts/templating/when-switch.bench.d.ts

@@ -0,0 +1,3 @@
+declare const itemRenderer: () => HTMLElement;
+export default itemRenderer;
+export { tests } from "@tensile-perf/web-components";

package/dist/dts/templating/when.d.ts

@@ -5,6 +5,8 @@ import type { CaptureType, SyntheticViewTemplate } from "./template.js";
  * @param condition - The condition to test for rendering.
  * @param templateOrTemplateBinding - The template or a binding that gets
  * the template to render when the condition is true.
+ * @param elseTemplateOrTemplateBinding - Optional template or binding that that
+ * gets the template to render when the conditional is false.
  * @public
  */
-export declare function when<TSource = any, TReturn = any, TParent = any>(condition: Expression<TSource, TReturn, TParent> | boolean, templateOrTemplateBinding: SyntheticViewTemplate<TSource, TParent> | Expression<TSource, SyntheticViewTemplate<TSource, TParent>, TParent>): CaptureType<TSource, TParent>;
+export declare function when<TSource = any, TReturn = any, TParent = any>(condition: Expression<TSource, TReturn, TParent> | boolean, templateOrTemplateBinding: SyntheticViewTemplate<TSource, TParent> | Expression<TSource, SyntheticViewTemplate<TSource, TParent>, TParent>, elseTemplateOrTemplateBinding?: SyntheticViewTemplate<TSource, TParent> | Expression<TSource, SyntheticViewTemplate<TSource, TParent>, TParent>): CaptureType<TSource, TParent>;

package/dist/dts/testing/fakes.d.ts

@@ -1,4 +1,15 @@
-import { ExecutionContext } from "../index.js";
+import { ExecutionContext } from "../observation/observable.js";
+import type { ViewBehavior, ViewBehaviorTargets } from "../templating/html-directive.js";
 export declare const Fake: Readonly<{
     executionContext<TParent = any>(parent?: TParent | undefined, parentContext?: ExecutionContext<TParent> | undefined): ExecutionContext<TParent>;
+    viewController<TSource = any, TParent_1 = any>(targets?: ViewBehaviorTargets, ...behaviors: ViewBehavior<TSource, TParent_1>[]): {
+        isBound: boolean;
+        context: ExecutionContext<TParent_1>;
+        onUnbind(object: any): void;
+        source: TSource;
+        targets: ViewBehaviorTargets;
+        toJSON: () => undefined;
+        bind(source: TSource, context?: ExecutionContext<TParent_1>): void;
+        unbind(): void;
+    };
 }>;

package/dist/dts/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.24.2"
+      "packageVersion": "7.47.0"
     }
   ]
 }