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

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

@@ -1,95 +1,351 @@
-import type { Behavior } from "../observation/behavior.js";
 import { Binding, BindingObserver, ExecutionContext } from "../observation/observable.js";
-import { TargetedHTMLDirective } from "./html-directive.js";
-declare function normalBind(this: BindingBehavior, source: unknown, context: ExecutionContext): void;
-declare function normalUnbind(this: BindingBehavior): void;
-declare function updatePropertyTarget(this: BindingBehavior, value: unknown): void;
+import { AddViewBehaviorFactory, Aspect, Aspected, HTMLDirective, ViewBehavior, ViewBehaviorFactory, ViewBehaviorTargets } from "./html-directive.js";
+import type { CaptureType } from "./template.js";
 /**
- * A directive that configures data binding to element content and attributes.
+ * Describes how aspects of an HTML element will be affected by bindings.
  * @public
  */
-export declare class HTMLBindingDirective extends TargetedHTMLDirective {
-    binding: Binding;
-    private cleanedTargetName?;
-    private originalTargetName?;
-    private bind;
-    private unbind;
-    private updateTarget;
-    private isBindingVolatile;
+export declare type BindingMode = Record<Aspect, (directive: HTMLBindingDirective) => Pick<ViewBehaviorFactory, "createBehavior">>;
+/**
+ * Describes how aspects of an HTML element will be affected by bindings.
+ * @public
+ */
+export declare const BindingMode: Readonly<{
     /**
-     * Creates an instance of BindingDirective.
-     * @param binding - A binding that returns the data used to update the DOM.
+     * Creates a binding mode based on the supplied behavior types.
+     * @param UpdateType - The base behavior type used to update aspects.
+     * @param EventType - The base behavior type used to respond to events.
+     * @returns A new binding mode.
      */
-    constructor(binding: Binding);
+    define(UpdateType: typeof UpdateBinding, EventType?: typeof EventBinding): BindingMode;
+}>;
+/**
+ * Describes the configuration for a binding expression.
+ * @public
+ */
+export interface BindingConfig<T = any> {
     /**
-     * Gets/sets the name of the attribute or property that this
-     * binding is targeting.
+     * The binding mode to configure the binding with.
      */
-    get targetName(): string | undefined;
-    set targetName(value: string | undefined);
+    mode: BindingMode;
     /**
-     * Makes this binding target the content of an element rather than
-     * a particular attribute or property.
+     * Options to be supplied to the binding behaviors.
      */
-    targetAtContent(): void;
+    options: T;
+}
+/**
+ * Creates a new binding configuration based on the supplied options.
+ * @public
+ */
+export declare type BindingConfigResolver<T> = (options: T) => BindingConfig<T>;
+/**
+ * Describes the configuration for a binding expression.
+ * @public
+ */
+export declare const BindingConfig: Readonly<{
+    /**
+     * Creates a binding configuration based on the provided mode and options.
+     * @param mode - The mode to use for the configuration.
+     * @param defaultOptions - The default options to use for the configuration.
+     * @returns A new binding configuration.
+     */
+    define<T>(mode: BindingMode, defaultOptions: T): BindingConfig<T> & BindingConfigResolver<T>;
+}>;
+/**
+ * The "this" context for an update target function.
+ * @public
+ */
+export interface UpdateTargetThis {
     /**
-     * Creates the runtime BindingBehavior instance based on the configuration
-     * information stored in the BindingDirective.
-     * @param target - The target node that the binding behavior should attach to.
+     * The directive configuration for the update.
      */
-    createBehavior(target: Node): BindingBehavior;
+    directive: HTMLBindingDirective;
 }
 /**
- * A behavior that updates content and attributes based on a configured
- * BindingDirective.
+ * A target update function.
+ * @param this - The "this" context for the update.
+ * @param target - The node that is targeted by the update.
+ * @param aspect - The aspect of the node that is being targeted.
+ * @param value - The value to assign to the aspect.
+ * @param source - The source object that the value was derived from.
+ * @param context - The execution context that the binding is being run under.
  * @public
  */
-export declare class BindingBehavior implements Behavior {
-    /** @internal */
-    source: unknown;
-    /** @internal */
-    context: ExecutionContext | null;
-    /** @internal */
-    bindingObserver: BindingObserver | null;
-    /** @internal */
-    classVersions: Record<string, number>;
-    /** @internal */
-    version: number;
-    /** @internal */
-    target: any;
-    /** @internal */
-    binding: Binding;
-    /** @internal */
-    isBindingVolatile: boolean;
-    /** @internal */
-    updateTarget: typeof updatePropertyTarget;
-    /** @internal */
-    targetName?: string;
+export declare type UpdateTarget = (this: UpdateTargetThis, target: Node, aspect: string, value: any, source: any, context: ExecutionContext) => void;
+/**
+ * A base binding behavior for DOM updates.
+ * @public
+ */
+export declare class UpdateBinding implements ViewBehavior {
+    readonly directive: HTMLBindingDirective;
+    protected updateTarget: UpdateTarget;
+    /**
+     * Creates an instance of UpdateBinding.
+     * @param directive - The directive that has the configuration for this behavior.
+     * @param updateTarget - The function used to update the target with the latest value.
+     */
+    constructor(directive: HTMLBindingDirective, updateTarget: UpdateTarget);
     /**
      * Bind this behavior to the source.
      * @param source - The source to bind to.
      * @param context - The execution context that the binding is operating within.
+     * @param targets - The targets that behaviors in a view can attach to.
      */
-    bind: typeof normalBind;
+    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
     /**
      * Unbinds this behavior from the source.
      * @param source - The source to unbind from.
+     * @param context - The execution context that the binding is operating within.
+     * @param targets - The targets that behaviors in a view can attach to.
      */
-    unbind: typeof normalUnbind;
+    unbind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
     /**
-     * Creates an instance of BindingBehavior.
-     * @param target - The target of the data updates.
-     * @param binding - The binding that returns the latest value for an update.
-     * @param isBindingVolatile - Indicates whether the binding has volatile dependencies.
-     * @param bind - The operation to perform during binding.
-     * @param unbind - The operation to perform during unbinding.
-     * @param updateTarget - The operation to perform when updating.
-     * @param targetName - The name of the target attribute or property to update.
+     * Creates a behavior.
+     * @param targets - The targets available for behaviors to be attached to.
      */
-    constructor(target: any, binding: Binding, isBindingVolatile: boolean, bind: typeof normalBind, unbind: typeof normalUnbind, updateTarget: typeof updatePropertyTarget, targetName?: string);
+    createBehavior(targets: ViewBehaviorTargets): ViewBehavior;
+}
+/**
+ * A binding behavior for one-time bindings.
+ * @public
+ */
+export declare class OneTimeBinding extends UpdateBinding {
+    /**
+     * Bind this behavior to the source.
+     * @param source - The source to bind to.
+     * @param context - The execution context that the binding is operating within.
+     * @param targets - The targets that behaviors in a view can attach to.
+     */
+    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
+}
+/**
+ * A binding behavior for signal bindings.
+ * @public
+ */
+export declare class SignalBinding extends UpdateBinding {
+    private handlerProperty;
+    /**
+     * Bind this behavior to the source.
+     * @param source - The source to bind to.
+     * @param context - The execution context that the binding is operating within.
+     * @param targets - The targets that behaviors in a view can attach to.
+     */
+    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
+    /**
+     * Unbinds this behavior from the source.
+     * @param source - The source to unbind from.
+     * @param context - The execution context that the binding is operating within.
+     * @param targets - The targets that behaviors in a view can attach to.
+     */
+    unbind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
+    private getSignal;
+    /**
+     * Sends the specified signal to signaled bindings.
+     * @param signal - The signal to send.
+     * @public
+     */
+    static send(signal: string): void;
+}
+/**
+ * A binding behavior for bindings that change.
+ * @public
+ */
+export declare class ChangeBinding extends UpdateBinding {
+    private isBindingVolatile;
+    private observerProperty;
+    /**
+     * Creates an instance of ChangeBinding.
+     * @param directive - The directive that has the configuration for this behavior.
+     * @param updateTarget - The function used to update the target with the latest value.
+     */
+    constructor(directive: HTMLBindingDirective, updateTarget: UpdateTarget);
+    /**
+     * Returns the binding observer used to update the node.
+     * @param target - The target node.
+     * @returns A BindingObserver.
+     */
+    protected getObserver(target: Node): BindingObserver;
+    /**
+     * Bind this behavior to the source.
+     * @param source - The source to bind to.
+     * @param context - The execution context that the binding is operating within.
+     * @param targets - The targets that behaviors in a view can attach to.
+     */
+    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
+    /**
+     * Unbinds this behavior from the source.
+     * @param source - The source to unbind from.
+     * @param context - The execution context that the binding is operating within.
+     * @param targets - The targets that behaviors in a view can attach to.
+     */
+    unbind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
     /** @internal */
-    handleChange(): void;
+    handleChange(binding: Binding, observer: BindingObserver): void;
+}
+/**
+ * A binding behavior for handling events.
+ * @public
+ */
+export declare class EventBinding {
+    readonly directive: HTMLBindingDirective;
+    private contextProperty;
+    private sourceProperty;
+    /**
+     * Creates an instance of EventBinding.
+     * @param directive - The directive that has the configuration for this behavior.
+     */
+    constructor(directive: HTMLBindingDirective);
+    /**
+     * Bind this behavior to the source.
+     * @param source - The source to bind to.
+     * @param context - The execution context that the binding is operating within.
+     * @param targets - The targets that behaviors in a view can attach to.
+     */
+    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
+    /**
+     * Unbinds this behavior from the source.
+     * @param source - The source to unbind from.
+     * @param context - The execution context that the binding is operating within.
+     * @param targets - The targets that behaviors in a view can attach to.
+     */
+    unbind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
+    /**
+     * Creates a behavior.
+     * @param targets - The targets available for behaviors to be attached to.
+     */
+    createBehavior(targets: ViewBehaviorTargets): ViewBehavior;
+    /**
+     * @internal
+     */
+    handleEvent(event: Event): void;
+}
+/**
+ * The settings required to enable two-way binding.
+ * @public
+ */
+export interface TwoWaySettings {
+    /**
+     * Determines which event to listen to, to detect changes in the view.
+     * @param directive - The directive to determine the change event for.
+     * @param target - The target element to determine the change event for.
+     */
+    determineChangeEvent(directive: HTMLBindingDirective, target: HTMLElement): string;
+}
+/**
+ * A binding behavior for bindings that update in two directions.
+ * @public
+ */
+export declare class TwoWayBinding extends ChangeBinding {
+    private changeEvent;
+    /**
+     * Bind this behavior to the source.
+     * @param source - The source to bind to.
+     * @param context - The execution context that the binding is operating within.
+     * @param targets - The targets that behaviors in a view can attach to.
+     */
+    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
+    /**
+     * Unbinds this behavior from the source.
+     * @param source - The source to unbind from.
+     * @param context - The execution context that the binding is operating within.
+     * @param targets - The targets that behaviors in a view can attach to.
+     */
+    unbind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
     /** @internal */
     handleEvent(event: Event): void;
+    /**
+     * Configures two-way binding.
+     * @param settings - The settings to use for the two-way binding system.
+     */
+    static configure(settings: TwoWaySettings): void;
 }
-export {};
+/**
+ * The default binding options.
+ * @public
+ */
+export declare type DefaultBindingOptions = AddEventListenerOptions;
+/**
+ * The default onChange binding configuration.
+ * @public
+ */
+export declare const onChange: BindingConfig<AddEventListenerOptions> & BindingConfigResolver<AddEventListenerOptions>;
+/**
+ * The default twoWay binding options.
+ * @public
+ */
+export declare type DefaultTwoWayBindingOptions = DefaultBindingOptions & {
+    changeEvent?: string;
+    fromView?: (value: any) => any;
+};
+/**
+ * The default twoWay binding configuration.
+ * @public
+ */
+export declare const twoWay: BindingConfig<DefaultTwoWayBindingOptions> & BindingConfigResolver<DefaultTwoWayBindingOptions>;
+/**
+ * The default onTime binding configuration.
+ * @public
+ */
+export declare const oneTime: BindingConfig<AddEventListenerOptions> & BindingConfigResolver<AddEventListenerOptions>;
+/**
+ * Creates a signal binding configuration with the supplied options.
+ * @param options - The signal name or a binding to use to retrieve the signal name.
+ * @returns A binding configuration.
+ * @public
+ */
+export declare const signal: <T = any>(options: string | Binding<T, any, ExecutionContext<any>>) => BindingConfig<string | Binding<T, any, ExecutionContext<any>>>;
+/**
+ * A directive that applies bindings.
+ * @public
+ */
+export declare class HTMLBindingDirective implements HTMLDirective, ViewBehaviorFactory, Aspected {
+    binding: Binding;
+    mode: BindingMode;
+    options: any;
+    private factory;
+    /**
+     * The unique id of the factory.
+     */
+    id: string;
+    /**
+     * The structural id of the DOM node to which the created behavior will apply.
+     */
+    nodeId: string;
+    /**
+     * The original source aspect exactly as represented in markup.
+     */
+    sourceAspect: string;
+    /**
+     * The evaluated target aspect, determined after processing the source.
+     */
+    targetAspect: string;
+    /**
+     * The type of aspect to target.
+     */
+    aspectType: Aspect;
+    /**
+     * Creates an instance of HTMLBindingDirective.
+     * @param binding - The binding to apply.
+     * @param mode - The binding mode to use when applying the binding.
+     * @param options - The options to configure the binding with.
+     */
+    constructor(binding: Binding, mode: BindingMode, options: any);
+    /**
+     * 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): ViewBehavior;
+}
+/**
+ * Creates a binding directive with the specified configuration.
+ * @param binding - The binding expression.
+ * @param config - The binding configuration.
+ * @returns A binding directive.
+ * @public
+ */
+export declare function bind<T = any>(binding: Binding<T>, config?: BindingConfig | DefaultBindingOptions): CaptureType<T>;

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

@@ -1,16 +1,16 @@
-import { NodeBehaviorOptions, NodeObservationBehavior } from "./node-observation.js";
+import { NodeBehaviorOptions, NodeObservationDirective } from "./node-observation.js";
 import type { CaptureType } from "./template.js";
 /**
  * The options used to configure child list observation.
  * @public
  */
-export interface ChildListBehaviorOptions<T = any> extends NodeBehaviorOptions<T>, Omit<MutationObserverInit, "subtree" | "childList"> {
+export interface ChildListDirectiveOptions<T = any> extends NodeBehaviorOptions<T>, Omit<MutationObserverInit, "subtree" | "childList"> {
 }
 /**
  * The options used to configure subtree observation.
  * @public
  */
-export interface SubtreeBehaviorOptions<T = any> extends Omit<NodeBehaviorOptions<T>, "filter">, Omit<MutationObserverInit, "subtree" | "childList"> {
+export interface SubtreeDirectiveOptions<T = any> extends NodeBehaviorOptions<T>, Omit<MutationObserverInit, "subtree" | "childList"> {
     /**
      * Indicates that child subtrees should be observed for changes.
      */
@@ -25,31 +25,34 @@ export interface SubtreeBehaviorOptions<T = any> extends Omit<NodeBehaviorOption
  * The options used to configure child/subtree node observation.
  * @public
  */
-export declare type ChildrenBehaviorOptions<T = any> = ChildListBehaviorOptions<T> | SubtreeBehaviorOptions<T>;
+export declare type ChildrenDirectiveOptions<T = any> = ChildListDirectiveOptions<T> | SubtreeDirectiveOptions<T>;
 /**
  * The runtime behavior for child node observation.
  * @public
  */
-export declare class ChildrenBehavior extends NodeObservationBehavior<ChildrenBehaviorOptions> {
-    private observer;
+export declare class ChildrenDirective extends NodeObservationDirective<ChildrenDirectiveOptions> {
+    private observerProperty;
     /**
-     * Creates an instance of ChildrenBehavior.
-     * @param target - The element target to observe children on.
-     * @param options - The options to use when observing the element children.
+     * Creates an instance of ChildrenDirective.
+     * @param options - The options to use in configuring the child observation behavior.
      */
-    constructor(target: HTMLElement, options: ChildrenBehaviorOptions);
+    constructor(options: ChildrenDirectiveOptions);
     /**
      * Begins observation of the nodes.
+     * @param target - The target to observe.
      */
-    observe(): void;
+    observe(target: any): void;
     /**
      * Disconnects observation of the nodes.
+     * @param target - The target to unobserve.
      */
-    disconnect(): void;
+    disconnect(target: any): void;
     /**
-     * Retrieves the nodes that should be assigned to the target.
+     * Retrieves the raw nodes that should be assigned to the source property.
+     * @param target - The target to get the node to.
      */
-    protected getNodes(): ChildNode[];
+    getNodes(target: Element): Node[];
+    private handleEvent;
 }
 /**
  * A directive that observes the `childNodes` of an element and updates a property
@@ -57,4 +60,4 @@ export declare class ChildrenBehavior extends NodeObservationBehavior<ChildrenBe
  * @param propertyOrOptions - The options used to configure child node observation.
  * @public
  */
-export declare function children<T = any>(propertyOrOptions: (keyof T & string) | ChildrenBehaviorOptions<keyof T & string>): CaptureType<T>;
+export declare function children<T = any>(propertyOrOptions: (keyof T & string) | ChildrenDirectiveOptions<keyof T & string>): CaptureType<T>;

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

@@ -1,38 +1,57 @@
-import type { HTMLDirective, NodeBehaviorFactory } from "./html-directive.js";
+import { TrustedTypesPolicy } from "../interfaces.js";
+import type { ExecutionContext } from "../observation/observable.js";
+import { ViewBehaviorFactory } from "./html-directive.js";
+import type { HTMLTemplateCompilationResult as TemplateCompilationResult } from "./template.js";
 /**
- * The result of compiling a template and its directives.
- * @beta
+ * A function capable of compiling a template from the preprocessed form produced
+ * by the html template function into a result that can instantiate views.
+ * @public
+ */
+export declare type CompilationStrategy = (
+/**
+ * The preprocessed HTML string or template to compile.
  */
-export interface CompilationResult {
+html: string | HTMLTemplateElement, 
+/**
+ * The behavior factories used within the html that is being compiled.
+ */
+factories: Record<string, ViewBehaviorFactory>) => TemplateCompilationResult;
+/**
+ * Common APIs related to compilation.
+ * @public
+ */
+export declare const Compiler: {
     /**
-     * A cloneable DocumentFragment representing the compiled HTML.
+     * Sets the HTML trusted types policy used by the compiler.
+     * @param policy - The policy to set for HTML.
+     * @remarks
+     * This API can only be called once, for security reasons. It should be
+     * called by the application developer at the start of their program.
      */
-    fragment: DocumentFragment;
+    setHTMLPolicy(policy: TrustedTypesPolicy): void;
     /**
-     * The behaviors that should be applied to the template's HTML.
+     * Compiles a template and associated directives into a compilation
+     * result which can be used to create views.
+     * @param html - The html string or template element to compile.
+     * @param directives - The directives referenced by the template.
+     * @remarks
+     * The template that is provided for compilation is altered in-place
+     * and cannot be compiled again. If the original template must be preserved,
+     * it is recommended that you clone the original and pass the clone to this API.
+     * @public
      */
-    viewBehaviorFactories: NodeBehaviorFactory[];
+    compile<TSource = any, TParent = any, TContext extends ExecutionContext<TParent> = ExecutionContext<TParent>>(html: string | HTMLTemplateElement, directives: Record<string, ViewBehaviorFactory>): TemplateCompilationResult<TSource, TParent, TContext>;
     /**
-     * The behaviors that should be applied to the host element that
-     * the template is rendered into.
+     * Sets the default compilation strategy that will be used by the ViewTemplate whenever
+     * it needs to compile a view preprocessed with the html template function.
+     * @param strategy - The compilation strategy to use when compiling templates.
      */
-    hostBehaviorFactories: NodeBehaviorFactory[];
+    setDefaultStrategy(strategy: CompilationStrategy): void;
     /**
-     * An index offset to apply to BehaviorFactory target indexes when
-     * matching factories to targets.
+     * Aggregates an array of strings and directives into a single directive.
+     * @param parts - A heterogeneous array of static strings interspersed with
+     * directives.
+     * @returns A single inline directive that aggregates the behavior of all the parts.
      */
-    targetOffset: number;
-}
-/**
- * Compiles a template and associated directives into a raw compilation
- * result which include a cloneable DocumentFragment and factories capable
- * of attaching runtime behavior to nodes within the fragment.
- * @param template - The template to compile.
- * @param directives - The directives referenced by the template.
- * @remarks
- * The template that is provided for compilation is altered in-place
- * and cannot be compiled again. If the original template must be preserved,
- * it is recommended that you clone the original and pass the clone to this API.
- * @public
- */
-export declare function compileTemplate(template: HTMLTemplateElement, directives: ReadonlyArray<HTMLDirective>): CompilationResult;
+    aggregate(parts: (string | ViewBehaviorFactory)[]): ViewBehaviorFactory;
+};

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

@@ -0,0 +1,41 @@
+import type { Callable } from "../interfaces.js";
+/**
+ * Common DOM APIs.
+ * @public
+ */
+export declare const DOM: Readonly<{
+    /**
+     * @deprecated
+     * Use Updates.enqueue().
+     */
+    queueUpdate: (callable: Callable) => void;
+    /**
+     * @deprecated
+     * Use Updates.next()
+     */
+    nextUpdate: () => Promise<void>;
+    /**
+     * @deprecated
+     * Use Updates.process()
+     */
+    processUpdates: () => void;
+    /**
+     * Sets an attribute value on an element.
+     * @param element - The element to set the attribute value on.
+     * @param attributeName - The attribute name to set.
+     * @param value - The value of the attribute to set.
+     * @remarks
+     * If the value is `null` or `undefined`, the attribute is removed, otherwise
+     * it is set to the provided value using the standard `setAttribute` API.
+     */
+    setAttribute(element: HTMLElement, attributeName: string, value: any): void;
+    /**
+     * Sets a boolean attribute value.
+     * @param element - The element to set the boolean attribute value on.
+     * @param attributeName - The attribute name to set.
+     * @param value - The value of the attribute to set.
+     * @remarks
+     * If the value is true, the attribute is added; otherwise it is removed.
+     */
+    setBooleanAttribute(element: HTMLElement, attributeName: string, value: boolean): void;
+}>;