@microsoft/fast-element 2.0.0-beta.3 → 2.0.0-beta.6

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

@@ -1,56 +1,5 @@
-import { Binding, BindingObserver, ExecutionContext } from "../observation/observable.js";
-import { AddViewBehaviorFactory, Aspect, Aspected, HTMLDirective, ViewBehavior, ViewBehaviorFactory, ViewBehaviorTargets } from "./html-directive.js";
-import type { CaptureType } from "./template.js";
-/**
- * Describes how aspects of an HTML element will be affected by bindings.
- * @public
- */
-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 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.
-     */
-    define(UpdateType: typeof UpdateBinding, EventType?: typeof EventBinding): BindingMode;
-}>;
-/**
- * Describes the configuration for a binding expression.
- * @public
- */
-export interface BindingConfig<T = any> {
-    /**
-     * The binding mode to configure the binding with.
-     */
-    mode: BindingMode;
-    /**
-     * Options to be supplied to the binding behaviors.
-     */
-    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>;
-}>;
+import { ExecutionContext, Expression, ExpressionObserver } from "../observation/observable.js";
+import { AddViewBehaviorFactory, Aspect, Aspected, Binding, HTMLDirective, ViewBehavior, ViewBehaviorFactory, ViewBehaviorTargets } from "./html-directive.js";
 /**
  * The "this" context for an update target function.
  * @public
@@ -73,57 +22,48 @@ export interface UpdateTargetThis {
  */
 export declare type UpdateTarget = (this: UpdateTargetThis, target: Node, aspect: string, value: any, source: any, context: ExecutionContext) => void;
 /**
- * A base binding behavior for DOM updates.
+ * A simple View that can be interpolated into HTML content.
  * @public
  */
-export declare class UpdateBinding implements ViewBehavior {
-    readonly directive: HTMLBindingDirective;
-    protected updateTarget: UpdateTarget;
+export interface ContentView {
     /**
-     * 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.
+     * Binds a view's behaviors to its binding source.
+     * @param source - The binding source for the view's binding behaviors.
+     * @param context - The execution context to run the view within.
      */
-    constructor(directive: HTMLBindingDirective, updateTarget: UpdateTarget);
+    bind(source: any, context: ExecutionContext): void;
     /**
-     * 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.
+     * Unbinds a view's behaviors from its binding source and context.
      */
-    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
+    unbind(): 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.
+     * Inserts the view's DOM nodes before the referenced node.
+     * @param node - The node to insert the view's DOM before.
      */
-    unbind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
+    insertBefore(node: Node): void;
     /**
-     * Creates a behavior.
-     * @param targets - The targets available for behaviors to be attached to.
+     * Removes the view's DOM nodes.
+     * The nodes are not disposed and the view can later be re-inserted.
      */
-    createBehavior(targets: ViewBehaviorTargets): ViewBehavior;
+    remove(): void;
 }
 /**
- * A binding behavior for one-time bindings.
+ * A simple template that can create ContentView instances.
  * @public
  */
-export declare class OneTimeBinding extends UpdateBinding {
+export interface ContentTemplate {
     /**
-     * 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.
+     * Creates a simple content view instance.
      */
-    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
+    create(): ContentView;
 }
 /**
  * A binding behavior for bindings that change.
  * @public
  */
-export declare class ChangeBinding extends UpdateBinding {
-    private isBindingVolatile;
+export declare class BindingBehavior implements ViewBehavior {
+    readonly directive: HTMLBindingDirective;
+    protected updateTarget: UpdateTarget;
     private observerProperty;
     /**
      * Creates an instance of ChangeBinding.
@@ -131,12 +71,6 @@ export declare class ChangeBinding extends UpdateBinding {
      * @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.
@@ -152,13 +86,37 @@ export declare class ChangeBinding extends UpdateBinding {
      */
     unbind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
     /** @internal */
-    handleChange(binding: Binding, observer: BindingObserver): void;
+    handleChange(binding: Expression, observer: ExpressionObserver): void;
+    /**
+     * Returns the binding observer used to update the node.
+     * @param target - The target node.
+     * @returns A BindingObserver.
+     */
+    protected getObserver(target: Node): ExpressionObserver;
+    /**
+     * Creates a behavior.
+     * @param targets - The targets available for behaviors to be attached to.
+     */
+    createBehavior(targets: ViewBehaviorTargets): ViewBehavior;
+}
+/**
+ * A special binding behavior that can bind node content.
+ * @public
+ */
+export declare class ContentBehavior extends BindingBehavior {
+    /**
+     * 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;
 }
 /**
  * A binding behavior for handling events.
  * @public
  */
-export declare class EventBinding {
+export declare class EventBehavior {
     readonly directive: HTMLBindingDirective;
     private contextProperty;
     private sourceProperty;
@@ -191,29 +149,12 @@ export declare class EventBinding {
      */
     handleEvent(event: Event): void;
 }
-/**
- * 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 onTime binding configuration.
- * @public
- */
-export declare const oneTime: BindingConfig<AddEventListenerOptions> & BindingConfigResolver<AddEventListenerOptions>;
 /**
  * A directive that applies bindings.
  * @public
  */
 export declare class HTMLBindingDirective implements HTMLDirective, ViewBehaviorFactory, Aspected {
-    binding: Binding;
-    mode: BindingMode;
-    options: any;
+    dataBinding: Binding;
     private factory;
     /**
      * The unique id of the factory.
@@ -237,11 +178,9 @@ export declare class HTMLBindingDirective implements HTMLDirective, ViewBehavior
     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.
+     * @param dataBinding - The binding configuration to apply.
      */
-    constructor(binding: Binding, mode: BindingMode, options: any);
+    constructor(dataBinding: Binding);
     /**
      * Creates HTML to be used within a template.
      * @param add - Can be used to add  behavior factories to a template.
@@ -254,10 +193,32 @@ export declare class HTMLBindingDirective implements HTMLDirective, ViewBehavior
     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.
+ * Creates an standard binding.
+ * @param binding - The binding to refresh when changed.
+ * @param isVolatile - Indicates whether the binding is volatile or not.
+ * @returns A binding configuration.
+ * @public
+ */
+export declare function bind<T = any>(binding: Expression<T>, isVolatile?: boolean): Binding<T>;
+/**
+ * Creates a one time binding
+ * @param binding - The binding to refresh when signaled.
+ * @returns A binding configuration.
+ * @public
+ */
+export declare function oneTime<T = any>(binding: Expression<T>): Binding<T>;
+/**
+ * Creates an event listener binding.
+ * @param binding - The binding to invoke when the event is raised.
+ * @param options - Event listener options.
+ * @returns A binding configuration.
+ * @public
+ */
+export declare function listener<T = any>(binding: Expression<T>, options?: AddEventListenerOptions): Binding<T>;
+/**
+ * Normalizes the input value into a binding.
+ * @param value - The value to create the default binding for.
+ * @returns A binding configuration for the provided value.
  * @public
  */
-export declare function bind<T = any>(binding: Binding<T>, config?: BindingConfig | DefaultBindingOptions): CaptureType<T>;
+export declare function normalizeBinding<TSource = any, TReturn = any, TParent = any>(value: Expression<TSource, TReturn, TParent> | Binding<TSource, TReturn, TParent> | {}): Binding<TSource, TReturn, TParent>;

package/dist/dts/templating/html-directive.d.ts

@@ -1,6 +1,7 @@
 import type { Constructable } from "../interfaces.js";
 import type { Behavior } from "../observation/behavior.js";
-import type { Binding, ExecutionContext } from "../observation/observable.js";
+import type { Subscriber } from "../observation/notifier.js";
+import type { ExecutionContext, Expression, ExpressionObserver } from "../observation/observable.js";
 /**
  * The target nodes available to a behavior.
  * @public
@@ -113,6 +114,31 @@ export declare const HTMLDirective: Readonly<{
  * @public
  */
 export declare function htmlDirective(options?: PartialHTMLDirectiveDefinition): (type: Constructable<HTMLDirective>) => void;
+/**
+ * Captures a binding expression along with related information and capabilities.
+ *
+ * @public
+ */
+export declare abstract class Binding<TSource = any, TReturn = any, TParent = any> {
+    /**
+     * Options associated with the binding.
+     */
+    options?: any;
+    /**
+     * Whether or not the binding is volatile.
+     */
+    isVolatile?: boolean;
+    /**
+     * Evaluates the binding expression.
+     */
+    evaluate: Expression<TSource, TReturn, TParent>;
+    /**
+     * Creates an observer capable of notifying a subscriber when the output of a binding changes.
+     * @param directive - The HTML Directive to create the observer for.
+     * @param subscriber - The subscriber to changes in the binding.
+     */
+    abstract createObserver(directive: HTMLDirective, subscriber: Subscriber): ExpressionObserver<TSource, TReturn, TParent>;
+}
 /**
  * The type of HTML aspect to target.
  * @public
@@ -180,7 +206,7 @@ export interface Aspected {
     /**
      * A binding if one is associated with the aspect.
      */
-    binding?: Binding;
+    dataBinding?: Binding;
 }
 /**
  * A base class used for attribute directives that don't need internal state.

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

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