@vonage/vivid 5.15.1 → 5.17.0

package/unbundled/anchored.cjs

@@ -1,97 +1,90 @@
-'use strict';
-
-const fastElement = require('@microsoft/fast-element');
-
-var __defProp = Object.defineProperty;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = void 0 ;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (decorator(target, key, result) ) || result;
-  if (result) __defProp(target, key, result);
-  return result;
+require("./chunk.cjs");
+const require_decorate = require("./decorate.cjs");
+let _microsoft_fast_element = require("@microsoft/fast-element");
+//#region src/shared/patterns/anchored.ts
+/**
+* Mixin for elements that are anchored to another element.
+* The anchor can be specified either through the anchor slot or by using the anchor prop with an ID or direct reference.
+* The resolved anchor element is available as `_anchorEl` while the element is connected.
+*/
+var Anchored = (Base) => {
+	class AnchoredElement extends Base {
+		/**
+		* @internal
+		*/
+		anchorChanged() {
+			this.#updateAnchorEl();
+		}
+		/**
+		* @internal
+		*/
+		_slottedAnchorChanged() {
+			const isOccupied = Boolean(this._slottedAnchor && this._slottedAnchor.length > 0);
+			_microsoft_fast_element.DOM.setBooleanAttribute(this, "slotted-anchor", isOccupied);
+			this.#updateAnchorEl();
+		}
+		#updateAnchorEl = () => {
+			if (!this.isConnected) {
+				this._anchorEl = void 0;
+				return;
+			}
+			this.#cleanupObserverIfNeeded();
+			let newAnchor = void 0;
+			if (this._slottedAnchor && this._slottedAnchor.length > 0) newAnchor = this._slottedAnchor[0];
+			else if (this.anchor instanceof HTMLElement) newAnchor = this.anchor;
+			else if (typeof this.anchor === "string") {
+				newAnchor = document.getElementById(this.anchor) ?? void 0;
+				if (!newAnchor) this.#observeMissingAnchor(this.anchor);
+			}
+			this._anchorEl = newAnchor;
+		};
+		#observer;
+		#observeMissingAnchor = (anchorId) => {
+			this.#observer = new MutationObserver(() => {
+				const anchor = document.getElementById(anchorId);
+				if (anchor) {
+					this._anchorEl = anchor;
+					this.#cleanupObserverIfNeeded();
+				}
+			});
+			this.#observer.observe(document.body, {
+				childList: true,
+				subtree: true
+			});
+		};
+		#cleanupObserverIfNeeded = () => {
+			this.#observer?.disconnect();
+			this.#observer = void 0;
+		};
+		connectedCallback() {
+			super.connectedCallback();
+			this.#updateAnchorEl();
+		}
+		disconnectedCallback() {
+			super.disconnectedCallback();
+			this.#cleanupObserverIfNeeded();
+			this._anchorEl = void 0;
+		}
+	}
+	require_decorate.__decorate([_microsoft_fast_element.attr], AnchoredElement.prototype, "anchor", void 0);
+	require_decorate.__decorate([_microsoft_fast_element.observable], AnchoredElement.prototype, "_slottedAnchor", void 0);
+	require_decorate.__decorate([_microsoft_fast_element.observable], AnchoredElement.prototype, "_anchorEl", void 0);
+	return AnchoredElement;
 };
-const Anchored = (Base) => {
-  class AnchoredElement extends Base {
-    /**
-     * @internal
-     */
-    anchorChanged() {
-      this.#updateAnchorEl();
-    }
-    /**
-     * @internal
-     */
-    _slottedAnchorChanged() {
-      const isOccupied = Boolean(
-        this._slottedAnchor && this._slottedAnchor.length > 0
-      );
-      fastElement.DOM.setBooleanAttribute(
-        this,
-        "slotted-anchor",
-        isOccupied
-      );
-      this.#updateAnchorEl();
-    }
-    #updateAnchorEl = () => {
-      if (!this.isConnected) {
-        this._anchorEl = void 0;
-        return;
-      }
-      this.#cleanupObserverIfNeeded();
-      let newAnchor = void 0;
-      if (this._slottedAnchor && this._slottedAnchor.length > 0) {
-        newAnchor = this._slottedAnchor[0];
-      } else if (this.anchor instanceof HTMLElement) {
-        newAnchor = this.anchor;
-      } else if (typeof this.anchor === "string") {
-        newAnchor = document.getElementById(this.anchor) ?? void 0;
-        if (!newAnchor) {
-          this.#observeMissingAnchor(this.anchor);
-        }
-      }
-      this._anchorEl = newAnchor;
-    };
-    #observer;
-    #observeMissingAnchor = (anchorId) => {
-      this.#observer = new MutationObserver(() => {
-        const anchor = document.getElementById(anchorId);
-        if (anchor) {
-          this._anchorEl = anchor;
-          this.#cleanupObserverIfNeeded();
-        }
-      });
-      this.#observer.observe(document.body, { childList: true, subtree: true });
-    };
-    #cleanupObserverIfNeeded = () => {
-      this.#observer?.disconnect();
-      this.#observer = void 0;
-    };
-    connectedCallback() {
-      super.connectedCallback();
-      this.#updateAnchorEl();
-    }
-    disconnectedCallback() {
-      super.disconnectedCallback();
-      this.#cleanupObserverIfNeeded();
-      this._anchorEl = void 0;
-    }
-  }
-  __decorateClass([
-    fastElement.attr
-  ], AnchoredElement.prototype, "anchor");
-  __decorateClass([
-    fastElement.observable
-  ], AnchoredElement.prototype, "_slottedAnchor");
-  __decorateClass([
-    fastElement.observable
-  ], AnchoredElement.prototype, "_anchorEl");
-  return AnchoredElement;
-};
-const anchorSlotTemplateFactory = () => fastElement.html`<slot
+var anchorSlotTemplateFactory = () => _microsoft_fast_element.html`<slot
 		name="anchor"
-		${fastElement.slotted("_slottedAnchor")}
+		${(0, _microsoft_fast_element.slotted)("_slottedAnchor")}
 	></slot>`;
-
-exports.Anchored = Anchored;
-exports.anchorSlotTemplateFactory = anchorSlotTemplateFactory;
+//#endregion
+Object.defineProperty(exports, "Anchored", {
+	enumerable: true,
+	get: function() {
+		return Anchored;
+	}
+});
+Object.defineProperty(exports, "anchorSlotTemplateFactory", {
+	enumerable: true,
+	get: function() {
+		return anchorSlotTemplateFactory;
+	}
+});

package/unbundled/anchored.js

@@ -1,94 +1,78 @@
-import { attr, observable, DOM, slotted, html } from '@microsoft/fast-element';
-
-var __defProp = Object.defineProperty;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = void 0 ;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (decorator(target, key, result) ) || result;
-  if (result) __defProp(target, key, result);
-  return result;
+import { t as __decorate } from "./decorate.js";
+import { DOM, attr, html, observable, slotted } from "@microsoft/fast-element";
+//#region src/shared/patterns/anchored.ts
+/**
+* Mixin for elements that are anchored to another element.
+* The anchor can be specified either through the anchor slot or by using the anchor prop with an ID or direct reference.
+* The resolved anchor element is available as `_anchorEl` while the element is connected.
+*/
+var Anchored = (Base) => {
+	class AnchoredElement extends Base {
+		/**
+		* @internal
+		*/
+		anchorChanged() {
+			this.#updateAnchorEl();
+		}
+		/**
+		* @internal
+		*/
+		_slottedAnchorChanged() {
+			const isOccupied = Boolean(this._slottedAnchor && this._slottedAnchor.length > 0);
+			DOM.setBooleanAttribute(this, "slotted-anchor", isOccupied);
+			this.#updateAnchorEl();
+		}
+		#updateAnchorEl = () => {
+			if (!this.isConnected) {
+				this._anchorEl = void 0;
+				return;
+			}
+			this.#cleanupObserverIfNeeded();
+			let newAnchor = void 0;
+			if (this._slottedAnchor && this._slottedAnchor.length > 0) newAnchor = this._slottedAnchor[0];
+			else if (this.anchor instanceof HTMLElement) newAnchor = this.anchor;
+			else if (typeof this.anchor === "string") {
+				newAnchor = document.getElementById(this.anchor) ?? void 0;
+				if (!newAnchor) this.#observeMissingAnchor(this.anchor);
+			}
+			this._anchorEl = newAnchor;
+		};
+		#observer;
+		#observeMissingAnchor = (anchorId) => {
+			this.#observer = new MutationObserver(() => {
+				const anchor = document.getElementById(anchorId);
+				if (anchor) {
+					this._anchorEl = anchor;
+					this.#cleanupObserverIfNeeded();
+				}
+			});
+			this.#observer.observe(document.body, {
+				childList: true,
+				subtree: true
+			});
+		};
+		#cleanupObserverIfNeeded = () => {
+			this.#observer?.disconnect();
+			this.#observer = void 0;
+		};
+		connectedCallback() {
+			super.connectedCallback();
+			this.#updateAnchorEl();
+		}
+		disconnectedCallback() {
+			super.disconnectedCallback();
+			this.#cleanupObserverIfNeeded();
+			this._anchorEl = void 0;
+		}
+	}
+	__decorate([attr], AnchoredElement.prototype, "anchor", void 0);
+	__decorate([observable], AnchoredElement.prototype, "_slottedAnchor", void 0);
+	__decorate([observable], AnchoredElement.prototype, "_anchorEl", void 0);
+	return AnchoredElement;
 };
-const Anchored = (Base) => {
-  class AnchoredElement extends Base {
-    /**
-     * @internal
-     */
-    anchorChanged() {
-      this.#updateAnchorEl();
-    }
-    /**
-     * @internal
-     */
-    _slottedAnchorChanged() {
-      const isOccupied = Boolean(
-        this._slottedAnchor && this._slottedAnchor.length > 0
-      );
-      DOM.setBooleanAttribute(
-        this,
-        "slotted-anchor",
-        isOccupied
-      );
-      this.#updateAnchorEl();
-    }
-    #updateAnchorEl = () => {
-      if (!this.isConnected) {
-        this._anchorEl = void 0;
-        return;
-      }
-      this.#cleanupObserverIfNeeded();
-      let newAnchor = void 0;
-      if (this._slottedAnchor && this._slottedAnchor.length > 0) {
-        newAnchor = this._slottedAnchor[0];
-      } else if (this.anchor instanceof HTMLElement) {
-        newAnchor = this.anchor;
-      } else if (typeof this.anchor === "string") {
-        newAnchor = document.getElementById(this.anchor) ?? void 0;
-        if (!newAnchor) {
-          this.#observeMissingAnchor(this.anchor);
-        }
-      }
-      this._anchorEl = newAnchor;
-    };
-    #observer;
-    #observeMissingAnchor = (anchorId) => {
-      this.#observer = new MutationObserver(() => {
-        const anchor = document.getElementById(anchorId);
-        if (anchor) {
-          this._anchorEl = anchor;
-          this.#cleanupObserverIfNeeded();
-        }
-      });
-      this.#observer.observe(document.body, { childList: true, subtree: true });
-    };
-    #cleanupObserverIfNeeded = () => {
-      this.#observer?.disconnect();
-      this.#observer = void 0;
-    };
-    connectedCallback() {
-      super.connectedCallback();
-      this.#updateAnchorEl();
-    }
-    disconnectedCallback() {
-      super.disconnectedCallback();
-      this.#cleanupObserverIfNeeded();
-      this._anchorEl = void 0;
-    }
-  }
-  __decorateClass([
-    attr
-  ], AnchoredElement.prototype, "anchor");
-  __decorateClass([
-    observable
-  ], AnchoredElement.prototype, "_slottedAnchor");
-  __decorateClass([
-    observable
-  ], AnchoredElement.prototype, "_anchorEl");
-  return AnchoredElement;
-};
-const anchorSlotTemplateFactory = () => html`<slot
+var anchorSlotTemplateFactory = () => html`<slot
 		name="anchor"
 		${slotted("_slottedAnchor")}
 	></slot>`;
-
-export { Anchored as A, anchorSlotTemplateFactory as a };
+//#endregion
+export { anchorSlotTemplateFactory as n, Anchored as t };

package/unbundled/attribute-binding-behaviour.cjs

@@ -1,42 +1,37 @@
-'use strict';
-
-const fastElement = require('@microsoft/fast-element');
-
-class AttributeBindingBehavior {
-  constructor(target, binding, isBindingVolatile, attributeName) {
-    this.target = target;
-    this.binding = binding;
-    this.isBindingVolatile = isBindingVolatile;
-    this.attributeName = attributeName;
-    this.source = null;
-    this.context = null;
-  }
-  bind(controller) {
-    this.source = controller.source;
-    this.context = controller.context;
-    if (!this.bindingObserver) {
-      this.bindingObserver = fastElement.Observable.binding(
-        this.binding.evaluate,
-        this,
-        this.isBindingVolatile
-      );
-    }
-    this.bindingObserver.observe(this.source, this.context);
-    this.updateTarget(this.bindingObserver.observe(this.source, this.context));
-  }
-  // unbind() {
-  // 	this.bindingObserver!.dispose();
-  // 	this.source = null;
-  // 	this.context = null;
-  // }
-  handleChange() {
-    this.updateTarget(
-      this.bindingObserver.observe(this.source, this.context)
-    );
-  }
-  updateTarget(value) {
-    fastElement.DOM.setAttribute(this.target, this.attributeName, value);
-  }
-}
-
-exports.AttributeBindingBehavior = AttributeBindingBehavior;
+require("./chunk.cjs");
+let _microsoft_fast_element = require("@microsoft/fast-element");
+//#region src/shared/templating/attribute-binding-behaviour.ts
+/**
+* Binds a binding to an attribute of the target element.
+*/
+var AttributeBindingBehavior = class {
+	constructor(target, binding, isBindingVolatile, attributeName) {
+		this.target = target;
+		this.binding = binding;
+		this.isBindingVolatile = isBindingVolatile;
+		this.attributeName = attributeName;
+		this.source = null;
+		this.context = null;
+	}
+	bind(controller) {
+		this.source = controller.source;
+		this.context = controller.context;
+		/* v8 ignore else -- @preserve */
+		if (!this.bindingObserver) this.bindingObserver = _microsoft_fast_element.Observable.binding(this.binding.evaluate, this, this.isBindingVolatile);
+		this.bindingObserver.observe(this.source, this.context);
+		this.updateTarget(this.bindingObserver.observe(this.source, this.context));
+	}
+	handleChange() {
+		this.updateTarget(this.bindingObserver.observe(this.source, this.context));
+	}
+	updateTarget(value) {
+		_microsoft_fast_element.DOM.setAttribute(this.target, this.attributeName, value);
+	}
+};
+//#endregion
+Object.defineProperty(exports, "AttributeBindingBehavior", {
+	enumerable: true,
+	get: function() {
+		return AttributeBindingBehavior;
+	}
+});

package/unbundled/attribute-binding-behaviour.js

@@ -1,40 +1,31 @@
-import { Observable, DOM } from '@microsoft/fast-element';
-
-class AttributeBindingBehavior {
-  constructor(target, binding, isBindingVolatile, attributeName) {
-    this.target = target;
-    this.binding = binding;
-    this.isBindingVolatile = isBindingVolatile;
-    this.attributeName = attributeName;
-    this.source = null;
-    this.context = null;
-  }
-  bind(controller) {
-    this.source = controller.source;
-    this.context = controller.context;
-    if (!this.bindingObserver) {
-      this.bindingObserver = Observable.binding(
-        this.binding.evaluate,
-        this,
-        this.isBindingVolatile
-      );
-    }
-    this.bindingObserver.observe(this.source, this.context);
-    this.updateTarget(this.bindingObserver.observe(this.source, this.context));
-  }
-  // unbind() {
-  // 	this.bindingObserver!.dispose();
-  // 	this.source = null;
-  // 	this.context = null;
-  // }
-  handleChange() {
-    this.updateTarget(
-      this.bindingObserver.observe(this.source, this.context)
-    );
-  }
-  updateTarget(value) {
-    DOM.setAttribute(this.target, this.attributeName, value);
-  }
-}
-
-export { AttributeBindingBehavior as A };
+import { DOM, Observable } from "@microsoft/fast-element";
+//#region src/shared/templating/attribute-binding-behaviour.ts
+/**
+* Binds a binding to an attribute of the target element.
+*/
+var AttributeBindingBehavior = class {
+	constructor(target, binding, isBindingVolatile, attributeName) {
+		this.target = target;
+		this.binding = binding;
+		this.isBindingVolatile = isBindingVolatile;
+		this.attributeName = attributeName;
+		this.source = null;
+		this.context = null;
+	}
+	bind(controller) {
+		this.source = controller.source;
+		this.context = controller.context;
+		/* v8 ignore else -- @preserve */
+		if (!this.bindingObserver) this.bindingObserver = Observable.binding(this.binding.evaluate, this, this.isBindingVolatile);
+		this.bindingObserver.observe(this.source, this.context);
+		this.updateTarget(this.bindingObserver.observe(this.source, this.context));
+	}
+	handleChange() {
+		this.updateTarget(this.bindingObserver.observe(this.source, this.context));
+	}
+	updateTarget(value) {
+		DOM.setAttribute(this.target, this.attributeName, value);
+	}
+};
+//#endregion
+export { AttributeBindingBehavior as t };