@vonage/vivid 3.47.0 → 3.49.0-preview.0

package/shared/presentationDate.js

@@ -5683,8 +5683,6 @@ class DatePickerBase extends FormAssociatedDatePickerBase {
         this._closePopup(false);
       }
     };
-    /// Used to stop the popup from immediately opening when closing popup and returning focus to text field
-    this.#isClosingPopup = false;
     this._presentationValue = "";
     this._numCalendars = 1;
     /**
@@ -5790,9 +5788,8 @@ class DatePickerBase extends FormAssociatedDatePickerBase {
     super.validate(this._textFieldEl?.querySelector("input") ?? void 0);
   }
   #dismissOnClickOutside;
-  #isClosingPopup;
   #openPopupIfPossible() {
-    if (!this.readOnly && !this.#isClosingPopup) {
+    if (!this.readOnly) {
       this._popupOpen = true;
     }
   }
@@ -5803,9 +5800,7 @@ class DatePickerBase extends FormAssociatedDatePickerBase {
     this._popupOpen = false;
     this._monthPickerYear = null;
     if (restoreFocusToTextField) {
-      this.#isClosingPopup = true;
       this._textFieldEl.focus();
-      this.#isClosingPopup = false;
     }
   }
   /**

package/shared/radio.cjs

@@ -0,0 +1,153 @@
+'use strict';
+
+const index = require('./index.cjs');
+const formAssociated = require('./form-associated.cjs');
+const keyCodes = require('./key-codes.cjs');
+
+class _Radio extends index.FoundationElement {
+}
+/**
+ * A form-associated base class for the {@link @microsoft/fast-foundation#(Radio:class)} component.
+ *
+ * @internal
+ */
+class FormAssociatedRadio extends formAssociated.CheckableFormAssociated(_Radio) {
+    constructor() {
+        super(...arguments);
+        this.proxy = document.createElement("input");
+    }
+}
+
+/**
+ * A Radio Custom HTML Element.
+ * Implements the {@link https://www.w3.org/TR/wai-aria-1.1/#radio | ARIA radio }.
+ *
+ * @slot checked-indicator - The checked indicator
+ * @slot - The default slot for the label
+ * @csspart control - The element representing the visual radio control
+ * @csspart label - The label
+ * @fires change - Emits a custom change event when the checked state changes
+ *
+ * @public
+ */
+let Radio$1 = class Radio extends FormAssociatedRadio {
+    constructor() {
+        super();
+        /**
+         * The element's value to be included in form submission when checked.
+         * Default to "on" to reach parity with input[type="radio"]
+         *
+         * @internal
+         */
+        this.initialValue = "on";
+        /**
+         * @internal
+         */
+        this.keypressHandler = (e) => {
+            switch (e.key) {
+                case keyCodes.keySpace:
+                    if (!this.checked && !this.readOnly) {
+                        this.checked = true;
+                    }
+                    return;
+            }
+            return true;
+        };
+        this.proxy.setAttribute("type", "radio");
+    }
+    readOnlyChanged() {
+        if (this.proxy instanceof HTMLInputElement) {
+            this.proxy.readOnly = this.readOnly;
+        }
+    }
+    /**
+     * @internal
+     */
+    defaultCheckedChanged() {
+        var _a;
+        if (this.$fastController.isConnected && !this.dirtyChecked) {
+            // Setting this.checked will cause us to enter a dirty state,
+            // but if we are clean when defaultChecked is changed, we want to stay
+            // in a clean state, so reset this.dirtyChecked
+            if (!this.isInsideRadioGroup()) {
+                this.checked = (_a = this.defaultChecked) !== null && _a !== void 0 ? _a : false;
+                this.dirtyChecked = false;
+            }
+        }
+    }
+    /**
+     * @internal
+     */
+    connectedCallback() {
+        var _a, _b;
+        super.connectedCallback();
+        this.validate();
+        if (((_a = this.parentElement) === null || _a === void 0 ? void 0 : _a.getAttribute("role")) !== "radiogroup" &&
+            this.getAttribute("tabindex") === null) {
+            if (!this.disabled) {
+                this.setAttribute("tabindex", "0");
+            }
+        }
+        if (this.checkedAttribute) {
+            if (!this.dirtyChecked) {
+                // Setting this.checked will cause us to enter a dirty state,
+                // but if we are clean when defaultChecked is changed, we want to stay
+                // in a clean state, so reset this.dirtyChecked
+                if (!this.isInsideRadioGroup()) {
+                    this.checked = (_b = this.defaultChecked) !== null && _b !== void 0 ? _b : false;
+                    this.dirtyChecked = false;
+                }
+            }
+        }
+    }
+    isInsideRadioGroup() {
+        const parent = this.closest("[role=radiogroup]");
+        return parent !== null;
+    }
+    /**
+     * @internal
+     */
+    clickHandler(e) {
+        if (!this.disabled && !this.readOnly && !this.checked) {
+            this.checked = true;
+        }
+    }
+};
+index.__decorate([
+    index.attr({ attribute: "readonly", mode: "boolean" })
+], Radio$1.prototype, "readOnly", void 0);
+index.__decorate([
+    index.observable
+], Radio$1.prototype, "name", void 0);
+index.__decorate([
+    index.observable
+], Radio$1.prototype, "defaultSlottedNodes", void 0);
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+class Radio extends Radio$1 {
+  constructor() {
+    super(...arguments);
+    this.ariaLabel = null;
+  }
+}
+__decorateClass([
+  index.attr({ attribute: "aria-label" })
+], Radio.prototype, "ariaLabel", 2);
+__decorateClass([
+  index.attr
+], Radio.prototype, "label", 2);
+__decorateClass([
+  index.attr
+], Radio.prototype, "connotation", 2);
+
+exports.Radio = Radio;

package/shared/ref.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+const index = require('./index.cjs');
+
+/**
+ * The runtime behavior for template references.
+ * @public
+ */
+class RefBehavior {
+    /**
+     * Creates an instance of RefBehavior.
+     * @param target - The element to reference.
+     * @param propertyName - The name of the property to assign the reference to.
+     */
+    constructor(target, propertyName) {
+        this.target = target;
+        this.propertyName = propertyName;
+    }
+    /**
+     * 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) {
+        source[this.propertyName] = this.target;
+    }
+    /**
+     * Unbinds this behavior from the source.
+     * @param source - The source to unbind from.
+     */
+    /* eslint-disable-next-line @typescript-eslint/no-empty-function */
+    unbind() { }
+}
+/**
+ * A directive that observes the updates a property with a reference to the element.
+ * @param propertyName - The name of the property to assign the reference to.
+ * @public
+ */
+function ref(propertyName) {
+    return new index.AttachedBehaviorHTMLDirective("fast-ref", RefBehavior, propertyName);
+}
+
+exports.ref = ref;