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

package/docs/api-report.md

@@ -12,24 +12,11 @@ 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;
 
-// Warning: (ae-internal-missing-underscore) The name "AdoptedStyleSheetsStrategy" should be prefixed with an underscore because the declaration is marked as @internal
-//
-// @internal
-export class AdoptedStyleSheetsStrategy implements StyleStrategy {
-    constructor(styles: (string | CSSStyleSheet)[]);
-    // (undocumented)
-    addStylesTo(target: StyleTarget): void;
-    // (undocumented)
-    removeStylesFrom(target: StyleTarget): void;
-    // (undocumented)
-    readonly sheets: CSSStyleSheet[];
-}
-
 // @public
 export interface ArrayObserver extends SubscriberSet {
     addSplice(splice: Splice): void;
@@ -53,7 +40,7 @@ export const Aspect: Readonly<{
     readonly content: 4;
     readonly tokenList: 5;
     readonly event: 6;
-    readonly assign: (directive: Aspected, value: string) => void;
+    readonly assign: (directive: Aspected, value?: string) => void;
 }>;
 
 // @public
@@ -62,7 +49,7 @@ export type Aspect = typeof Aspect[Exclude<keyof typeof Aspect, "assign" | "none
 // @public
 export interface Aspected {
     aspectType: Aspect;
-    binding?: Binding;
+    dataBinding?: Binding;
     sourceAspect: string;
     targetAspect: string;
 }
@@ -81,6 +68,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);
@@ -104,44 +96,17 @@ export class AttributeDefinition implements Accessor {
 export type AttributeMode = typeof reflectMode | typeof booleanMode | "fromView";
 
 // @public
-export interface Behavior<TSource = any, TParent = any, TContext extends ExecutionContext<TParent> = RootContext> {
-    bind(source: TSource, context: TContext): void;
-    unbind(source: TSource, context: TContext): void;
-}
-
-// @public
-export function bind<T = any>(binding: Binding<T>, config?: BindingConfig | DefaultBindingOptions): CaptureType<T>;
-
-// @public
-export type Binding<TSource = any, TReturn = any, TContext extends ExecutionContext = ExecutionContext> = (source: TSource, context: TContext) => TReturn;
-
-// @public
-export interface BindingConfig<T = any> {
-    mode: BindingMode;
-    options: T;
-}
-
-// @public
-export const BindingConfig: Readonly<{
-    define<T>(mode: BindingMode, defaultOptions: T): BindingConfig<T> & BindingConfigResolver<T>;
-}>;
-
-// @public
-export type BindingConfigResolver<T> = (options: T) => BindingConfig<T>;
-
-// @public
-export type BindingMode = Record<Aspect, (directive: HTMLBindingDirective) => Pick<ViewBehaviorFactory, "createBehavior">>;
-
-// @public
-export const BindingMode: Readonly<{
-    define(UpdateType: typeof UpdateBinding, EventType?: typeof EventBinding): BindingMode;
-}>;
+export function bind<T = any>(binding: Expression<T>, isVolatile?: boolean): Binding<T>;
 
 // @public
-export interface BindingObserver<TSource = any, TReturn = any, TParent = any> extends Notifier, Disposable {
-    observe(source: TSource, context?: ExecutionContext<TParent>): TReturn;
-    records(): IterableIterator<ObservationRecord>;
-    setMode(isAsync: boolean): void;
+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>;
+    // (undocumented)
+    evaluate: Expression<TSource, TReturn, TParent>;
+    // (undocumented)
+    isVolatile: boolean;
+    options?: any;
 }
 
 // @public
@@ -153,27 +118,7 @@ export type Callable = typeof Function.prototype.call | {
 };
 
 // @public
-export interface CaptureType<TSource> {
-}
-
-// @public
-export class ChangeBinding extends UpdateBinding {
-    constructor(directive: HTMLBindingDirective, updateTarget: UpdateTarget);
-    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-    protected getObserver(target: Node): BindingObserver;
-    // @internal (undocumented)
-    handleChange(binding: Binding, observer: BindingObserver): void;
-    unbind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-}
-
-// @public
-export const child: <TChild = any, TParent = any>(strings: TemplateStringsArray, ...values: TemplateValue<TChild, TParent, ChildContext<TParent>>[]) => ChildViewTemplate<TChild, TParent>;
-
-// @public
-export interface ChildContext<TParentSource = any> extends RootContext {
-    createItemContext(index: number, length: number): ItemContext<TParentSource>;
-    readonly parent: TParentSource;
-    readonly parentContext: ChildContext<TParentSource>;
+export interface CaptureType<TSource, TParent> {
 }
 
 // @public
@@ -181,7 +126,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> {
@@ -194,13 +139,6 @@ export class ChildrenDirective extends NodeObservationDirective<ChildrenDirectiv
 // @public
 export type ChildrenDirectiveOptions<T = any> = ChildListDirectiveOptions<T> | SubtreeDirectiveOptions<T>;
 
-// @public
-export interface ChildViewTemplate<TSource = any, TParent = any> {
-    create(): SyntheticView<TSource, TParent, ChildContext<TParent>>;
-    // (undocumented)
-    type: "child";
-}
-
 // @public
 export type CompilationStrategy = (
 html: string | HTMLTemplateElement,
@@ -209,7 +147,7 @@ factories: Record<string, ViewBehaviorFactory>) => HTMLTemplateCompilationResult
 // @public
 export const Compiler: {
     setHTMLPolicy(policy: TrustedTypesPolicy): void;
-    compile<TSource = any, TParent = any, TContext extends ExecutionContext<TParent> = ExecutionContext<TParent>>(html: string | HTMLTemplateElement, directives: Record<string, ViewBehaviorFactory>): HTMLTemplateCompilationResult<TSource, TParent, TContext>;
+    compile<TSource = any, TParent = any>(html: string | HTMLTemplateElement, directives: Record<string, ViewBehaviorFactory>): HTMLTemplateCompilationResult<TSource, TParent>;
     setDefaultStrategy(strategy: CompilationStrategy): void;
     aggregate(parts: (string | ViewBehaviorFactory)[]): ViewBehaviorFactory;
 };
@@ -228,28 +166,25 @@ export type ConstructibleStyleStrategy = {
 };
 
 // @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;
+export interface ContentTemplate {
+    create(): ContentView;
+}
+
+// @public
+export interface ContentView {
+    bind(source: any, context?: ExecutionContext): void;
+    // (undocumented)
+    readonly context: ExecutionContext;
+    insertBefore(node: Node): void;
+    remove(): void;
+    unbind(): void;
 }
 
+// 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
 //
 // @internal
@@ -292,15 +227,6 @@ export function customElement(nameOrDef: string | PartialFASTElementDefinition):
 // @public
 export type DecoratorAttributeConfiguration = Omit<AttributeConfiguration, "property">;
 
-// @public
-export type DefaultBindingOptions = AddEventListenerOptions;
-
-// @public
-export type DefaultTwoWayBindingOptions = DefaultBindingOptions & {
-    changeEvent?: string;
-    fromView?: (value: any) => any;
-};
-
 // @public
 export interface Disposable {
     dispose(): void;
@@ -315,20 +241,44 @@ 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;
     // @internal (undocumented)
     removeStylesFrom(target: StyleTarget): void;
     static setDefaultStrategy(Strategy: ConstructibleStyleStrategy): void;
@@ -336,12 +286,12 @@ 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;
 }
 
 // @public
-export interface ElementView<TSource = any, TParent = any> extends View<TSource, TParent, RootContext> {
+export interface ElementView<TSource = any, TParent = any> extends View<TSource, TParent> {
     appendTo(node: Node): void;
 }
 
@@ -349,34 +299,59 @@ export interface ElementView<TSource = any, TParent = any> extends View<TSource,
 export interface ElementViewTemplate<TSource = any, TParent = any> {
     create(hostBindingTarget: Element): ElementView<TSource, TParent>;
     render(source: TSource, host: Node, hostBindingTarget?: Element): ElementView<TSource, TParent>;
-    // (undocumented)
-    type: "element";
 }
 
 // @public
 export const emptyArray: readonly never[];
 
 // @public
-export class EventBinding {
-    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;
+export interface ExecutionContext<TParent = any> {
+    readonly event: Event;
+    eventDetail<TDetail>(): TDetail;
+    eventTarget<TTarget extends EventTarget>(): TTarget;
+    index: number;
+    readonly isEven: boolean;
+    readonly isFirst: boolean;
+    readonly isInMiddle: boolean;
+    readonly isLast: boolean;
+    readonly isOdd: boolean;
+    length: number;
+    parent: TParent;
+    parentContext: ExecutionContext<TParent>;
 }
 
 // @public
 export const ExecutionContext: Readonly<{
-    default: RootContext;
+    default: ExecutionContext<any>;
+    getEvent(): Event | null;
     setEvent(event: Event | null): void;
-    create(): RootContext;
 }>;
 
 // @public
-export type ExecutionContext<TParentSource = any> = RootContext | ChildContext<TParentSource> | ItemContext<TParentSource>;
+export type Expression<TSource = any, TReturn = any, TParent = any> = (source: TSource, context: ExecutionContext<TParent>) => TReturn;
+
+// @public
+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> {
+    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
 //
@@ -386,34 +361,36 @@ 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;
 }
 
 // @public
-export const FASTElement: (new () => HTMLElement & FASTElement) & {
-    from<TBase extends {
-        new (): HTMLElement;
-        prototype: HTMLElement;
-    }>(BaseType: TBase): new () => InstanceType<TBase> & FASTElement;
-    define<TType extends Constructable<HTMLElement>>(type: TType, nameOrDef?: string | PartialFASTElementDefinition): TType;
+export const FASTElement: {
+    new (): FASTElement;
+    define: typeof define;
+    compose: typeof compose;
+    from: typeof from;
 };
 
 // @public
 export class FASTElementDefinition<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>> {
-    constructor(type: TType, nameOrConfig?: PartialFASTElementDefinition | string);
     readonly attributeLookup: Record<string, AttributeDefinition>;
     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;
+    // @internal
+    static registerBaseType(type: Function): void;
+    readonly registry: CustomElementRegistry;
+    readonly shadowOptions?: ShadowRootOptions;
     readonly styles?: ElementStyles;
     readonly template?: ElementViewTemplate;
     readonly type: TType;
@@ -424,33 +401,62 @@ export class FASTElementDefinition<TType extends Constructable<HTMLElement> = Co
 // @internal
 export interface FASTGlobal {
     addMessages(messages: Record<number, string>): void;
-    error(code: number, ...args: any[]): Error;
+    error(code: number, values?: Record<string, any>): Error;
     getById<T>(id: string | number): T | null;
     // (undocumented)
     getById<T>(id: string | number, initialize: () => T): T;
     readonly versions: string[];
-    warn(code: number, ...args: any[]): void;
+    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, TContext extends ExecutionContext<TParent> = ExecutionContext<TParent>>(strings: TemplateStringsArray, ...values: TemplateValue<TSource, TParent, TContext>[]): ViewTemplate<TSource, TParent>;
+export function html<TSource = any, TParent = any>(strings: TemplateStringsArray, ...values: TemplateValue<TSource, TParent>[]): ViewTemplate<TSource, TParent>;
 
 // @public
-export class HTMLBindingDirective implements HTMLDirective, ViewBehaviorFactory, Aspected {
-    constructor(binding: Binding, mode: BindingMode, options: any);
+export class HTMLBindingDirective implements HTMLDirective, ViewBehaviorFactory, ViewBehavior, Aspected {
+    constructor(dataBinding: Binding);
     aspectType: Aspect;
-    // (undocumented)
-    binding: Binding;
-    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;
-    id: string;
     // (undocumented)
-    mode: BindingMode;
+    dataBinding: Binding;
+    // @internal (undocumented)
+    handleChange(binding: Expression, observer: ExpressionObserver): void;
+    // @internal (undocumented)
+    handleEvent(event: Event): void;
+    id: string;
     nodeId: string;
-    // (undocumented)
-    options: any;
     sourceAspect: string;
     targetAspect: string;
+    // @internal (undocumented)
+    unbind(controller: ViewController): void;
 }
 
 // @public
@@ -474,56 +480,56 @@ export interface HTMLDirectiveDefinition<TType extends Constructable<HTMLDirecti
 }
 
 // @public
-export interface HTMLTemplateCompilationResult<TSource = any, TParent = any, TContext extends ExecutionContext<TParent> = ExecutionContext<TParent>> {
-    createView(hostBindingTarget?: Element): HTMLView<TSource, TParent, TContext>;
+export interface HTMLTemplateCompilationResult<TSource = any, TParent = any> {
+    createView(hostBindingTarget?: Element): HTMLView<TSource, TParent>;
 }
 
 // @public
-export class HTMLView<TSource = any, TParent = any, TContext extends ExecutionContext<TParent> = ExecutionContext<TParent>> implements ElementView<TSource, TParent>, SyntheticView<TSource, TParent, TContext> {
+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: TContext): void;
-    context: TContext | null;
+    bind(source: TSource, context?: ExecutionContext<TParent>): void;
+    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;
+    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;
     source: TSource | null;
+    readonly sourceLifetime: SourceLifetime;
+    // (undocumented)
+    readonly targets: ViewBehaviorTargets;
     unbind(): void;
 }
 
 // @public
-export const item: <TItem = any, TParent = any>(strings: TemplateStringsArray, ...values: TemplateValue<TItem, TParent, ItemContext<TParent>>[]) => ItemViewTemplate<TItem, TParent>;
-
-// @public
-export interface ItemContext<TParentSource = any> extends ChildContext<TParentSource> {
-    readonly index: number;
-    readonly isEven: boolean;
-    readonly isFirst: boolean;
-    readonly isInMiddle: boolean;
-    readonly isLast: boolean;
-    readonly isOdd: boolean;
-    readonly length: number;
-    updatePosition(index: number, length: number): void;
-}
-
-// @public
-export interface ItemViewTemplate<TSource = any, TParent = any> {
-    create(): SyntheticView<TSource, TParent, ItemContext<TParent>>;
-    // (undocumented)
-    type: "item";
+export interface LengthObserver extends Subscriber {
+    length: number;
 }
 
 // @public
-function length_2<T>(array: readonly T[]): number;
-export { length_2 as length }
+export function lengthOf<T>(array: readonly T[]): number;
 
 // @public
-export interface LengthObserver extends Subscriber {
-    length: number;
-}
+export function listener<T = any>(binding: Expression<T>, options?: AddEventListenerOptions): Binding<T>;
 
 // @public
 export const Markup: Readonly<{
@@ -547,16 +553,19 @@ 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;
 }
 
+// @public
+export function normalizeBinding<TSource = any, TReturn = any, TParent = any>(value: Expression<TSource, TReturn, TParent> | Binding<TSource, TReturn, TParent> | {}): Binding<TSource, TReturn, TParent>;
+
 // @public
 export interface Notifier {
     notify(args: any): void;
@@ -577,8 +586,8 @@ export const Observable: Readonly<{
     notify(source: unknown, args: any): void;
     defineProperty(target: {}, nameOrAccessor: string | Accessor): void;
     getAccessors: (target: {}) => Accessor[];
-    binding<TSource = any, TReturn = any>(binding: Binding<TSource, TReturn, ExecutionContext<any>>, initialSubscriber?: Subscriber, isVolatileBinding?: boolean): BindingObserver<TSource, TReturn, any>;
-    isVolatileBinding<TSource_1 = any, TReturn_1 = any>(binding: Binding<TSource_1, TReturn_1, ExecutionContext<any>>): boolean;
+    binding<TSource = any, TReturn = any>(expression: Expression<TSource, TReturn, any>, initialSubscriber?: Subscriber, isVolatileBinding?: boolean): ExpressionNotifier<TSource, TReturn, any>;
+    isVolatileBinding<TSource_1 = any, TReturn_1 = any>(expression: Expression<TSource_1, TReturn_1, any>): boolean;
 }>;
 
 // @public
@@ -591,15 +600,7 @@ export interface ObservationRecord {
 }
 
 // @public
-export const onChange: BindingConfig<AddEventListenerOptions> & BindingConfigResolver<AddEventListenerOptions>;
-
-// @public
-export const oneTime: BindingConfig<AddEventListenerOptions> & BindingConfigResolver<AddEventListenerOptions>;
-
-// @public
-export class OneTimeBinding extends UpdateBinding {
-    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-}
+export function oneTime<T = any>(binding: Expression<T>): Binding<T>;
 
 // @public
 export const Parser: Readonly<{
@@ -611,7 +612,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;
 }
@@ -631,67 +633,32 @@ 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>>(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>;
-
-// @public
-export 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>;
-
-// @public
-export 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>;
-
-// @public
-export class RepeatBehavior<TSource = any> implements Behavior, Subscriber {
-    constructor(location: Node, itemsBinding: Binding<TSource, any[]>, isItemsBindingVolatile: boolean, templateBinding: Binding<TSource, SyntheticViewTemplate>, isTemplateBindingVolatile: boolean, options: RepeatOptions);
-    bind(source: TSource, context: ExecutionContext): void;
-    handleChange(source: any, args: Splice[]): void;
+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 ViewBehavior, Subscriber {
+    constructor(directive: RepeatDirective);
+    bind(controller: ViewController): void;
+    handleChange(source: any, args: Splice[] | ExpressionObserver): void;
     unbind(): void;
 }
 
 // @public
 export class RepeatDirective<TSource = any> implements HTMLDirective, ViewBehaviorFactory {
-    constructor(itemsBinding: Binding, templateBinding: Binding<TSource, SyntheticViewTemplate>, options: RepeatOptions);
-    createBehavior(targets: ViewBehaviorTargets): RepeatBehavior<TSource>;
+    constructor(dataBinding: Binding<TSource>, templateBinding: Binding<TSource, SyntheticViewTemplate>, options: RepeatOptions);
+    createBehavior(): RepeatBehavior<TSource>;
     createHTML(add: AddViewBehaviorFactory): string;
-    id: string;
     // (undocumented)
-    readonly itemsBinding: Binding;
+    readonly dataBinding: Binding<TSource>;
+    id: string;
     nodeId: string;
     // (undocumented)
     readonly options: RepeatOptions;
@@ -706,25 +673,13 @@ export interface RepeatOptions {
 }
 
 // @public
-export interface RootContext {
-    createChildContext<TParentSource>(source: TParentSource): ChildContext<TParentSource>;
-    readonly event: Event;
-    eventDetail<TDetail = any>(): TDetail;
-    eventTarget<TTarget extends EventTarget = EventTarget>(): TTarget;
-}
-
-// @public
-export const signal: <T = any>(options: string | Binding<T, any, ExecutionContext<any>>) => BindingConfig<string | Binding<T, any, ExecutionContext<any>>>;
-
-// @public
-export class SignalBinding extends UpdateBinding {
-    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-    static send(signal: string): void;
-    unbind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
+export interface ShadowRootOptions extends ShadowRootInit {
+    // @beta
+    registry?: CustomElementRegistry;
 }
 
 // @public
-export function slotted<T = any>(propertyOrOptions: (keyof T & string) | SlottedDirectiveOptions<keyof T & string>): CaptureType<T>;
+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> {
@@ -739,6 +694,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);
@@ -782,16 +746,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
@@ -801,7 +764,7 @@ export interface StyleStrategy {
 }
 
 // @public
-export interface StyleTarget {
+export interface StyleTarget extends Pick<Node, "getRootNode"> {
     adoptedStyleSheets?: CSSStyleSheet[];
     append(styles: HTMLStyleElement): void;
     querySelectorAll<E extends Element = Element>(selectors: string): NodeListOf<E>;
@@ -830,7 +793,7 @@ export interface SubtreeDirectiveOptions<T = any> extends NodeBehaviorOptions<T>
 }
 
 // @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> {
     readonly firstChild: Node;
     insertBefore(node: Node): void;
     readonly lastChild: Node;
@@ -838,14 +801,12 @@ export interface SyntheticView<TSource = any, TParent = any, TContext extends Ex
 }
 
 // @public
-export interface SyntheticViewTemplate<TSource = any, TParent = any, TContext extends ExecutionContext<TParent> = ExecutionContext<TParent>> {
-    create(): SyntheticView<TSource, TParent, TContext>;
-    // (undocumented)
-    type: "synthetic";
+export interface SyntheticViewTemplate<TSource = any, TParent = any> {
+    create(): SyntheticView<TSource, TParent>;
 }
 
 // @public
-export type TemplateValue<TSource, TParent = any, TContext extends ExecutionContext<TParent> = ExecutionContext<TParent>> = Binding<TSource, any, TContext> | 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 = {
@@ -857,23 +818,6 @@ export type TrustedTypesPolicy = {
     createHTML(html: string): string;
 };
 
-// @public
-export const twoWay: BindingConfig<DefaultTwoWayBindingOptions> & BindingConfigResolver<DefaultTwoWayBindingOptions>;
-
-// @public
-export class TwoWayBinding extends ChangeBinding {
-    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-    static configure(settings: TwoWaySettings): void;
-    // @internal (undocumented)
-    handleEvent(event: Event): void;
-    unbind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-}
-
-// @public
-export interface TwoWaySettings {
-    determineChangeEvent(directive: HTMLBindingDirective, target: HTMLElement): string;
-}
-
 // Warning: (ae-internal-missing-underscore) The name "TypeDefinition" should be prefixed with an underscore because the declaration is marked as @internal
 //
 // @internal
@@ -894,18 +838,6 @@ export interface TypeRegistry<TDefinition extends TypeDefinition> {
     register(definition: TDefinition): boolean;
 }
 
-// @public
-export class UpdateBinding implements ViewBehavior {
-    constructor(directive: HTMLBindingDirective, updateTarget: UpdateTarget);
-    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-    createBehavior(targets: ViewBehaviorTargets): ViewBehavior;
-    // (undocumented)
-    readonly directive: HTMLBindingDirective;
-    unbind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-    // (undocumented)
-    protected updateTarget: UpdateTarget;
-}
-
 // @public
 export interface UpdateQueue {
     enqueue(callable: Callable): void;
@@ -917,14 +849,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;
@@ -932,46 +856,68 @@ export interface ValueConverter {
 }
 
 // @public
-export interface View<TSource = any, TParent = any, TContext extends ExecutionContext<TParent> = ExecutionContext<TParent>> extends Disposable {
-    bind(source: TSource, context: TContext): void;
-    readonly context: TContext | null;
+export interface View<TSource = any, TParent = any> extends Disposable {
+    bind(source: TSource, context?: ExecutionContext<TParent>): 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 class ViewTemplate<TSource = any, TParent = any, TContext extends ExecutionContext<TParent> = ExecutionContext> implements ElementViewTemplate<TSource, TParent>, SyntheticViewTemplate<TSource, TParent, TContext> {
+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, TContext>;
+    create(hostBindingTarget?: Element): HTMLView<TSource, TParent>;
     readonly factories: Record<string, ViewBehaviorFactory>;
     readonly html: string | HTMLTemplateElement;
-    render(source: TSource, host: Node, hostBindingTarget?: Element, context?: TContext): HTMLView<TSource, TParent, TContext>;
-    type: any;
+    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>(binding: Binding<TSource, TReturn>, templateOrTemplateBinding: SyntheticViewTemplate | Binding<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:
+//
+// dist/dts/components/fast-element.d.ts:60:5 - (ae-forgotten-export) The symbol "define" needs to be exported by the entry point index.d.ts
+// dist/dts/components/fast-element.d.ts:61:5 - (ae-forgotten-export) The symbol "compose" needs to be exported by the entry point index.d.ts
+// dist/dts/components/fast-element.d.ts:62:5 - (ae-forgotten-export) The symbol "from" needs to be exported by the entry point index.d.ts
 
 // (No @packageDocumentation comment for this package)