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

package/dist/esm/templating/binding.js

@@ -1,9 +1,9 @@
-import { isString } from "../interfaces.js";
+import { isFunction } from "../interfaces.js";
 import { ExecutionContext, Observable, } from "../observation/observable.js";
 import { FAST } from "../platform.js";
 import { DOM } from "./dom.js";
-import { Aspect, HTMLDirective, } from "./html-directive.js";
-import { Markup } from "./markup.js";
+import { Aspect, Binding, HTMLDirective, } from "./html-directive.js";
+import { Markup, nextId } from "./markup.js";
 const createInnerHTMLBinding = globalThis.TrustedHTML
     ? (binding) => (s, c) => {
         const value = binding(s, c);
@@ -13,107 +13,26 @@ const createInnerHTMLBinding = globalThis.TrustedHTML
         throw FAST.error(1202 /* Message.bindingInnerHTMLRequiresTrustedTypes */);
     }
     : (binding) => binding;
-/**
- * Describes how aspects of an HTML element will be affected by bindings.
- * @public
- */
-export const BindingMode = Object.freeze({
-    /**
-     * 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, EventType = EventBinding) {
-        return Object.freeze({
-            [1]: d => new UpdateType(d, DOM.setAttribute),
-            [2]: d => new UpdateType(d, DOM.setBooleanAttribute),
-            [3]: d => new UpdateType(d, (t, a, v) => (t[a] = v)),
-            [4]: d => new (createContentBinding(UpdateType))(d, updateContentTarget),
-            [5]: d => new UpdateType(d, updateTokenListTarget),
-            [6]: d => new EventType(d),
-        });
-    },
-});
-/**
- * Describes the configuration for a binding expression.
- * @public
- */
-export const BindingConfig = Object.freeze({
-    /**
-     * 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(mode, defaultOptions) {
-        const config = (options) => {
-            return {
-                mode: config.mode,
-                options: Object.assign({}, defaultOptions, options),
-            };
-        };
-        config.options = defaultOptions;
-        config.mode = mode;
-        return config;
-    },
-});
-/**
- * A base binding behavior for DOM updates.
- * @public
- */
-export class UpdateBinding {
-    /**
-     * 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, updateTarget) {
-        this.directive = directive;
-        this.updateTarget = updateTarget;
+class OnChangeBinding extends Binding {
+    createObserver(_, subscriber) {
+        return Observable.binding(this.evaluate, subscriber, this.isVolatile);
     }
-    /**
-     * 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, context, targets) { }
-    /**
-     * 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, context, targets) { }
-    /**
-     * Creates a behavior.
-     * @param targets - The targets available for behaviors to be attached to.
-     */
-    createBehavior(targets) {
+}
+class OneTimeBinding extends Binding {
+    createObserver() {
         return this;
     }
+    bind(controller) {
+        return this.evaluate(controller.source, controller.context);
+    }
 }
-function createContentBinding(Type) {
-    return class extends Type {
-        unbind(source, context, targets) {
-            super.unbind(source, context, targets);
-            const target = targets[this.directive.nodeId];
-            const view = target.$fastView;
-            if (view !== void 0 && view.isComposed) {
-                view.unbind();
-                view.needsBindOnly = true;
-            }
-        }
-    };
-}
-function updateContentTarget(target, aspect, value, source, context) {
+function updateContent(target, aspect, value, controller) {
     // If there's no actual value, then this equates to the
     // empty string for the purposes of content bindings.
     if (value === null || value === undefined) {
         value = "";
     }
-    // If the value has a "create" method, then it's a template-like.
+    // If the value has a "create" method, then it's a ContentTemplate.
     if (value.create) {
         target.textContent = "";
         let view = target.$fastView;
@@ -139,14 +58,14 @@ function updateContentTarget(target, aspect, value, source, context) {
         // and that there's actually no need to compose it.
         if (!view.isComposed) {
             view.isComposed = true;
-            view.bind(source, context);
+            view.bind(controller.source, controller.context);
             view.insertBefore(target);
             target.$fastView = view;
             target.$fastTemplate = value;
         }
         else if (view.needsBindOnly) {
             view.needsBindOnly = false;
-            view.bind(source, context);
+            view.bind(controller.source, controller.context);
         }
     }
     else {
@@ -166,10 +85,9 @@ function updateContentTarget(target, aspect, value, source, context) {
         target.textContent = value;
     }
 }
-function updateTokenListTarget(target, aspect, value) {
+function updateTokenList(target, aspect, value) {
     var _a;
-    const directive = this.directive;
-    const lookup = `${directive.id}-t`;
+    const lookup = `${this.id}-t`;
     const state = (_a = target[lookup]) !== null && _a !== void 0 ? _a : (target[lookup] = { c: 0, v: Object.create(null) });
     const versions = state.v;
     let currentVersion = state.c;
@@ -199,364 +117,166 @@ function updateTokenListTarget(target, aspect, value) {
         }
     }
 }
+const setProperty = (t, a, v) => (t[a] = v);
+const eventTarget = () => void 0;
 /**
- * A binding behavior for one-time bindings.
+ * A directive that applies bindings.
  * @public
  */
-export class OneTimeBinding extends UpdateBinding {
+export class 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.
+     * Creates an instance of HTMLBindingDirective.
+     * @param dataBinding - The binding configuration to apply.
      */
-    bind(source, context, targets) {
-        const directive = this.directive;
-        this.updateTarget(targets[directive.nodeId], directive.targetAspect, directive.binding(source, context), source, context);
-    }
-}
-const signals = Object.create(null);
-/**
- * A binding behavior for signal bindings.
- * @public
- */
-export class SignalBinding extends UpdateBinding {
-    constructor() {
-        super(...arguments);
-        this.handlerProperty = `${this.directive.id}-h`;
+    constructor(dataBinding) {
+        this.dataBinding = dataBinding;
+        this.updateTarget = null;
+        /**
+         * The unique id of the factory.
+         */
+        this.id = nextId();
+        /**
+         * The type of aspect to target.
+         */
+        this.aspectType = Aspect.content;
+        /** @internal */
+        this.bind = this.bindDefault;
+        this.data = `${this.id}-d`;
     }
     /**
-     * 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 HTML to be used within a template.
+     * @param add - Can be used to add  behavior factories to a template.
      */
-    bind(source, context, targets) {
-        const directive = this.directive;
-        const target = targets[directive.nodeId];
-        const signal = this.getSignal(source, context);
-        const handler = (target[this.handlerProperty] = () => {
-            this.updateTarget(target, directive.targetAspect, directive.binding(source, context), source, context);
-        });
-        handler();
-        const found = signals[signal];
-        if (found) {
-            Array.isArray(found)
-                ? found.push(handler)
-                : (signals[signal] = [found, handler]);
-        }
-        else {
-            signals[signal] = handler;
-        }
+    createHTML(add) {
+        return Markup.interpolation(add(this));
     }
     /**
-     * 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.
+     * Creates a behavior.
      */
-    unbind(source, context, targets) {
-        const signal = this.getSignal(source, context);
-        const found = signals[signal];
-        if (found && Array.isArray(found)) {
-            const directive = this.directive;
-            const target = targets[directive.nodeId];
-            const handler = target[this.handlerProperty];
-            const index = found.indexOf(handler);
-            if (index !== -1) {
-                found.splice(index, 1);
+    createBehavior() {
+        if (this.updateTarget === null) {
+            if (this.targetAspect === "innerHTML") {
+                this.dataBinding.evaluate = createInnerHTMLBinding(this.dataBinding.evaluate);
+            }
+            switch (this.aspectType) {
+                case 1:
+                    this.updateTarget = DOM.setAttribute;
+                    break;
+                case 2:
+                    this.updateTarget = DOM.setBooleanAttribute;
+                    break;
+                case 3:
+                    this.updateTarget = setProperty;
+                    break;
+                case 4:
+                    this.bind = this.bindContent;
+                    this.updateTarget = updateContent;
+                    break;
+                case 5:
+                    this.updateTarget = updateTokenList;
+                    break;
+                case 6:
+                    this.bind = this.bindEvent;
+                    this.updateTarget = eventTarget;
+                    break;
+                default:
+                    throw FAST.error(1205 /* Message.unsupportedBindingBehavior */);
             }
         }
-        else {
-            signals[signal] = void 0;
-        }
-    }
-    getSignal(source, context) {
-        const options = this.directive.options;
-        return isString(options) ? options : options(source, context);
-    }
-    /**
-     * Sends the specified signal to signaled bindings.
-     * @param signal - The signal to send.
-     * @public
-     */
-    static send(signal) {
-        const found = signals[signal];
-        if (found) {
-            Array.isArray(found) ? found.forEach(x => x()) : found();
-        }
-    }
-}
-/**
- * A binding behavior for bindings that change.
- * @public
- */
-export class ChangeBinding extends UpdateBinding {
-    /**
-     * 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, updateTarget) {
-        super(directive, updateTarget);
-        this.isBindingVolatile = Observable.isVolatileBinding(directive.binding);
-        this.observerProperty = `${directive.id}-o`;
+        return this;
     }
-    /**
-     * Returns the binding observer used to update the node.
-     * @param target - The target node.
-     * @returns A BindingObserver.
-     */
-    getObserver(target) {
+    /** @internal */
+    bindDefault(controller) {
         var _a;
-        return ((_a = target[this.observerProperty]) !== null && _a !== void 0 ? _a : (target[this.observerProperty] = Observable.binding(this.directive.binding, this, this.isBindingVolatile)));
-    }
-    /**
-     * 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, context, targets) {
-        const directive = this.directive;
-        const target = targets[directive.nodeId];
-        const observer = this.getObserver(target);
+        const target = controller.targets[this.nodeId];
+        const observer = (_a = target[this.data]) !== null && _a !== void 0 ? _a : (target[this.data] = this.dataBinding.createObserver(this, this));
         observer.target = target;
-        observer.source = source;
-        observer.context = context;
-        this.updateTarget(target, directive.targetAspect, observer.observe(source, context), source, context);
-    }
-    /**
-     * 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, context, targets) {
-        const target = targets[this.directive.nodeId];
-        const observer = this.getObserver(target);
-        observer.dispose();
-        observer.target = null;
-        observer.source = null;
-        observer.context = null;
+        observer.controller = controller;
+        this.updateTarget(target, this.targetAspect, observer.bind(controller), controller);
+        if (this.updateTarget === updateContent) {
+            controller.onUnbind(this);
+        }
     }
     /** @internal */
-    handleChange(binding, observer) {
-        const target = observer.target;
-        const source = observer.source;
-        const context = observer.context;
-        this.updateTarget(target, this.directive.targetAspect, observer.observe(source, context), source, context);
-    }
-}
-/**
- * A binding behavior for handling events.
- * @public
- */
-export class EventBinding {
-    /**
-     * Creates an instance of EventBinding.
-     * @param directive - The directive that has the configuration for this behavior.
-     */
-    constructor(directive) {
-        this.directive = directive;
-        this.sourceProperty = `${directive.id}-s`;
-        this.contextProperty = `${directive.id}-c`;
+    bindContent(controller) {
+        this.bindDefault(controller);
+        controller.onUnbind(this);
     }
-    /**
-     * 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, context, targets) {
-        const directive = this.directive;
-        const target = targets[directive.nodeId];
-        target[this.sourceProperty] = source;
-        target[this.contextProperty] = context;
-        target.addEventListener(directive.targetAspect, this, directive.options);
-    }
-    /**
-     * 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, context, targets) {
-        const directive = this.directive;
-        const target = targets[directive.nodeId];
-        target[this.sourceProperty] = target[this.contextProperty] = null;
-        target.removeEventListener(directive.targetAspect, this, directive.options);
+    /** @internal */
+    bindEvent(controller) {
+        const target = controller.targets[this.nodeId];
+        target[this.data] = controller;
+        target.addEventListener(this.targetAspect, this, this.dataBinding.options);
     }
-    /**
-     * Creates a behavior.
-     * @param targets - The targets available for behaviors to be attached to.
-     */
-    createBehavior(targets) {
-        return this;
+    /** @internal */
+    unbind(controller) {
+        const target = controller.targets[this.nodeId];
+        const view = target.$fastView;
+        if (view !== void 0 && view.isComposed) {
+            view.unbind();
+            view.needsBindOnly = true;
+        }
     }
-    /**
-     * @internal
-     */
+    /** @internal */
     handleEvent(event) {
         const target = event.currentTarget;
         ExecutionContext.setEvent(event);
-        const result = this.directive.binding(target[this.sourceProperty], target[this.contextProperty]);
+        const controller = target[this.data];
+        const result = this.dataBinding.evaluate(controller.source, controller.context);
         ExecutionContext.setEvent(null);
         if (result !== true) {
             event.preventDefault();
         }
     }
-}
-let twoWaySettings = {
-    determineChangeEvent() {
-        return "change";
-    },
-};
-/**
- * A binding behavior for bindings that update in two directions.
- * @public
- */
-export class TwoWayBinding extends ChangeBinding {
-    /**
-     * 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, context, targets) {
-        var _a;
-        super.bind(source, context, targets);
-        const directive = this.directive;
-        const target = targets[directive.nodeId];
-        if (!this.changeEvent) {
-            this.changeEvent =
-                (_a = directive.options.changeEvent) !== null && _a !== void 0 ? _a : twoWaySettings.determineChangeEvent(directive, target);
-        }
-        target.addEventListener(this.changeEvent, this);
-    }
-    /**
-     * 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, context, targets) {
-        super.unbind(source, context, targets);
-        targets[this.directive.nodeId].removeEventListener(this.changeEvent, this);
-    }
     /** @internal */
-    handleEvent(event) {
-        const directive = this.directive;
-        const target = event.currentTarget;
-        let value;
-        switch (directive.aspectType) {
-            case 1:
-                value = target.getAttribute(directive.targetAspect);
-                break;
-            case 2:
-                value = target.hasAttribute(directive.targetAspect);
-                break;
-            case 4:
-                value = target.innerText;
-                break;
-            default:
-                value = target[directive.targetAspect];
-                break;
-        }
-        const observer = this.getObserver(target);
-        const last = observer.last; // using internal API!!!
-        last.propertySource[last.propertyName] = directive.options.fromView(value);
-    }
-    /**
-     * Configures two-way binding.
-     * @param settings - The settings to use for the two-way binding system.
-     */
-    static configure(settings) {
-        twoWaySettings = settings;
+    handleChange(binding, observer) {
+        const target = observer.target;
+        const controller = observer.controller;
+        this.updateTarget(target, this.targetAspect, observer.bind(controller), controller);
     }
 }
+HTMLDirective.define(HTMLBindingDirective, { aspected: true });
 /**
- * The default onChange binding configuration.
- * @public
- */
-export const onChange = BindingConfig.define(BindingMode.define(ChangeBinding), {});
-/**
- * The default twoWay binding configuration.
- * @public
- */
-export const twoWay = BindingConfig.define(BindingMode.define(TwoWayBinding), {
-    fromView: v => v,
-});
-/**
- * The default onTime binding configuration.
+ * 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 const oneTime = BindingConfig.define(BindingMode.define(OneTimeBinding), {
-    once: true,
-});
-const signalMode = BindingMode.define(SignalBinding);
+export function bind(binding, isVolatile = Observable.isVolatileBinding(binding)) {
+    return new OnChangeBinding(binding, isVolatile);
+}
 /**
- * Creates a signal binding configuration with the supplied options.
- * @param options - The signal name or a binding to use to retrieve the signal name.
+ * Creates a one time binding
+ * @param binding - The binding to refresh when signaled.
  * @returns A binding configuration.
  * @public
  */
-export const signal = (options) => {
-    return { mode: signalMode, options };
-};
+export function oneTime(binding) {
+    return new OneTimeBinding(binding);
+}
 /**
- * A directive that applies bindings.
+ * 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 class HTMLBindingDirective {
-    /**
-     * 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, mode, options) {
-        this.binding = binding;
-        this.mode = mode;
-        this.options = options;
-        this.factory = null;
-        /**
-         * The type of aspect to target.
-         */
-        this.aspectType = Aspect.content;
-    }
-    /**
-     * Creates HTML to be used within a template.
-     * @param add - Can be used to add  behavior factories to a template.
-     */
-    createHTML(add) {
-        return Markup.interpolation(add(this));
-    }
-    /**
-     * Creates a behavior.
-     * @param targets - The targets available for behaviors to be attached to.
-     */
-    createBehavior(targets) {
-        if (this.factory == null) {
-            if (this.targetAspect === "innerHTML") {
-                this.binding = createInnerHTMLBinding(this.binding);
-            }
-            this.factory = this.mode[this.aspectType](this);
-        }
-        return this.factory.createBehavior(targets);
-    }
+export function listener(binding, options) {
+    const config = new OnChangeBinding(binding, false);
+    config.options = options;
+    return config;
 }
-HTMLDirective.define(HTMLBindingDirective, { aspected: true });
 /**
- * Creates a binding directive with the specified configuration.
- * @param binding - The binding expression.
- * @param config - The binding configuration.
- * @returns A binding directive.
+ * 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 function bind(binding, config = onChange) {
-    if (!("mode" in config)) {
-        config = onChange(config);
-    }
-    return new HTMLBindingDirective(binding, config.mode, config.options);
+export function normalizeBinding(value) {
+    return isFunction(value)
+        ? bind(value)
+        : value instanceof Binding
+            ? value
+            : oneTime(() => value);
 }