@microsoft/fast-element 2.0.0-beta.5 → 2.0.0-beta.7

package/docs/api-report.md

@@ -12,7 +12,7 @@ export interface Accessor {
 }
 
 // @public
-export type AddBehavior = (behavior: Behavior<HTMLElement>) => void;
+export type AddBehavior = (behavior: HostBehavior<HTMLElement>) => void;
 
 // @public
 export type AddViewBehaviorFactory = (factory: ViewBehaviorFactory) => string;
@@ -81,6 +81,11 @@ export type AttributeConfiguration = {
     converter?: ValueConverter;
 };
 
+// @public
+export const AttributeConfiguration: Readonly<{
+    locate: (target: {}) => AttributeConfiguration[];
+}>;
+
 // @public
 export class AttributeDefinition implements Accessor {
     constructor(Owner: Function, name: string, attribute?: string, mode?: AttributeMode, converter?: ValueConverter);
@@ -103,36 +108,18 @@ export class AttributeDefinition implements Accessor {
 // @public
 export type AttributeMode = typeof reflectMode | typeof booleanMode | "fromView";
 
-// @public
-export interface Behavior<TSource = any, TParent = any> {
-    bind(source: TSource, context: ExecutionContext<TParent>): void;
-    unbind(source: TSource, context: ExecutionContext<TParent>): void;
-}
-
 // @public
 export function bind<T = any>(binding: Expression<T>, isVolatile?: boolean): Binding<T>;
 
 // @public
 export abstract class Binding<TSource = any, TReturn = any, TParent = any> {
+    constructor(evaluate: Expression<TSource, TReturn, TParent>, isVolatile?: boolean);
     abstract createObserver(directive: HTMLDirective, subscriber: Subscriber): ExpressionObserver<TSource, TReturn, TParent>;
-    evaluate: Expression<TSource, TReturn, TParent>;
-    isVolatile?: boolean;
-    options?: any;
-}
-
-// @public
-export class BindingBehavior implements ViewBehavior {
-    constructor(directive: HTMLBindingDirective, updateTarget: UpdateTarget);
-    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-    createBehavior(targets: ViewBehaviorTargets): ViewBehavior;
     // (undocumented)
-    readonly directive: HTMLBindingDirective;
-    protected getObserver(target: Node): ExpressionObserver;
-    // @internal (undocumented)
-    handleChange(binding: Expression, observer: ExpressionObserver): void;
-    unbind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
+    evaluate: Expression<TSource, TReturn, TParent>;
     // (undocumented)
-    protected updateTarget: UpdateTarget;
+    isVolatile: boolean;
+    options?: any;
 }
 
 // @public
@@ -144,7 +131,7 @@ export type Callable = typeof Function.prototype.call | {
 };
 
 // @public
-export interface CaptureType<TSource> {
+export interface CaptureType<TSource, TParent> {
 }
 
 // @public
@@ -152,7 +139,7 @@ export interface ChildListDirectiveOptions<T = any> extends NodeBehaviorOptions<
 }
 
 // @public
-export function children<T = any>(propertyOrOptions: (keyof T & string) | ChildrenDirectiveOptions<keyof T & string>): CaptureType<T>;
+export function children<TSource = any, TParent = any>(propertyOrOptions: (keyof TSource & string) | ChildrenDirectiveOptions<keyof TSource & string>): CaptureType<TSource, TParent>;
 
 // @public
 export class ChildrenDirective extends NodeObservationDirective<ChildrenDirectiveOptions> {
@@ -191,11 +178,6 @@ export type ConstructibleStyleStrategy = {
     new (styles: (string | CSSStyleSheet)[]): StyleStrategy;
 };
 
-// @public
-export class ContentBehavior extends BindingBehavior {
-    unbind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-}
-
 // @public
 export interface ContentTemplate {
     create(): ContentView;
@@ -203,34 +185,18 @@ export interface ContentTemplate {
 
 // @public
 export interface ContentView {
-    bind(source: any, context: ExecutionContext): void;
+    bind(source: any): void;
+    // (undocumented)
+    readonly context: ExecutionContext;
     insertBefore(node: Node): void;
     remove(): void;
     unbind(): void;
 }
 
-// @public
-export class Controller<TElement extends HTMLElement = HTMLElement> extends PropertyChangeNotifier {
-    // @internal
-    constructor(element: TElement, definition: FASTElementDefinition);
-    addBehaviors(behaviors: ReadonlyArray<Behavior<TElement>>): void;
-    addStyles(styles: ElementStyles | HTMLStyleElement | null | undefined): void;
-    readonly definition: FASTElementDefinition;
-    readonly element: TElement;
-    emit(type: string, detail?: any, options?: Omit<CustomEventInit, "detail">): void | boolean;
-    static forCustomElement(element: HTMLElement): Controller;
-    get isConnected(): boolean;
-    onAttributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
-    onConnectedCallback(): void;
-    onDisconnectedCallback(): void;
-    removeBehaviors(behaviors: ReadonlyArray<Behavior<TElement>>, force?: boolean): void;
-    removeStyles(styles: ElementStyles | HTMLStyleElement | null | undefined): void;
-    get styles(): ElementStyles | null;
-    set styles(value: ElementStyles | null);
-    get template(): ElementViewTemplate<TElement> | null;
-    set template(value: ElementViewTemplate<TElement> | null);
-    readonly view: ElementView<TElement> | null;
-}
+// Warning: (ae-internal-missing-underscore) The name "createMetadataLocator" should be prefixed with an underscore because the declaration is marked as @internal
+//
+// @internal
+export function createMetadataLocator<TMetadata>(): (target: {}) => TMetadata[];
 
 // Warning: (ae-internal-missing-underscore) The name "createTypeRegistry" should be prefixed with an underscore because the declaration is marked as @internal
 //
@@ -288,18 +254,41 @@ export const DOM: Readonly<{
     setBooleanAttribute(element: HTMLElement, attributeName: string, value: boolean): void;
 }>;
 
+// @public
+export class ElementController<TElement extends HTMLElement = HTMLElement> extends PropertyChangeNotifier implements HostController<TElement> {
+    // @internal
+    constructor(element: TElement, definition: FASTElementDefinition);
+    addBehavior(behavior: HostBehavior<TElement>): void;
+    addStyles(styles: ElementStyles | HTMLStyleElement | null | undefined): void;
+    connect(): void;
+    readonly definition: FASTElementDefinition;
+    disconnect(): void;
+    emit(type: string, detail?: any, options?: Omit<CustomEventInit, "detail">): void | boolean;
+    static forCustomElement(element: HTMLElement): ElementController;
+    get isConnected(): boolean;
+    get mainStyles(): ElementStyles | null;
+    set mainStyles(value: ElementStyles | null);
+    onAttributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
+    removeBehavior(behavior: HostBehavior<TElement>, force?: boolean): void;
+    removeStyles(styles: ElementStyles | HTMLStyleElement | null | undefined): void;
+    readonly source: TElement;
+    get template(): ElementViewTemplate<TElement> | null;
+    set template(value: ElementViewTemplate<TElement> | null);
+    readonly view: ElementView<TElement> | null;
+}
+
 // @public
 export const elements: (selector?: string) => ElementsFilter;
 
 // @public
-export type ElementsFilter = (value: Node, index: number, array: Node[]) => boolean;
+export type ElementsFilter = (value: Node, index?: number, array?: Node[]) => boolean;
 
 // @public
 export class ElementStyles {
     constructor(styles: ReadonlyArray<ComposableStyles>);
     // @internal (undocumented)
     addStylesTo(target: StyleTarget): void;
-    readonly behaviors: ReadonlyArray<Behavior<HTMLElement>> | null;
+    readonly behaviors: ReadonlyArray<HostBehavior<HTMLElement>> | null;
     // @internal (undocumented)
     isAttachedTo(target: StyleTarget): boolean;
     static normalize(styles: ComposableStyles | ComposableStyles[] | undefined): ElementStyles | undefined;
@@ -310,7 +299,7 @@ export class ElementStyles {
     // (undocumented)
     readonly styles: ReadonlyArray<ComposableStyles>;
     static readonly supportsAdoptedStyleSheets: boolean;
-    withBehaviors(...behaviors: Behavior<HTMLElement>[]): this;
+    withBehaviors(...behaviors: HostBehavior<HTMLElement>[]): this;
     withStrategy(Strategy: ConstructibleStyleStrategy): this;
 }
 
@@ -329,52 +318,52 @@ export interface ElementViewTemplate<TSource = any, TParent = any> {
 export const emptyArray: readonly never[];
 
 // @public
-export class EventBehavior {
-    constructor(directive: HTMLBindingDirective);
-    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-    createBehavior(targets: ViewBehaviorTargets): ViewBehavior;
-    // (undocumented)
-    readonly directive: HTMLBindingDirective;
-    // @internal (undocumented)
-    handleEvent(event: Event): void;
-    unbind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-}
-
-// @public
-export class ExecutionContext<TParentSource = any> {
-    static create(): ExecutionContext;
-    createChildContext<TParentSource>(parentSource: TParentSource): ExecutionContext<TParentSource>;
-    createItemContext(index: number, length: number): ExecutionContext<TParentSource>;
-    static readonly default: ExecutionContext<any>;
-    get event(): Event;
+export interface ExecutionContext<TParent = any> {
+    readonly event: Event;
     eventDetail<TDetail>(): TDetail;
     eventTarget<TTarget extends EventTarget>(): TTarget;
     index: number;
-    get isEven(): boolean;
-    get isFirst(): boolean;
-    get isInMiddle(): boolean;
-    get isLast(): boolean;
-    get isOdd(): boolean;
+    readonly isEven: boolean;
+    readonly isFirst: boolean;
+    readonly isInMiddle: boolean;
+    readonly isLast: boolean;
+    readonly isOdd: boolean;
     length: number;
-    readonly parent: TParentSource;
-    readonly parentContext: ExecutionContext<TParentSource>;
-    // @internal
-    static setEvent(event: Event | null): void;
-    updatePosition(index: number, length: number): void;
+    parent: TParent;
+    parentContext: ExecutionContext<TParent>;
 }
 
+// @public
+export const ExecutionContext: Readonly<{
+    default: ExecutionContext<any>;
+    getEvent(): Event | null;
+    setEvent(event: Event | null): void;
+}>;
+
 // @public
 export type Expression<TSource = any, TReturn = any, TParent = any> = (source: TSource, context: ExecutionContext<TParent>) => TReturn;
 
 // @public
-export interface ExpressionNotifier<TSource = any, TReturn = any, TParent = any> extends Notifier, ExpressionObserver<TSource, TReturn, TParent> {
+export interface ExpressionController<TSource = any, TParent = any> {
+    readonly context: ExecutionContext<TParent>;
+    readonly isBound: boolean;
+    onUnbind(behavior: {
+        unbind(controller: ExpressionController<TSource, TParent>): any;
+    }): void;
+    readonly source: TSource;
+    readonly sourceLifetime?: SourceLifetime;
+}
+
+// @public
+export interface ExpressionNotifier<TSource = any, TReturn = any, TParent = any> extends Notifier, ExpressionObserver<TSource, TReturn, TParent>, Disposable {
+    observe(source: TSource, context?: ExecutionContext): TReturn;
     records(): IterableIterator<ObservationRecord>;
     setMode(isAsync: boolean): void;
 }
 
 // @public
-export interface ExpressionObserver<TSource = any, TReturn = any, TParent = any> extends Disposable {
-    observe(source: TSource, context?: ExecutionContext<TParent>): TReturn;
+export interface ExpressionObserver<TSource = any, TReturn = any, TParent = any> {
+    bind(controller: ExpressionController<TSource, TParent>): TReturn;
 }
 
 // Warning: (ae-internal-missing-underscore) The name "FAST" should be prefixed with an underscore because the declaration is marked as @internal
@@ -385,7 +374,7 @@ export const FAST: FASTGlobal;
 // @public
 export interface FASTElement extends HTMLElement {
     $emit(type: string, detail?: any, options?: Omit<CustomEventInit, "detail">): boolean | void;
-    readonly $fastController: Controller;
+    readonly $fastController: ElementController;
     attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
     connectedCallback(): void;
     disconnectedCallback(): void;
@@ -405,13 +394,14 @@ export class FASTElementDefinition<TType extends Constructable<HTMLElement> = Co
     readonly attributes: ReadonlyArray<AttributeDefinition>;
     static compose<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(type: TType, nameOrDef?: string | PartialFASTElementDefinition): FASTElementDefinition<TType>;
     define(registry?: CustomElementRegistry): this;
-    readonly elementOptions?: ElementDefinitionOptions;
+    readonly elementOptions: ElementDefinitionOptions;
     static readonly getByType: (key: Function) => FASTElementDefinition<Constructable<HTMLElement>> | undefined;
     static readonly getForInstance: (object: any) => FASTElementDefinition<Constructable<HTMLElement>> | undefined;
     get isDefined(): boolean;
     readonly name: string;
     readonly propertyLookup: Record<string, AttributeDefinition>;
-    readonly shadowOptions?: ShadowRootInit;
+    readonly registry: CustomElementRegistry;
+    readonly shadowOptions?: ShadowRootOptions;
     readonly styles?: ElementStyles;
     readonly template?: ElementViewTemplate;
     readonly type: TType;
@@ -430,21 +420,54 @@ export interface FASTGlobal {
     warn(code: number, values?: Record<string, any>): void;
 }
 
+// @public
+export interface HostBehavior<TSource = any> {
+    addedCallback?(controller: HostController<TSource>): void;
+    connectedCallback?(controller: HostController<TSource>): void;
+    disconnectedCallback?(controller: HostController<TSource>): void;
+    removedCallback?(controller: HostController<TSource>): void;
+}
+
+// @public
+export interface HostController<TSource = any> {
+    addBehavior(behavior: HostBehavior<TSource>): void;
+    addStyles(styles: ElementStyles | HTMLStyleElement | null | undefined): void;
+    readonly isConnected: boolean;
+    mainStyles: ElementStyles | null;
+    removeBehavior(behavior: HostBehavior<TSource>, force?: boolean): void;
+    removeStyles(styles: ElementStyles | HTMLStyleElement | null | undefined): void;
+    readonly source: TSource;
+}
+
 // @public
 export function html<TSource = any, TParent = any>(strings: TemplateStringsArray, ...values: TemplateValue<TSource, TParent>[]): ViewTemplate<TSource, TParent>;
 
 // @public
-export class HTMLBindingDirective implements HTMLDirective, ViewBehaviorFactory, Aspected {
+export class HTMLBindingDirective implements HTMLDirective, ViewBehaviorFactory, ViewBehavior, Aspected {
     constructor(dataBinding: Binding);
     aspectType: Aspect;
-    createBehavior(targets: ViewBehaviorTargets): ViewBehavior;
+    // @internal (undocumented)
+    bind: (controller: ViewController) => void;
+    // @internal (undocumented)
+    bindContent(controller: ViewController): void;
+    // @internal (undocumented)
+    bindDefault(controller: ViewController): void;
+    // @internal (undocumented)
+    bindEvent(controller: ViewController): void;
+    createBehavior(): ViewBehavior;
     createHTML(add: AddViewBehaviorFactory): string;
     // (undocumented)
     dataBinding: Binding;
+    // @internal (undocumented)
+    handleChange(binding: Expression, observer: ExpressionObserver): void;
+    // @internal (undocumented)
+    handleEvent(event: Event): void;
     id: string;
     nodeId: string;
     sourceAspect: string;
     targetAspect: string;
+    // @internal (undocumented)
+    unbind(controller: ViewController): void;
 }
 
 // @public
@@ -473,18 +496,40 @@ export interface HTMLTemplateCompilationResult<TSource = any, TParent = any> {
 }
 
 // @public
-export class HTMLView<TSource = any, TParent = any> implements ElementView<TSource, TParent>, SyntheticView<TSource, TParent> {
+export class HTMLView<TSource = any, TParent = any> implements ElementView<TSource, TParent>, SyntheticView<TSource, TParent>, ExecutionContext<TParent> {
     constructor(fragment: DocumentFragment, factories: ReadonlyArray<ViewBehaviorFactory>, targets: ViewBehaviorTargets);
     appendTo(node: Node): void;
-    bind(source: TSource, context: ExecutionContext<TParent>): void;
-    context: ExecutionContext<TParent> | null;
+    bind(source: TSource): void;
+    get context(): ExecutionContext<TParent>;
     dispose(): void;
     static disposeContiguousBatch(views: SyntheticView[]): void;
+    get event(): Event;
+    eventDetail<TDetail>(): TDetail;
+    eventTarget<TTarget extends EventTarget>(): TTarget;
     firstChild: Node;
+    index: number;
     insertBefore(node: Node): void;
+    // (undocumented)
+    isBound: boolean;
+    get isEven(): boolean;
+    get isFirst(): boolean;
+    get isInMiddle(): boolean;
+    get isLast(): boolean;
+    get isOdd(): boolean;
     lastChild: Node;
+    length: number;
+    // (undocumented)
+    onUnbind(behavior: {
+        unbind(controller: ViewController<TSource, TParent>): any;
+    }): void;
+    readonly parent: TParent;
+    readonly parentContext: ExecutionContext<TParent>;
     remove(): void;
+    // (undocumented)
+    selfContained: boolean;
     source: TSource | null;
+    // (undocumented)
+    readonly targets: ViewBehaviorTargets;
     unbind(): void;
 }
 
@@ -521,13 +566,13 @@ export interface NodeBehaviorOptions<T = any> {
 
 // @public
 export abstract class NodeObservationDirective<T extends NodeBehaviorOptions> extends StatelessAttachedAttributeDirective<T> {
-    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
+    bind(controller: ViewController): void;
     protected computeNodes(target: any): Node[];
     protected abstract disconnect(target: any): void;
     protected abstract getNodes(target: any): Node[];
     protected getSource(target: Node): any;
     protected abstract observe(target: any): void;
-    unbind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
+    unbind(controller: ViewController): void;
     protected updateTarget(source: any, value: ReadonlyArray<any>): void;
 }
 
@@ -580,7 +625,8 @@ export interface PartialFASTElementDefinition {
     readonly attributes?: (AttributeConfiguration | string)[];
     readonly elementOptions?: ElementDefinitionOptions;
     readonly name: string;
-    readonly shadowOptions?: Partial<ShadowRootInit> | null;
+    readonly registry?: CustomElementRegistry;
+    readonly shadowOptions?: Partial<ShadowRootOptions> | null;
     readonly styles?: ComposableStyles | ComposableStyles[];
     readonly template?: ElementViewTemplate;
 }
@@ -600,21 +646,20 @@ export class PropertyChangeNotifier implements Notifier {
 }
 
 // @public
-export const ref: <T = any>(propertyName: keyof T & string) => CaptureType<T>;
+export const ref: <TSource = any, TParent = any>(propertyName: keyof TSource & string) => CaptureType<TSource, TParent>;
 
 // @public
 export class RefDirective extends StatelessAttachedAttributeDirective<string> {
-    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-    unbind(): void;
+    bind(controller: ViewController): void;
 }
 
 // @public
-export 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>;
+export function repeat<TSource = any, TArray extends ReadonlyArray<any> = ReadonlyArray<any>, TParent = any>(items: Expression<TSource, TArray, TParent> | Binding<TSource, TArray, TParent> | ReadonlyArray<any>, template: Expression<TSource, ViewTemplate<any, TSource>> | Binding<TSource, ViewTemplate<any, TSource>> | ViewTemplate<any, TSource>, options?: RepeatOptions): CaptureType<TSource, TParent>;
 
 // @public
-export class RepeatBehavior<TSource = any> implements Behavior, Subscriber {
-    constructor(directive: RepeatDirective, location: Node);
-    bind(source: TSource, context: ExecutionContext): void;
+export class RepeatBehavior<TSource = any> implements ViewBehavior, Subscriber {
+    constructor(directive: RepeatDirective);
+    bind(controller: ViewController): void;
     handleChange(source: any, args: Splice[] | ExpressionObserver): void;
     unbind(): void;
 }
@@ -622,7 +667,7 @@ export class RepeatBehavior<TSource = any> implements Behavior, Subscriber {
 // @public
 export class RepeatDirective<TSource = any> implements HTMLDirective, ViewBehaviorFactory {
     constructor(dataBinding: Binding<TSource>, templateBinding: Binding<TSource, SyntheticViewTemplate>, options: RepeatOptions);
-    createBehavior(targets: ViewBehaviorTargets): RepeatBehavior<TSource>;
+    createBehavior(): RepeatBehavior<TSource>;
     createHTML(add: AddViewBehaviorFactory): string;
     // (undocumented)
     readonly dataBinding: Binding<TSource>;
@@ -641,7 +686,13 @@ export interface RepeatOptions {
 }
 
 // @public
-export function slotted<T = any>(propertyOrOptions: (keyof T & string) | SlottedDirectiveOptions<keyof T & string>): CaptureType<T>;
+export interface ShadowRootOptions extends ShadowRootInit {
+    // @beta
+    registry?: CustomElementRegistry;
+}
+
+// @public
+export function slotted<TSource = any, TParent = any>(propertyOrOptions: (keyof TSource & string) | SlottedDirectiveOptions<keyof TSource & string>): CaptureType<TSource, TParent>;
 
 // @public
 export class SlottedDirective extends NodeObservationDirective<SlottedDirectiveOptions> {
@@ -656,6 +707,15 @@ export class SlottedDirective extends NodeObservationDirective<SlottedDirectiveO
 export interface SlottedDirectiveOptions<T = any> extends NodeBehaviorOptions<T>, AssignedNodesOptions {
 }
 
+// @public
+export const SourceLifetime: Readonly<{
+    readonly unknown: undefined;
+    readonly coupled: 1;
+}>;
+
+// @public
+export type SourceLifetime = typeof SourceLifetime[keyof typeof SourceLifetime];
+
 // @public
 export class Splice {
     constructor(index: number, removed: any[], addedCount: number);
@@ -699,16 +759,15 @@ export const SpliceStrategySupport: Readonly<{
 export type SpliceStrategySupport = typeof SpliceStrategySupport[keyof typeof SpliceStrategySupport];
 
 // @public
-export abstract class StatelessAttachedAttributeDirective<T> implements HTMLDirective, ViewBehaviorFactory, ViewBehavior {
-    constructor(options: T);
-    abstract bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-    createBehavior(targets: ViewBehaviorTargets): ViewBehavior;
+export abstract class StatelessAttachedAttributeDirective<TOptions> implements HTMLDirective, ViewBehaviorFactory, ViewBehavior {
+    constructor(options: TOptions);
+    abstract bind(controller: ViewController): void;
+    createBehavior(): ViewBehavior;
     createHTML(add: AddViewBehaviorFactory): string;
     id: string;
     nodeId: string;
     // (undocumented)
-    protected options: T;
-    abstract unbind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
+    protected options: TOptions;
 }
 
 // @public
@@ -760,7 +819,7 @@ export interface SyntheticViewTemplate<TSource = any, TParent = any> {
 }
 
 // @public
-export type TemplateValue<TSource, TParent = any> = Expression<TSource, any, TParent> | Binding<TSource, any, TParent> | HTMLDirective | CaptureType<TSource>;
+export type TemplateValue<TSource, TParent = any> = Expression<TSource, any, TParent> | Binding<TSource, any, TParent> | HTMLDirective | CaptureType<TSource, TParent>;
 
 // @public
 export type TrustedTypes = {
@@ -803,14 +862,6 @@ export interface UpdateQueue {
 // @public
 export const Updates: UpdateQueue;
 
-// @public
-export type UpdateTarget = (this: UpdateTargetThis, target: Node, aspect: string, value: any, source: any, context: ExecutionContext) => void;
-
-// @public
-export interface UpdateTargetThis {
-    directive: HTMLBindingDirective;
-}
-
 // @public
 export interface ValueConverter {
     fromView(value: any): any;
@@ -819,44 +870,61 @@ export interface ValueConverter {
 
 // @public
 export interface View<TSource = any, TParent = any> extends Disposable {
-    bind(source: TSource, context: ExecutionContext<TParent>): void;
-    readonly context: ExecutionContext<TParent> | null;
+    bind(source: TSource): void;
+    readonly context: ExecutionContext<TParent>;
     readonly source: TSource | null;
     unbind(): void;
 }
 
 // @public
 export interface ViewBehavior<TSource = any, TParent = any> {
-    bind(source: TSource, context: ExecutionContext<TParent>, targets: ViewBehaviorTargets): void;
-    unbind(source: TSource, context: ExecutionContext<TParent>, targets: ViewBehaviorTargets): void;
+    bind(controller: ViewController<TSource, TParent>): void;
 }
 
 // @public
 export interface ViewBehaviorFactory {
-    createBehavior(targets: ViewBehaviorTargets): Behavior | ViewBehavior;
+    createBehavior(): ViewBehavior;
     id: string;
     nodeId: string;
 }
 
+// @public
+export interface ViewBehaviorOrchestrator<TSource = any, TParent = any> extends ViewController<TSource, TParent>, HostBehavior<TSource> {
+    addBehavior(behavior: ViewBehavior): void;
+    addBehaviorFactory(factory: ViewBehaviorFactory, target: Node): void;
+    // (undocumented)
+    addTarget(nodeId: string, target: Node): void;
+}
+
+// @public
+export const ViewBehaviorOrchestrator: Readonly<{
+    create<TSource = any, TParent = any>(source: TSource): ViewBehaviorOrchestrator<TSource, TParent>;
+}>;
+
 // @public
 export type ViewBehaviorTargets = {
     [id: string]: Node;
 };
 
+// @public
+export interface ViewController<TSource = any, TParent = any> extends ExpressionController<TSource, TParent> {
+    readonly targets: ViewBehaviorTargets;
+}
+
 // @public
 export class ViewTemplate<TSource = any, TParent = any> implements ElementViewTemplate<TSource, TParent>, SyntheticViewTemplate<TSource, TParent> {
     constructor(html: string | HTMLTemplateElement, factories: Record<string, ViewBehaviorFactory>);
     create(hostBindingTarget?: Element): HTMLView<TSource, TParent>;
     readonly factories: Record<string, ViewBehaviorFactory>;
     readonly html: string | HTMLTemplateElement;
-    render(source: TSource, host: Node, hostBindingTarget?: Element, context?: ExecutionContext): HTMLView<TSource, TParent>;
+    render(source: TSource, host: Node, hostBindingTarget?: Element): HTMLView<TSource, TParent>;
 }
 
 // @public
 export function volatile(target: {}, name: string | Accessor, descriptor: PropertyDescriptor): PropertyDescriptor;
 
 // @public
-export function when<TSource = any, TReturn = any>(condition: Expression<TSource, TReturn> | boolean, templateOrTemplateBinding: SyntheticViewTemplate | Expression<TSource, SyntheticViewTemplate>): CaptureType<TSource>;
+export 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>;
 
 // Warnings were encountered during analysis:
 //

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@microsoft/fast-element",
   "description": "A library for constructing Web Components",
-  "version": "2.0.0-beta.5",
+  "version": "2.0.0-beta.7",
   "author": {
     "name": "Microsoft",
     "url": "https://discord.gg/FcSNfg4"
@@ -50,9 +50,9 @@
       "types": "./dist/dts/utilities.d.ts",
       "default": "./dist/esm/utilities.js"
     },
-    "./hooks": {
-      "types": "./dist/dts/hooks.d.ts",
-      "default": "./dist/esm/hooks.js"
+    "./state": {
+      "types": "./dist/dts/state/exports.d.ts",
+      "default": "./dist/esm/state/exports.js"
     },
     "./context": {
       "types": "./dist/dts/context.d.ts",
@@ -70,6 +70,10 @@
       "types": "./dist/dts/di/di.d.ts",
       "default": "./dist/esm/di/di.js"
     },
+    "./pending-task": {
+      "types": "./dist/dts/pending-task.d.ts",
+      "default": "./dist/esm/pending-task.js"
+    },
     "./package.json": "./package.json"
   },
   "unpkg": "dist/fast-element.min.js",

package/dist/dts/hooks.d.ts

@@ -1,20 +0,0 @@
-import { ExpressionNotifier } from "./observation/observable.js";
-/**
- * Functions used for getting and setting a stateful value.
- * @beta
- */
-export declare type State<T> = [() => T, (newValue: T) => T];
-/**
- * Creates an observable state value.
- * @param value The initial state value.
- * @param deep Whether or not to convert the state value to an observable.
- * @returns The state accessor functions.
- * @beta
- */
-export declare function useState<T>(value: T, deep?: boolean): State<T>;
-/**
- * Executes an action once, and then whenever any of its dependent state changes.
- * @param action An action that is affected by state changes.
- * @returns A BindingObserver which can be used to dispose of the effect.
- */
-export declare function useEffect(action: () => void): ExpressionNotifier;

package/dist/dts/observation/behavior.d.ts

@@ -1,19 +0,0 @@
-import type { ExecutionContext } from "./observable.js";
-/**
- * Represents an object that can contribute behavior to a view or
- * element's bind/unbind operations.
- * @public
- */
-export interface Behavior<TSource = any, TParent = any> {
-    /**
-     * 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<TParent>): void;
-    /**
-     * Unbinds this behavior from the source.
-     * @param source - The source to unbind from.
-     */
-    unbind(source: TSource, context: ExecutionContext<TParent>): void;
-}