@microsoft/fast-element 2.0.0-beta.1 → 2.0.0-beta.4

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

@@ -0,0 +1,277 @@
+import type { FASTElement } from "../components/fast-element.js";
+import { Constructable } from "../interfaces.js";
+import type { Behavior } from "../observation/behavior.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, ViewBehaviorFactory, ViewBehaviorTargets } from "./html-directive.js";
+import { CaptureType, SyntheticViewTemplate, TemplateValue, ViewTemplate } from "./template.js";
+/**
+ * A Behavior that enables advanced rendering.
+ * @public
+ */
+export declare class RenderBehavior<TSource = any, TParent = any> implements Behavior, Subscriber {
+    private directive;
+    private location;
+    private source;
+    private view;
+    private template;
+    private templateBindingObserver;
+    private data;
+    private dataBindingObserver;
+    private originalContext;
+    private childContext;
+    /**
+     * Creates an instance of RenderBehavior.
+     * @param location - A Node representing the location where this behavior will render.
+     * @param dataBinding - A binding expression that returns the data to render.
+     * @param templateBinding - A binding expression that returns the template to use with the data.
+     */
+    constructor(directive: RenderDirective, location: Node);
+    /**
+     * Bind this behavior to the source.
+     * @param source - The source to bind to.
+     * @param context - The execution context that the binding is operating within.
+     */
+    bind(source: TSource, context: ExecutionContext): void;
+    /**
+     * Unbinds this behavior from the source.
+     * @param source - The source to unbind from.
+     */
+    unbind(source: TSource, context: ExecutionContext<TParent>): void;
+    /** @internal */
+    handleChange(source: any, observer: ExpressionObserver): void;
+    private refreshView;
+}
+/**
+ * A Directive that enables use of the RenderBehavior.
+ * @public
+ */
+export declare class RenderDirective<TSource = any> implements HTMLDirective, ViewBehaviorFactory {
+    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;
+    /**
+     * Creates an instance of RenderDirective.
+     * @param dataBinding - A binding expression that returns the data to render.
+     * @param templateBinding - A binding expression that returns the template to use to render the data.
+     */
+    constructor(dataBinding: Binding<TSource>, templateBinding: Binding<TSource, ContentTemplate>, templateBindingDependsOnData: boolean);
+    /**
+     * Creates HTML to be used within a template.
+     * @param add - Can be used to add  behavior factories to a template.
+     */
+    createHTML(add: AddViewBehaviorFactory): string;
+    /**
+     * Creates a behavior.
+     * @param targets - The targets available for behaviors to be attached to.
+     */
+    createBehavior(targets: ViewBehaviorTargets): RenderBehavior<TSource>;
+}
+/**
+ * Provides instructions for how to render a type.
+ * @public
+ */
+export interface RenderInstruction {
+    /**
+     * Identifies this as a RenderInstruction.
+     */
+    brand: symbol;
+    /**
+     * The type this instruction is associated with.
+     */
+    type: Constructable;
+    /**
+     * The template to use when rendering.
+     */
+    template: ContentTemplate;
+    /**
+     * A name that can be used to identify the instruction.
+     */
+    name: string;
+}
+/**
+ * Render options that are common to all configurations.
+ * @public
+ */
+export declare type CommonRenderOptions = {
+    /**
+     * The type this instruction is associated with.
+     */
+    type: Constructable;
+    /**
+     * A name that can be used to identify the instruction.
+     */
+    name?: string;
+};
+/**
+ * Render options used to specify a template.
+ * @public
+ */
+export declare type TemplateRenderOptions = CommonRenderOptions & {
+    /**
+     * The template to use when rendering.
+     */
+    template: ContentTemplate;
+};
+/**
+ * Render options that are common to all element render instructions.
+ * @public
+ */
+export declare type BaseElementRenderOptions<TSource = any, TParent = any> = CommonRenderOptions & {
+    /**
+     * Attributes to use when creating the element template.
+     */
+    attributes?: Record<string, string | TemplateValue<TSource, TParent>>;
+    /**
+     * Content to use when creating the element template.
+     */
+    content?: string | SyntheticViewTemplate;
+};
+/**
+ * Render options used to specify an element.
+ * @public
+ */
+export declare type ElementConstructorRenderOptions<TSource = any, TParent = any> = BaseElementRenderOptions<TSource, TParent> & {
+    /**
+     * The element to use when rendering.
+     */
+    element: Constructable<FASTElement>;
+};
+/**
+ * Render options use to specify an element by tag name.
+ * @public
+ */
+export declare type TagNameRenderOptions<TSource = any, TParent = any> = BaseElementRenderOptions<TSource, TParent> & {
+    /**
+     * The tag name to use when rendering.
+     */
+    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 create(options: TagNameRenderOptions): RenderInstruction;
+declare function create(options: ElementConstructorRenderOptions): RenderInstruction;
+declare function create(options: TemplateRenderOptions): RenderInstruction;
+declare function instanceOf(object: any): object is RenderInstruction;
+declare function register(options: TagNameRenderOptions): RenderInstruction;
+declare function register(options: ElementConstructorRenderOptions): RenderInstruction;
+declare function register(options: TemplateRenderOptions): RenderInstruction;
+declare function register(instruction: RenderInstruction): RenderInstruction;
+declare function getByType(type: Constructable, name?: string): RenderInstruction | undefined;
+declare function getForInstance(object: any, name?: string): RenderInstruction | undefined;
+/**
+ * Provides APIs for creating and interacting with render instructions.
+ * @public
+ */
+export declare const RenderInstruction: Readonly<{
+    /**
+     * Checks whether the provided object is a RenderInstruction.
+     * @param object - The object to check.
+     * @returns true if the object is a RenderInstruction; false otherwise
+     */
+    instanceOf: typeof instanceOf;
+    /**
+     * Creates a RenderInstruction for a set of options.
+     * @param options - The options to use when creating the RenderInstruction.
+     */
+    create: typeof create;
+    /**
+     * Creates a template based on a tag name.
+     * @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.
+     * @returns A template based on the provided specifications.
+     */
+    createElementTemplate: typeof createElementTemplate;
+    /**
+     * Creates and registers an instruction.
+     * @param options The options to use when creating the RenderInstruction.
+     * @remarks
+     * A previously created RenderInstruction can also be registered.
+     */
+    register: typeof register;
+    /**
+     * Finds a previously registered RenderInstruction by type and optionally by name.
+     * @param type - The type to retrieve the RenderInstruction for.
+     * @param name - An optional name used in differentiating between multiple registered instructions.
+     * @returns The located RenderInstruction that matches the criteria or undefined if none is found.
+     */
+    getByType: typeof getByType;
+    /**
+     * Finds a previously registered RenderInstruction for the instance's type and optionally by name.
+     * @param object - The instance to retrieve the RenderInstruction for.
+     * @param name - An optional name used in differentiating between multiple registered instructions.
+     * @returns The located RenderInstruction that matches the criteria or undefined if none is found.
+     */
+    getForInstance: typeof getForInstance;
+}>;
+/**
+ * Decorates a type with render instruction metadata.
+ * @param options - The options used in creating the RenderInstruction.
+ * @public
+ */
+export declare function renderWith(options: Omit<TagNameRenderOptions, "type">): ClassDecorator;
+/**
+ * Decorates a type with render instruction metadata.
+ * @param options - The options used in creating the RenderInstruction.
+ * @public
+ */
+export declare function renderWith(options: Omit<ElementConstructorRenderOptions, "type">): ClassDecorator;
+/**
+ * Decorates a type with render instruction metadata.
+ * @param options - The options used in creating the RenderInstruction.
+ * @public
+ */
+export declare function renderWith(options: Omit<TemplateRenderOptions, "type">): ClassDecorator;
+/**
+ * Decorates a type with render instruction metadata.
+ * @param element - The element to use to render the decorated class.
+ * @param name - An optional name to differentiate the render instruction.
+ * @public
+ */
+export declare function renderWith(element: Constructable<FASTElement>, name?: string): ClassDecorator;
+/**
+ * Decorates a type with render instruction metadata.
+ * @param template - The template to use to render the decorated class.
+ * @param name - An optional name to differentiate the render instruction.
+ * @public
+ */
+export declare function renderWith(template: ContentTemplate, name?: string): ClassDecorator;
+/**
+ * @internal
+ */
+export declare class NodeTemplate implements ContentTemplate, ContentView {
+    readonly node: Node;
+    constructor(node: Node);
+    bind(source: any, context: ExecutionContext<any>): void;
+    unbind(): void;
+    insertBefore(refNode: Node): void;
+    remove(): void;
+    create(): ContentView;
+}
+/**
+ * Creates a RenderDirective for use in advanced rendering scenarios.
+ * @param value - The binding expression that returns the data to be rendered. The expression
+ * can also return a Node to render directly.
+ * @param template - A template to render the data with
+ * or a string to indicate which RenderInstruction to use when looking up a RenderInstruction.
+ * Expressions can also be provided to dynamically determine either the template or the name.
+ * @returns A RenderDirective suitable for use in a template.
+ * @remarks
+ * If no binding is provided, then a default binding that returns the source is created.
+ * If no template is provided, then a binding is created that will use registered
+ * RenderInstructions to determine the view.
+ * If the template binding returns a string, then it will be used to look up a
+ * RenderInstruction to determine the view.
+ * @public
+ */
+export declare function render<TSource = any, TItem = any>(value?: Expression<TSource, TItem> | Binding<TSource, TItem> | {}, template?: ContentTemplate | string | Expression<TSource, ContentTemplate | string | Node> | Binding<TSource, ContentTemplate | string | Node>): CaptureType<TSource>;
+export {};

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

@@ -1,9 +1,9 @@
 import type { Behavior } from "../observation/behavior.js";
 import type { Subscriber } from "../observation/notifier.js";
-import { Binding, ChildContext, ExecutionContext, ItemContext, RootContext } from "../observation/observable.js";
+import { ExecutionContext, Expression, ExpressionObserver } from "../observation/observable.js";
 import { Splice } from "../observation/arrays.js";
-import { AddViewBehaviorFactory, HTMLDirective, ViewBehaviorFactory, ViewBehaviorTargets } from "./html-directive.js";
-import type { CaptureType, ChildViewTemplate, ItemViewTemplate, SyntheticViewTemplate, ViewTemplate } from "./template.js";
+import { AddViewBehaviorFactory, Binding, HTMLDirective, ViewBehaviorFactory, ViewBehaviorTargets } from "./html-directive.js";
+import type { CaptureType, SyntheticViewTemplate, ViewTemplate } from "./template.js";
 /**
  * Options for configuring repeat behavior.
  * @public
@@ -23,10 +23,8 @@ export interface RepeatOptions {
  * @public
  */
 export declare class RepeatBehavior<TSource = any> implements Behavior, Subscriber {
+    private directive;
     private location;
-    private itemsBinding;
-    private templateBinding;
-    private options;
     private source;
     private views;
     private template;
@@ -40,13 +38,13 @@ export declare class RepeatBehavior<TSource = any> implements Behavior, Subscrib
     /**
      * Creates an instance of RepeatBehavior.
      * @param location - The location in the DOM to render the repeat.
-     * @param itemsBinding - The array to render.
+     * @param dataBinding - The array to render.
      * @param isItemsBindingVolatile - Indicates whether the items binding has volatile dependencies.
      * @param templateBinding - The template to render for each item.
      * @param isTemplateBindingVolatile - Indicates whether the template binding has volatile dependencies.
      * @param options - Options used to turn on special repeat features.
      */
-    constructor(location: Node, itemsBinding: Binding<TSource, any[]>, isItemsBindingVolatile: boolean, templateBinding: Binding<TSource, SyntheticViewTemplate>, isTemplateBindingVolatile: boolean, options: RepeatOptions);
+    constructor(directive: RepeatDirective, location: Node);
     /**
      * Bind this behavior to the source.
      * @param source - The source to bind to.
@@ -63,7 +61,7 @@ export declare class RepeatBehavior<TSource = any> implements Behavior, Subscrib
      * @param source - The source of the change.
      * @param args - The details about what was changed.
      */
-    handleChange(source: any, args: Splice[]): void;
+    handleChange(source: any, args: Splice[] | ExpressionObserver): void;
     private observeItems;
     private updateViews;
     private refreshAllViews;
@@ -74,11 +72,9 @@ export declare class RepeatBehavior<TSource = any> implements Behavior, Subscrib
  * @public
  */
 export declare class RepeatDirective<TSource = any> implements HTMLDirective, ViewBehaviorFactory {
-    readonly itemsBinding: Binding;
+    readonly dataBinding: Binding<TSource>;
     readonly templateBinding: Binding<TSource, SyntheticViewTemplate>;
     readonly options: RepeatOptions;
-    private isItemsBindingVolatile;
-    private isTemplateBindingVolatile;
     /**
      * The unique id of the factory.
      */
@@ -94,11 +90,11 @@ export declare class RepeatDirective<TSource = any> implements HTMLDirective, Vi
     createHTML(add: AddViewBehaviorFactory): string;
     /**
      * Creates an instance of RepeatDirective.
-     * @param itemsBinding - The binding that provides the array to render.
+     * @param dataBinding - The binding that provides the array to render.
      * @param templateBinding - The template binding used to obtain a template to render for each item in the array.
      * @param options - Options used to turn on special repeat features.
      */
-    constructor(itemsBinding: Binding, templateBinding: Binding<TSource, SyntheticViewTemplate>, options: RepeatOptions);
+    constructor(dataBinding: Binding<TSource>, templateBinding: Binding<TSource, SyntheticViewTemplate>, options: RepeatOptions);
     /**
      * Creates a behavior for the provided target node.
      * @param target - The node instance to create the behavior for.
@@ -107,56 +103,10 @@ export declare class RepeatDirective<TSource = any> implements HTMLDirective, Vi
 }
 /**
  * A directive that enables list rendering.
- * @param itemsBinding - The array to render.
- * @param templateOrTemplateBinding - The template or a template binding used obtain a template
+ * @param items - The array to render.
+ * @param template - The template or a template binding used obtain a template
  * to render for each item in the array.
  * @param options - Options used to turn on special repeat features.
  * @public
  */
-export declare function repeat<TSource = any, TArray extends ReadonlyArray<any> = ReadonlyArray<any>>(itemsBinding: Binding<TSource, TArray, ExecutionContext<TSource>>, templateOrTemplateBinding: ViewTemplate | Binding<TSource, ViewTemplate, RootContext>, options?: {
-    positioning: false;
-} | {
-    recycle: true;
-} | {
-    positioning: false;
-    recycle: false;
-} | {
-    positioning: false;
-    recycle: true;
-}): CaptureType<TSource>;
-/**
- * A directive that enables list rendering.
- * @param itemsBinding - The array to render.
- * @param templateOrTemplateBinding - The template or a template binding used obtain a template
- * to render for each item in the array.
- * @param options - Options used to turn on special repeat features.
- * @public
- */
-export declare function repeat<TSource = any, TArray extends ReadonlyArray<any> = ReadonlyArray<any>>(itemsBinding: Binding<TSource, TArray, ExecutionContext<TSource>>, templateOrTemplateBinding: ChildViewTemplate | Binding<TSource, ChildViewTemplate, ChildContext>, options?: {
-    positioning: false;
-} | {
-    recycle: true;
-} | {
-    positioning: false;
-    recycle: false;
-} | {
-    positioning: false;
-    recycle: true;
-}): CaptureType<TSource>;
-/**
- * A directive that enables list rendering.
- * @param itemsBinding - The array to render.
- * @param templateOrTemplateBinding - The template or a template binding used obtain a template
- * to render for each item in the array.
- * @param options - Options used to turn on special repeat features.
- * @public
- */
-export declare function repeat<TSource = any, TArray extends ReadonlyArray<any> = ReadonlyArray<any>>(itemsBinding: Binding<TSource, TArray, ExecutionContext<TSource>>, templateOrTemplateBinding: ItemViewTemplate | Binding<TSource, ItemViewTemplate, ItemContext>, options: {
-    positioning: true;
-} | {
-    positioning: true;
-    recycle: true;
-} | {
-    positioning: true;
-    recycle: false;
-}): CaptureType<TSource>;
+export declare function repeat<TSource = any, TArray extends ReadonlyArray<any> = ReadonlyArray<any>>(items: Expression<TSource, TArray, ExecutionContext<TSource>> | Binding<TSource, TArray> | ReadonlyArray<any>, template: Expression<TSource, ViewTemplate> | Binding<TSource, ViewTemplate> | ViewTemplate, options?: RepeatOptions): CaptureType<TSource>;

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

@@ -1,12 +1,11 @@
-import { Binding, ChildContext, ExecutionContext, ItemContext } from "../observation/observable.js";
-import { HTMLDirective, ViewBehaviorFactory } from "./html-directive.js";
+import { ExecutionContext, Expression } from "../observation/observable.js";
+import { Binding, 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.
  * @public
  */
 export interface ElementViewTemplate<TSource = any, TParent = any> {
-    type: "element";
     /**
      * Creates an ElementView instance based on this template definition.
      * @param hostBindingTarget - The element that host behaviors will be bound to.
@@ -25,57 +24,29 @@ export interface ElementViewTemplate<TSource = any, TParent = any> {
  * A template capable of rendering views not specifically connected to custom elements.
  * @public
  */
-export interface SyntheticViewTemplate<TSource = any, TParent = any, TContext extends ExecutionContext<TParent> = ExecutionContext<TParent>> {
-    type: "synthetic";
+export interface SyntheticViewTemplate<TSource = any, TParent = any> {
     /**
      * Creates a SyntheticView instance based on this template definition.
      */
-    create(): SyntheticView<TSource, TParent, TContext>;
-}
-/**
- * A template capable of rendering child views not specifically connected to custom elements.
- * @public
- */
-export interface ChildViewTemplate<TSource = any, TParent = any> {
-    type: "child";
-    /**
-     * Creates a SyntheticView instance based on this template definition.
-     */
-    create(): SyntheticView<TSource, TParent, ChildContext<TParent>>;
-}
-/**
- * A template capable of rendering item views not specifically connected to custom elements.
- * @public
- */
-export interface ItemViewTemplate<TSource = any, TParent = any> {
-    type: "item";
-    /**
-     * Creates a SyntheticView instance based on this template definition.
-     */
-    create(): SyntheticView<TSource, TParent, ItemContext<TParent>>;
+    create(): SyntheticView<TSource, TParent>;
 }
 /**
  * The result of a template compilation operation.
  * @public
  */
-export interface HTMLTemplateCompilationResult<TSource = any, TParent = any, TContext extends ExecutionContext<TParent> = ExecutionContext<TParent>> {
+export interface HTMLTemplateCompilationResult<TSource = any, TParent = any> {
     /**
      * Creates a view instance.
      * @param hostBindingTarget - The host binding target for the view.
      */
-    createView(hostBindingTarget?: Element): HTMLView<TSource, TParent, TContext>;
+    createView(hostBindingTarget?: Element): HTMLView<TSource, TParent>;
 }
 /**
  * A template capable of creating HTMLView instances or rendering directly to DOM.
  * @public
  */
-export declare class ViewTemplate<TSource = any, TParent = any, TContext extends ExecutionContext<TParent> = ExecutionContext> implements ElementViewTemplate<TSource, TParent>, SyntheticViewTemplate<TSource, TParent, TContext> {
+export declare class ViewTemplate<TSource = any, TParent = any> implements ElementViewTemplate<TSource, TParent>, SyntheticViewTemplate<TSource, TParent> {
     private result;
-    /**
-     * Used for TypeScript purposes only.
-     * Do not use.
-     */
-    type: any;
     /**
      * The html representing what this template will
      * instantiate, including placeholders for directives.
@@ -95,7 +66,7 @@ export declare class ViewTemplate<TSource = any, TParent = any, TContext extends
      * 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, TContext>;
+    create(hostBindingTarget?: Element): HTMLView<TSource, TParent>;
     /**
      * 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.
@@ -103,7 +74,7 @@ export declare class ViewTemplate<TSource = any, TParent = any, TContext extends
      * @param hostBindingTarget - An HTML element to target the host bindings at if different from the
      * host that the template is being attached to.
      */
-    render(source: TSource, host: Node, hostBindingTarget?: Element, context?: TContext): HTMLView<TSource, TParent, TContext>;
+    render(source: TSource, host: Node, hostBindingTarget?: Element, context?: ExecutionContext): HTMLView<TSource, TParent>;
 }
 /**
  * A marker interface used to capture types when interpolating Directive helpers
@@ -116,7 +87,7 @@ export interface CaptureType<TSource> {
  * Represents the types of values that can be interpolated into a template.
  * @public
  */
-export declare type TemplateValue<TSource, TParent = any, TContext extends ExecutionContext<TParent> = ExecutionContext<TParent>> = Binding<TSource, any, TContext> | HTMLDirective | CaptureType<TSource>;
+export declare type TemplateValue<TSource, TParent = any> = Expression<TSource, any, TParent> | Binding<TSource, any, TParent> | HTMLDirective | CaptureType<TSource>;
 /**
  * Transforms a template literal string into a ViewTemplate.
  * @param strings - The string fragments that are interpolated with the values.
@@ -126,24 +97,4 @@ export declare type TemplateValue<TSource, TParent = any, TContext extends Execu
  * other template instances, and Directive instances.
  * @public
  */
-export declare function html<TSource = any, TParent = any, TContext extends ExecutionContext<TParent> = ExecutionContext<TParent>>(strings: TemplateStringsArray, ...values: TemplateValue<TSource, TParent, TContext>[]): ViewTemplate<TSource, TParent>;
-/**
- * Transforms a template literal string into a ChildViewTemplate.
- * @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 const child: <TChild = any, TParent = any>(strings: TemplateStringsArray, ...values: TemplateValue<TChild, TParent, ChildContext<TParent>>[]) => ChildViewTemplate<TChild, TParent>;
-/**
- * Transforms a template literal string into an ItemViewTemplate.
- * @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 const item: <TItem = any, TParent = any>(strings: TemplateStringsArray, ...values: TemplateValue<TItem, TParent, ItemContext<TParent>>[]) => ItemViewTemplate<TItem, TParent>;
+export declare function html<TSource = any, TParent = any>(strings: TemplateStringsArray, ...values: TemplateValue<TSource, TParent>[]): ViewTemplate<TSource, TParent>;

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

@@ -1,15 +1,15 @@
 import type { Disposable } from "../interfaces.js";
-import type { ExecutionContext, RootContext } from "../observation/observable.js";
+import type { ExecutionContext } from "../observation/observable.js";
 import type { ViewBehaviorFactory, ViewBehaviorTargets } from "./html-directive.js";
 /**
  * Represents a collection of DOM nodes which can be bound to a data source.
  * @public
  */
-export interface View<TSource = any, TParent = any, TContext extends ExecutionContext<TParent> = ExecutionContext<TParent>> extends Disposable {
+export interface View<TSource = any, TParent = any> extends Disposable {
     /**
      * The execution context the view is running within.
      */
-    readonly context: TContext | null;
+    readonly context: ExecutionContext<TParent> | null;
     /**
      * The data that the view is bound to.
      */
@@ -19,7 +19,7 @@ export interface View<TSource = any, TParent = any, TContext extends ExecutionCo
      * @param source - The binding source for the view's binding behaviors.
      * @param context - The execution context to run the view within.
      */
-    bind(source: TSource, context: TContext): void;
+    bind(source: TSource, context: ExecutionContext<TParent>): void;
     /**
      * Unbinds a view's behaviors from its binding source and context.
      */
@@ -29,7 +29,7 @@ export interface View<TSource = any, TParent = any, TContext extends ExecutionCo
  * A View representing DOM nodes specifically for rendering the view of a custom element.
  * @public
  */
-export interface ElementView<TSource = any, TParent = any> extends View<TSource, TParent, RootContext> {
+export interface ElementView<TSource = any, TParent = any> extends View<TSource, TParent> {
     /**
      * Appends the view's DOM nodes to the referenced node.
      * @param node - The parent node to append the view's DOM nodes to.
@@ -40,7 +40,7 @@ export interface ElementView<TSource = any, TParent = any> extends View<TSource,
  * A view representing a range of DOM nodes which can be added/removed ad hoc.
  * @public
  */
-export interface SyntheticView<TSource = any, TParent = any, TContext extends ExecutionContext<TParent> = ExecutionContext<TParent>> extends View<TSource, TParent, TContext> {
+export interface SyntheticView<TSource = any, TParent = any> extends View<TSource, TParent> {
     /**
      * The first DOM node in the range of nodes that make up the view.
      */
@@ -64,7 +64,7 @@ export interface SyntheticView<TSource = any, TParent = any, TContext extends Ex
  * The standard View implementation, which also implements ElementView and SyntheticView.
  * @public
  */
-export declare class HTMLView<TSource = any, TParent = any, TContext extends ExecutionContext<TParent> = ExecutionContext<TParent>> implements ElementView<TSource, TParent>, SyntheticView<TSource, TParent, TContext> {
+export declare class HTMLView<TSource = any, TParent = any> implements ElementView<TSource, TParent>, SyntheticView<TSource, TParent> {
     private fragment;
     private factories;
     private targets;
@@ -76,7 +76,7 @@ export declare class HTMLView<TSource = any, TParent = any, TContext extends Exe
     /**
      * The execution context the view is running within.
      */
-    context: TContext | null;
+    context: ExecutionContext<TParent> | null;
     /**
      * The first DOM node in the range of nodes that make up the view.
      */
@@ -116,7 +116,7 @@ export declare class HTMLView<TSource = any, TParent = any, TContext extends Exe
      * @param source - The binding source for the view's binding behaviors.
      * @param context - The execution context to run the behaviors within.
      */
-    bind(source: TSource, context: TContext): void;
+    bind(source: TSource, context: ExecutionContext<TParent>): void;
     /**
      * Unbinds a view's behaviors from its binding source.
      */

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

@@ -1,10 +1,10 @@
-import type { Binding } from "../observation/observable.js";
+import type { Expression } from "../observation/observable.js";
 import type { CaptureType, SyntheticViewTemplate } from "./template.js";
 /**
  * A directive that enables basic conditional rendering in a template.
- * @param binding - The condition to test for rendering.
+ * @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.
  * @public
  */
-export declare function when<TSource = any, TReturn = any>(binding: Binding<TSource, TReturn>, templateOrTemplateBinding: SyntheticViewTemplate | Binding<TSource, SyntheticViewTemplate>): CaptureType<TSource>;
+export declare function when<TSource = any, TReturn = any>(condition: Expression<TSource, TReturn> | boolean, templateOrTemplateBinding: SyntheticViewTemplate | Expression<TSource, SyntheticViewTemplate>): CaptureType<TSource>;

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

@@ -0,0 +1,2 @@
+export { timeout } from "./timeout.js";
+export * from "./fixture.js";