@spectrum-web-components/picker 0.36.0 → 0.37.0

package/src/Picker.dev.js

@@ -13,12 +13,12 @@ var __decorateClass = (decorators, target, key, kind) => {
 import {
   html,
   nothing,
-  render,
   SizedMixin
 } from "@spectrum-web-components/base";
 import {
   classMap,
-  ifDefined
+  ifDefined,
+  styleMap
 } from "@spectrum-web-components/base/src/directives.js";
 import {
   property,
@@ -28,15 +28,9 @@ import {
 import pickerStyles from "./picker.css.js";
 import chevronStyles from "@spectrum-web-components/icon/src/spectrum-icon-chevron.css.js";
 import { Focusable } from "@spectrum-web-components/shared/src/focusable.js";
-import { reparentChildren } from "@spectrum-web-components/shared/src/reparent-children.js";
 import "@spectrum-web-components/icons-ui/icons/sp-icon-chevron100.js";
 import "@spectrum-web-components/icons-workflow/icons/sp-icon-alert.js";
 import "@spectrum-web-components/menu/sp-menu.js";
-import "@spectrum-web-components/tray/sp-tray.js";
-import "@spectrum-web-components/popover/sp-popover.js";
-import {
-  openOverlay
-} from "@spectrum-web-components/overlay";
 import {
   IS_MOBILE,
   MatchMediaController
@@ -49,21 +43,22 @@ const chevronClass = {
 };
 export class PickerBase extends SizedMixin(Focusable) {
   constructor() {
-    super();
+    super(...arguments);
     this.isMobile = new MatchMediaController(this, IS_MOBILE);
+    this.deprecatedMenu = null;
     this.disabled = false;
     this.focused = false;
     this.invalid = false;
     this.open = false;
     this.readonly = false;
     this.selects = "single";
-    this.menuItems = [];
     this.placement = "bottom-start";
     this.quiet = false;
     this.value = "";
     this.listRole = "listbox";
     this.itemRole = "option";
-    this.onKeydown = (event) => {
+    this.preventNextToggle = "no";
+    this.handleKeydown = (event) => {
       this.focused = true;
       if (event.code !== "ArrowDown" && event.code !== "ArrowUp") {
         return;
@@ -71,31 +66,49 @@ export class PickerBase extends SizedMixin(Focusable) {
       event.preventDefault();
       this.toggle(true);
     };
-    this.overlayOpenCallback = async () => {
-      this.updateMenuItems();
-      await this.itemsUpdated;
-      await this.optionsMenu.updateComplete;
-      requestAnimationFrame(() => this.menuStateResolver());
-    };
-    this.overlayCloseCallback = async () => {
-      if (this.restoreChildren) {
-        this.restoreChildren();
-        this.restoreChildren = void 0;
-      }
-      this.close();
-      requestAnimationFrame(() => this.menuStateResolver());
-    };
     this.applyFocusElementLabel = (value) => {
       this.appliedLabel = value;
     };
-    this._willUpdateItems = false;
-    this.itemsUpdated = Promise.resolve();
-    this.menuStatePromise = Promise.resolve();
+    this.hasOpened = false;
+    this.willManageSelection = false;
     this.selectionPromise = Promise.resolve();
-    this.onKeydown = this.onKeydown.bind(this);
+    this.recentlyConnected = false;
+    this.enterKeydownOn = null;
+    this.handleEnterKeydown = (event) => {
+      if (event.code !== "Enter") {
+        return;
+      }
+      if (this.enterKeydownOn) {
+        event.preventDefault();
+        return;
+      } else {
+        this.addEventListener(
+          "keyup",
+          (keyupEvent) => {
+            if (keyupEvent.code !== "Enter") {
+              return;
+            }
+            this.enterKeydownOn = null;
+          },
+          { once: true }
+        );
+      }
+      this.enterKeydownOn = this.enterKeydownOn || event.target;
+    };
   }
-  get target() {
-    return this.button;
+  get menuItems() {
+    return this.optionsMenu.childItems;
+  }
+  get selectedItem() {
+    return this._selectedItem;
+  }
+  set selectedItem(selectedItem) {
+    this.selectedItemContent = selectedItem ? selectedItem.itemChildren : void 0;
+    if (selectedItem === this.selectedItem)
+      return;
+    const oldSelectedItem = this.selectedItem;
+    this._selectedItem = selectedItem;
+    this.requestUpdate("selectedItem", oldSelectedItem);
   }
   get focusElement() {
     if (this.open) {
@@ -106,14 +119,33 @@ export class PickerBase extends SizedMixin(Focusable) {
   forceFocusVisible() {
     this.focused = true;
   }
-  onButtonBlur() {
+  handleButtonBlur() {
     this.focused = false;
-    this.target.removeEventListener(
-      "keydown",
-      this.onKeydown
-    );
   }
-  onButtonClick() {
+  handlebuttonPointerdown() {
+    this.preventNextToggle = "maybe";
+    const cleanup = () => {
+      document.removeEventListener("pointerup", cleanup);
+      document.removeEventListener("pointercancel", cleanup);
+      requestAnimationFrame(() => {
+        this.preventNextToggle = "no";
+      });
+    };
+    document.addEventListener("pointerup", cleanup);
+    document.addEventListener("pointercancel", cleanup);
+  }
+  handleButtonFocus(event) {
+    if (this.preventNextToggle === "maybe" && event.relatedTarget === this.optionsMenu) {
+      this.preventNextToggle = "yes";
+    }
+  }
+  handleButtonClick() {
+    if (this.enterKeydownOn && this.enterKeydownOn !== this.button) {
+      return;
+    }
+    if (this.preventNextToggle === "yes") {
+      return;
+    }
     this.toggle();
   }
   focus(options) {
@@ -122,41 +154,36 @@ export class PickerBase extends SizedMixin(Focusable) {
       this.focused = this.hasVisibleFocusInTree();
     }
   }
-  onHelperFocus() {
+  handleHelperFocus() {
     this.focused = true;
     this.button.focus();
   }
-  onButtonFocus() {
-    this.target.addEventListener(
-      "keydown",
-      this.onKeydown
-    );
-  }
   handleChange(event) {
     const target = event.target;
     const [selected] = target.selectedItems;
+    event.stopPropagation();
     if (event.cancelable) {
-      event.stopPropagation();
       this.setValueFromItem(selected, event);
     } else {
       this.open = false;
     }
   }
   async setValueFromItem(item, menuChangeEvent) {
+    this.open = false;
     const oldSelectedItem = this.selectedItem;
     const oldValue = this.value;
     this.selectedItem = item;
     this.value = item.value;
-    this.open = false;
     await this.updateComplete;
     const applyDefault = this.dispatchEvent(
       new Event("change", {
         bubbles: true,
+        // Allow it to be prevented.
         cancelable: true,
         composed: true
       })
     );
-    if (!applyDefault) {
+    if (!applyDefault && this.selects) {
       if (menuChangeEvent) {
         menuChangeEvent.preventDefault();
       }
@@ -168,6 +195,10 @@ export class PickerBase extends SizedMixin(Focusable) {
       this.value = oldValue;
       this.open = true;
       return;
+    } else if (!this.selects) {
+      this.selectedItem = oldSelectedItem;
+      this.value = oldValue;
+      return;
     }
     if (oldSelectedItem) {
       this.setMenuItemSelected(oldSelectedItem, false);
@@ -191,74 +222,23 @@ export class PickerBase extends SizedMixin(Focusable) {
     }
     this.open = false;
   }
-  async generatePopover() {
-    if (!this.popoverFragment) {
-      this.popoverFragment = document.createDocumentFragment();
-    }
-    render(this.renderPopover, this.popoverFragment, { host: this });
-    this.popoverEl = this.popoverFragment.children[0];
-    this.optionsMenu = this.popoverEl.children[1];
-  }
-  async openMenu() {
-    let reparentableChildren = [];
-    const deprecatedMenu = this.querySelector(":scope > sp-menu");
-    await this.generatePopover();
-    if (deprecatedMenu) {
-      reparentableChildren = Array.from(deprecatedMenu.children);
-    } else {
-      reparentableChildren = Array.from(this.children).filter(
-        (element) => {
-          return !element.hasAttribute("slot");
-        }
-      );
-    }
-    if (reparentableChildren.length === 0) {
-      this.menuStateResolver();
-      return;
-    }
-    this.restoreChildren = reparentChildren(reparentableChildren, this.optionsMenu, {
-      position: "beforeend",
-      prepareCallback: (el) => {
-        if (this.value === el.value) {
-          this.setMenuItemSelected(el, true);
-        }
-        return (el2) => {
-          if (typeof el2.focused !== "undefined") {
-            el2.focused = false;
-          }
-        };
-      }
-    });
-    this.sizePopover(this.popoverEl);
-    if (true) {
-      window.__swc.ignoreWarningLevels.deprecation = true;
-    }
-    this.closeOverlay = Picker.openOverlay(this, "modal", this.popoverEl, {
-      placement: this.isMobile.matches ? "none" : this.placement,
-      receivesFocus: "auto"
-    });
-    if (true) {
-      window.__swc.ignoreWarningLevels.deprecation = false;
-    }
-  }
-  sizePopover(popover) {
+  get containerStyles() {
     if (this.isMobile.matches) {
-      popover.style.setProperty("--swc-menu-width", `100%`);
-      return;
-    }
-  }
-  async closeMenu() {
-    if (this.closeOverlay) {
-      const closeOverlay = this.closeOverlay;
-      delete this.closeOverlay;
-      (await closeOverlay)();
+      return {
+        "--swc-menu-width": "100%"
+      };
     }
+    return {};
   }
   get selectedItemContent() {
-    if (this.selectedItem) {
-      return this.selectedItem.itemChildren;
-    }
-    return { icon: [], content: [] };
+    return this._selectedItemContent || { icon: [], content: [] };
+  }
+  set selectedItemContent(selectedItemContent) {
+    if (selectedItemContent === this.selectedItemContent)
+      return;
+    const oldContent = this.selectedItemContent;
+    this._selectedItemContent = selectedItemContent;
+    this.requestUpdate("selectedItemContent", oldContent);
   }
   renderLabelContent(content) {
     if (this.value && this.selectedItem) {
@@ -284,7 +264,6 @@ export class PickerBase extends SizedMixin(Focusable) {
     const appliedLabel = this.appliedLabel || this.label;
     return [
       html`
-                </span>
                 <span id="icon" ?hidden=${this.icons === "none"}>
                     ${this.selectedItemContent.icon}
                 </span>
@@ -292,38 +271,63 @@ export class PickerBase extends SizedMixin(Focusable) {
                     ${this.renderLabelContent(this.selectedItemContent.content)}
                 </span>
                 ${this.value && this.selectedItem ? html`
-                              <span
-                                  aria-hidden="true"
-                                  class="visually-hidden"
-                                  id="applied-label"
-                              >
-                                  ${appliedLabel}
-                                  <slot name="label"></slot>
-                              </span>
-                          ` : html`
-                              <span hidden id="applied-label">
-                                  ${appliedLabel}
-                              </span>
-                          `}
+                          <span
+                              aria-hidden="true"
+                              class="visually-hidden"
+                              id="applied-label"
+                          >
+                              ${appliedLabel}
+                              <slot name="label"></slot>
+                          </span>
+                      ` : html`
+                          <span hidden id="applied-label">${appliedLabel}</span>
+                      `}
                 ${this.invalid ? html`
-                              <sp-icon-alert
-                                  class="validation-icon"
-                              ></sp-icon-alert>
-                          ` : nothing}
+                          <sp-icon-alert
+                              class="validation-icon"
+                          ></sp-icon-alert>
+                      ` : nothing}
                 <sp-icon-chevron100
                     class="picker ${chevronClass[this.size]}"
                 ></sp-icon-chevron100>
             `
     ];
   }
+  renderOverlay(menu) {
+    import("@spectrum-web-components/overlay/sp-overlay.js");
+    return html`
+            <sp-overlay
+                .triggerElement=${this}
+                .offset=${0}
+                ?open=${this.open}
+                .placement=${this.placement}
+                type="auto"
+                .receivesFocus=${"true"}
+                @beforetoggle=${(event) => {
+      if (event.composedPath()[0] !== event.target) {
+        return;
+      }
+      if (event.newState === "closed") {
+        this.open = false;
+      }
+      if (!this.open) {
+        this.optionsMenu.updateSelectedItemIndex();
+        this.optionsMenu.closeDescendentOverlays();
+      }
+    }}
+            >
+                ${this.renderContainer(menu)}
+            </sp-overlay>
+        `;
+  }
   // a helper to throw focus to the button is needed because Safari
   // won't include buttons in the tab order even with tabindex="0"
   render() {
     return html`
             <span
                 id="focus-helper"
-                tabindex="${this.focused ? "-1" : "0"}"
-                @focus=${this.onHelperFocus}
+                tabindex="${this.focused || this.open ? "-1" : "0"}"
+                @focus=${this.handleHelperFocus}
             ></span>
             <button
                 aria-haspopup="true"
@@ -332,38 +336,40 @@ export class PickerBase extends SizedMixin(Focusable) {
                 aria-labelledby="icon label applied-label"
                 id="button"
                 class="button"
-                @blur=${this.onButtonBlur}
-                @click=${this.onButtonClick}
-                @focus=${this.onButtonFocus}
+                @blur=${this.handleButtonBlur}
+                @pointerdown=${this.handlebuttonPointerdown}
+                @focus=${this.handleButtonFocus}
+                @click=${this.handleButtonClick}
+                @keydown=${{
+      handleEvent: this.handleEnterKeydown,
+      capture: true
+    }}
                 ?disabled=${this.disabled}
                 tabindex="-1"
             >
                 ${this.buttonContent}
             </button>
+            ${this.renderMenu}
         `;
   }
   update(changes) {
+    var _a, _b;
     if (this.selects) {
       this.selects = "single";
     }
     if (changes.has("disabled") && this.disabled) {
       this.open = false;
     }
-    if (changes.has("open") && (this.open || typeof changes.get("open") !== "undefined")) {
-      this.menuStatePromise = new Promise(
-        (res) => this.menuStateResolver = res
-      );
-      if (this.open) {
-        this.openMenu();
-      } else {
-        this.closeMenu();
-      }
+    if (changes.has("value")) {
+      this.shouldScheduleManageSelection();
     }
-    if (changes.has("value") && !changes.has("selectedItem")) {
-      this.updateMenuItems();
+    if (!this.hasUpdated) {
+      this.deprecatedMenu = this.querySelector(":scope > sp-menu");
+      (_a = this.deprecatedMenu) == null ? void 0 : _a.toggleAttribute("ignore", true);
+      (_b = this.deprecatedMenu) == null ? void 0 : _b.setAttribute("selects", "inherit");
     }
     if (true) {
-      if (!this.hasUpdated && this.querySelector("sp-menu")) {
+      if (!this.hasUpdated && this.querySelector(":scope > sp-menu")) {
         const { localName } = this;
         window.__swc.warn(
           this,
@@ -375,6 +381,13 @@ export class PickerBase extends SizedMixin(Focusable) {
     }
     super.update(changes);
   }
+  bindButtonKeydownListener() {
+    this.button.addEventListener("keydown", this.handleKeydown);
+  }
+  firstUpdated(changes) {
+    super.firstUpdated(changes);
+    this.bindButtonKeydownListener();
+  }
   get dismissHelper() {
     return html`
             <div class="visually-hidden">
@@ -386,85 +399,88 @@ export class PickerBase extends SizedMixin(Focusable) {
             </div>
         `;
   }
-  get renderPopover() {
-    const content = html`
-            ${this.dismissHelper}
-            <sp-menu
-                id="menu"
-                role="${this.listRole}"
-                @change=${this.handleChange}
-                .selects=${this.selects}
-                size=${this.size}
-            ></sp-menu>
-            ${this.dismissHelper}
+  renderContainer(menu) {
+    const accessibleMenu = html`
+            ${this.dismissHelper} ${menu} ${this.dismissHelper}
         `;
     if (this.isMobile.matches) {
+      import("@spectrum-web-components/tray/sp-tray.js");
       return html`
                 <sp-tray
                     id="popover"
                     role="presentation"
-                    @sp-menu-item-added-or-updated=${this.updateMenuItems}
-                    .overlayOpenCallback=${this.overlayOpenCallback}
-                    .overlayCloseCallback=${this.overlayCloseCallback}
+                    style=${styleMap(this.containerStyles)}
                 >
-                    ${content}
+                    ${accessibleMenu}
                 </sp-tray>
             `;
     }
+    import("@spectrum-web-components/popover/sp-popover.js");
     return html`
             <sp-popover
                 id="popover"
                 role="presentation"
-                @sp-menu-item-added-or-updated=${this.updateMenuItems}
-                .overlayOpenCallback=${this.overlayOpenCallback}
-                .overlayCloseCallback=${this.overlayCloseCallback}
+                style=${styleMap(this.containerStyles)}
+                placement=${this.placement}
             >
-                ${content}
+                ${accessibleMenu}
             </sp-popover>
         `;
   }
-  /**
-   * Acquire the available MenuItems in the Picker by
-   * direct element query or by assuming the list managed
-   * by the Menu within the open options overlay.
-   */
-  updateMenuItems(event) {
-    if (this.open && (event == null ? void 0 : event.type) === "sp-menu-item-removed")
-      return;
-    if (this._willUpdateItems)
-      return;
-    this._willUpdateItems = true;
-    if ((event == null ? void 0 : event.item) === this.selectedItem) {
-      this.requestUpdate();
+  get renderMenu() {
+    const menu = html`
+            <sp-menu
+                aria-labelledby="applied-label"
+                @change=${this.handleChange}
+                id="menu"
+                @keydown=${{
+      handleEvent: this.handleEnterKeydown,
+      capture: true
+    }}
+                role=${this.listRole}
+                .selects=${this.selects}
+                .selected=${this.value ? [this.value] : []}
+                size=${this.size}
+                @sp-menu-item-added-or-updated=${this.shouldManageSelection}
+            >
+                <slot @slotchange=${this.shouldScheduleManageSelection}></slot>
+            </sp-menu>
+        `;
+    this.hasOpened = this.hasOpened || this.open || !!this.deprecatedMenu;
+    if (this.hasOpened) {
+      return this.renderOverlay(menu);
     }
-    let resolve = () => {
+    return menu;
+  }
+  shouldScheduleManageSelection(event) {
+    if (!this.willManageSelection && (!event || event.target.getRootNode().host === this)) {
+      this.willManageSelection = true;
+      requestAnimationFrame(() => {
+        requestAnimationFrame(() => {
+          this.manageSelection();
+        });
+      });
+    }
+  }
+  shouldManageSelection() {
+    if (this.willManageSelection) {
       return;
-    };
-    this.itemsUpdated = new Promise((res) => resolve = res);
-    window.requestAnimationFrame(async () => {
-      if (this.open) {
-        await this.optionsMenu.updateComplete;
-        this.menuItems = this.optionsMenu.childItems;
-      } else {
-        this.menuItems = [
-          ...this.querySelectorAll(
-            'sp-menu-item:not([slot="submenu"] *)'
-          )
-        ];
-      }
-      this.manageSelection();
-      resolve();
-      this._willUpdateItems = false;
-    });
+    }
+    this.willManageSelection = true;
+    this.manageSelection();
   }
   async manageSelection() {
     if (this.selects == null)
       return;
-    await this.menuStatePromise;
     this.selectionPromise = new Promise(
       (res) => this.selectionResolver = res
     );
     let selectedItem;
+    await this.optionsMenu.updateComplete;
+    if (this.recentlyConnected) {
+      await new Promise((res) => requestAnimationFrame(() => res(true)));
+      this.recentlyConnected = false;
+    }
     this.menuItems.forEach((item) => {
       if (this.value === item.value && !item.disabled) {
         selectedItem = item;
@@ -484,34 +500,25 @@ export class PickerBase extends SizedMixin(Focusable) {
       this.optionsMenu.updateSelectedItemIndex();
     }
     this.selectionResolver();
+    this.willManageSelection = false;
   }
   async getUpdateComplete() {
     const complete = await super.getUpdateComplete();
-    await this.menuStatePromise;
-    await this.itemsUpdated;
     await this.selectionPromise;
+    if (this.overlayElement) {
+      await this.overlayElement.updateComplete;
+    }
     return complete;
   }
   connectedCallback() {
-    this.updateMenuItems();
-    this.addEventListener(
-      "sp-menu-item-added-or-updated",
-      this.updateMenuItems
-    );
-    this.addEventListener("sp-menu-item-removed", this.updateMenuItems);
     super.connectedCallback();
+    this.recentlyConnected = this.hasUpdated;
   }
   disconnectedCallback() {
     this.close();
     super.disconnectedCallback();
   }
 }
-/**
- * @private
- */
-PickerBase.openOverlay = async (target, interaction, content, options) => {
-  return await openOverlay(target, interaction, content, options);
-};
 __decorateClass([
   state()
 ], PickerBase.prototype, "appliedLabel", 2);
@@ -539,6 +546,12 @@ __decorateClass([
 __decorateClass([
   property({ type: Boolean, reflect: true })
 ], PickerBase.prototype, "readonly", 2);
+__decorateClass([
+  query("sp-menu")
+], PickerBase.prototype, "optionsMenu", 2);
+__decorateClass([
+  query("sp-overlay")
+], PickerBase.prototype, "overlayElement", 2);
 __decorateClass([
   property()
 ], PickerBase.prototype, "placement", 2);
@@ -550,13 +563,20 @@ __decorateClass([
 ], PickerBase.prototype, "value", 2);
 __decorateClass([
   property({ attribute: false })
-], PickerBase.prototype, "selectedItem", 2);
+], PickerBase.prototype, "selectedItem", 1);
+__decorateClass([
+  property({ attribute: false })
+], PickerBase.prototype, "selectedItemContent", 1);
 export class Picker extends PickerBase {
   constructor() {
     super(...arguments);
-    this.onKeydown = (event) => {
+    this.handleKeydown = (event) => {
       const { code } = event;
       this.focused = true;
+      if (code === "ArrowUp" || code === "ArrowDown") {
+        this.toggle(true);
+        return;
+      }
       if (!code.startsWith("Arrow") || this.readonly) {
         return;
       }
@@ -582,11 +602,12 @@ export class Picker extends PickerBase {
   static get styles() {
     return [pickerStyles, chevronStyles];
   }
-  sizePopover(popover) {
-    super.sizePopover(popover);
-    if (this.quiet)
-      return;
-    popover.style.setProperty("min-width", `${this.offsetWidth}px`);
+  get containerStyles() {
+    const styles = super.containerStyles;
+    if (!this.quiet) {
+      styles["min-width"] = `${this.offsetWidth}px`;
+    }
+    return styles;
   }
 }
 //# sourceMappingURL=Picker.dev.js.map