@esri/calcite-components 1.0.0-beta.75 → 1.0.0-beta.76

package/dist/collection/components/pick-list/pick-list.js

@@ -0,0 +1,192 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Component, Element, Event, Listen, Method, Prop, State, h } from "@stencil/core";
+import { ICON_TYPES } from "./resources";
+import { calciteListItemChangeHandler, calciteListItemValueChangeHandler, cleanUpObserver, deselectSiblingItems, deselectRemovedItems, getItemData, handleFilter, calciteListFocusOutHandler, initialize, initializeObserver, mutationObserverCallback, selectSiblings, setUpItems, keyDownHandler, setFocus, removeItem } from "./shared-list-logic";
+import List from "./shared-list-render";
+import { createObserver } from "../../utils/observers";
+/**
+ * @slot - A slot for adding `calcite-pick-list-item` elements or `calcite-pick-list-group` elements. Items are displayed as a vertical list.
+ * @slot menu-actions - A slot for adding a button + menu combo for performing actions like sorting.
+ */
+let PickList = class PickList {
+    constructor() {
+        // --------------------------------------------------------------------------
+        //
+        //  Properties
+        //
+        // --------------------------------------------------------------------------
+        /**
+         * When true, disabled prevents interaction. This state shows items with lower opacity/grayed.
+         */
+        this.disabled = false;
+        /**
+         * When true, an input appears at the top of the list that can be used by end users to filter items in the list.
+         */
+        this.filterEnabled = false;
+        /**
+         * When true, content is waiting to be loaded. This state shows a busy indicator.
+         */
+        this.loading = false;
+        /**
+         * Multiple works similar to standard radio buttons and checkboxes.
+         * When true, a user can select multiple items at a time.
+         * When false, only a single item can be selected at a time
+         * and selecting a new item will deselect any other selected items.
+         */
+        this.multiple = false;
+        /**
+         * When true and single-selection is enabled, the selection will change when navigating items via the keyboard.
+         */
+        this.selectionFollowsFocus = false;
+        // --------------------------------------------------------------------------
+        //
+        //  Private Properties
+        //
+        // --------------------------------------------------------------------------
+        this.selectedValues = new Map();
+        this.dataForFilter = [];
+        this.lastSelectedItem = null;
+        this.mutationObserver = createObserver("mutation", mutationObserverCallback.bind(this));
+        this.setFilterEl = (el) => {
+            this.filterEl = el;
+        };
+        this.deselectRemovedItems = deselectRemovedItems.bind(this);
+        this.deselectSiblingItems = deselectSiblingItems.bind(this);
+        this.selectSiblings = selectSiblings.bind(this);
+        this.handleFilter = handleFilter.bind(this);
+        this.getItemData = getItemData.bind(this);
+        this.keyDownHandler = keyDownHandler.bind(this);
+    }
+    // --------------------------------------------------------------------------
+    //
+    //  Lifecycle
+    //
+    // --------------------------------------------------------------------------
+    connectedCallback() {
+        initialize.call(this);
+        initializeObserver.call(this);
+    }
+    disconnectedCallback() {
+        cleanUpObserver.call(this);
+    }
+    calciteListItemRemoveHandler(event) {
+        removeItem.call(this, event);
+    }
+    calciteListItemChangeHandler(event) {
+        calciteListItemChangeHandler.call(this, event);
+    }
+    calciteListItemPropsChangeHandler(event) {
+        event.stopPropagation();
+        this.setUpFilter();
+    }
+    calciteListItemValueChangeHandler(event) {
+        calciteListItemValueChangeHandler.call(this, event);
+    }
+    calciteListFocusOutHandler(event) {
+        calciteListFocusOutHandler.call(this, event);
+    }
+    // --------------------------------------------------------------------------
+    //
+    //  Private Methods
+    //
+    // --------------------------------------------------------------------------
+    setUpItems() {
+        setUpItems.call(this, "calcite-pick-list-item");
+    }
+    setUpFilter() {
+        if (this.filterEnabled) {
+            this.dataForFilter = this.getItemData();
+        }
+    }
+    // --------------------------------------------------------------------------
+    //
+    //  Public Methods
+    //
+    // --------------------------------------------------------------------------
+    /** Returns the currently selected items */
+    async getSelectedItems() {
+        return this.selectedValues;
+    }
+    /** Sets focus on the component. */
+    async setFocus(focusId) {
+        return setFocus.call(this, focusId);
+    }
+    // --------------------------------------------------------------------------
+    //
+    //  Render Methods
+    //
+    // --------------------------------------------------------------------------
+    getIconType() {
+        return this.multiple ? ICON_TYPES.square : ICON_TYPES.circle;
+    }
+    render() {
+        return h(List, { onKeyDown: this.keyDownHandler, props: this });
+    }
+};
+__decorate([
+    Prop({ reflect: true })
+], PickList.prototype, "disabled", void 0);
+__decorate([
+    Prop({ reflect: true })
+], PickList.prototype, "filterEnabled", void 0);
+__decorate([
+    Prop({ reflect: true })
+], PickList.prototype, "filterPlaceholder", void 0);
+__decorate([
+    Prop()
+], PickList.prototype, "headingLevel", void 0);
+__decorate([
+    Prop({ reflect: true })
+], PickList.prototype, "loading", void 0);
+__decorate([
+    Prop({ reflect: true })
+], PickList.prototype, "multiple", void 0);
+__decorate([
+    Prop()
+], PickList.prototype, "selectionFollowsFocus", void 0);
+__decorate([
+    State()
+], PickList.prototype, "selectedValues", void 0);
+__decorate([
+    State()
+], PickList.prototype, "dataForFilter", void 0);
+__decorate([
+    Element()
+], PickList.prototype, "el", void 0);
+__decorate([
+    Event()
+], PickList.prototype, "calciteListChange", void 0);
+__decorate([
+    Listen("calciteListItemRemove")
+], PickList.prototype, "calciteListItemRemoveHandler", null);
+__decorate([
+    Listen("calciteListItemChange")
+], PickList.prototype, "calciteListItemChangeHandler", null);
+__decorate([
+    Listen("calciteListItemPropsChange")
+], PickList.prototype, "calciteListItemPropsChangeHandler", null);
+__decorate([
+    Listen("calciteListItemValueChange")
+], PickList.prototype, "calciteListItemValueChangeHandler", null);
+__decorate([
+    Listen("focusout")
+], PickList.prototype, "calciteListFocusOutHandler", null);
+__decorate([
+    Method()
+], PickList.prototype, "getSelectedItems", null);
+__decorate([
+    Method()
+], PickList.prototype, "setFocus", null);
+PickList = __decorate([
+    Component({
+        tag: "calcite-pick-list",
+        styleUrl: "pick-list.scss",
+        shadow: true
+    })
+], PickList);
+export { PickList };

package/dist/collection/components/pick-list/resources.js

@@ -0,0 +1,15 @@
+export const CSS = {
+    sticky: "sticky-pos"
+};
+export var ICON_TYPES;
+(function (ICON_TYPES) {
+    ICON_TYPES["circle"] = "circle";
+    ICON_TYPES["square"] = "square";
+    ICON_TYPES["grip"] = "grip";
+})(ICON_TYPES || (ICON_TYPES = {}));
+export const TEXT = {
+    filterResults: "Filter results"
+};
+export const SLOTS = {
+    menuActions: "menu-actions"
+};

package/dist/collection/components/pick-list/shared-list-logic.js

@@ -0,0 +1,269 @@
+import { debounce } from "lodash-es";
+import { focusElement, getSlotted } from "../../utils/dom";
+import { getRoundRobinIndex } from "../../utils/array";
+export function mutationObserverCallback() {
+    this.setUpItems();
+    this.setUpFilter();
+    this.deselectRemovedItems();
+}
+const SUPPORTED_ARROW_KEYS = ["ArrowUp", "ArrowDown"];
+// --------------------------------------------------------------------------
+//
+//  Lifecycle
+//
+// --------------------------------------------------------------------------
+export function initialize() {
+    this.setUpItems();
+    this.setUpFilter();
+    this.emitCalciteListChange = debounce(internalCalciteListChangeEvent.bind(this), 0);
+}
+export function initializeObserver() {
+    var _a;
+    (_a = this.mutationObserver) === null || _a === void 0 ? void 0 : _a.observe(this.el, { childList: true, subtree: true });
+}
+export function cleanUpObserver() {
+    var _a;
+    (_a = this.mutationObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
+}
+// --------------------------------------------------------------------------
+//
+//  Listeners
+//
+// --------------------------------------------------------------------------
+export function calciteListItemChangeHandler(event) {
+    const { selectedValues } = this;
+    const { item, value, selected, shiftPressed } = event.detail;
+    if (selected) {
+        if (this.multiple && shiftPressed) {
+            this.selectSiblings(item);
+        }
+        if (!this.multiple) {
+            this.deselectSiblingItems(item);
+        }
+        selectedValues.set(value, item);
+    }
+    else {
+        selectedValues.delete(value);
+        if (this.multiple && shiftPressed) {
+            this.selectSiblings(item, true);
+        }
+    }
+    if (!this.multiple) {
+        toggleSingleSelectItemTabbing(item, selected);
+        if (selected) {
+            focusElement(item);
+        }
+    }
+    this.lastSelectedItem = item;
+    this.emitCalciteListChange();
+}
+export function calciteListItemValueChangeHandler(event) {
+    event.stopPropagation();
+    const oldValue = event.detail.oldValue;
+    const selectedValues = this.selectedValues;
+    if (selectedValues.has(oldValue)) {
+        const item = selectedValues.get(oldValue);
+        selectedValues.delete(oldValue);
+        selectedValues.set(event.detail.newValue, item);
+    }
+}
+// --------------------------------------------------------------------------
+//
+//  Private Methods
+//
+// --------------------------------------------------------------------------
+function isValidNavigationKey(key) {
+    return !!SUPPORTED_ARROW_KEYS.find((k) => k === key);
+}
+export function calciteListFocusOutHandler(event) {
+    const { el, items, multiple, selectedValues } = this;
+    if (multiple) {
+        return;
+    }
+    const focusedInside = !!el.contains(event.relatedTarget);
+    if (focusedInside) {
+        toggleSingleSelectItemTabbing(event.target, false);
+        return;
+    }
+    items.forEach((item) => toggleSingleSelectItemTabbing(item, selectedValues.size === 0 ? event.target === item : item.selected));
+}
+export function keyDownHandler(event) {
+    const { key, target } = event;
+    if (!isValidNavigationKey(key)) {
+        return;
+    }
+    const { items, multiple, selectionFollowsFocus } = this;
+    const { length: totalItems } = items;
+    const currentIndex = items.indexOf(target);
+    if (!totalItems || currentIndex === -1) {
+        return;
+    }
+    event.preventDefault();
+    const index = getRoundRobinIndex(currentIndex + (key === "ArrowUp" ? -1 : 1), totalItems);
+    const item = items[index];
+    items.forEach((i) => toggleSingleSelectItemTabbing(i, i === item));
+    if (!multiple && selectionFollowsFocus) {
+        item.selected = true;
+    }
+    focusElement(item);
+}
+export function internalCalciteListChangeEvent() {
+    this.calciteListChange.emit(this.selectedValues);
+}
+export function removeItem(event) {
+    if (event.defaultPrevented) {
+        return;
+    }
+    const item = event.target;
+    const selectedValues = this.selectedValues;
+    if (item.parentElement.tagName === "CALCITE-PICK-LIST-GROUP") {
+        item.parentElement.remove();
+        Array.from(item.parentElement.children).forEach((item) => selectedValues.delete(item.value));
+    }
+    else {
+        item.remove();
+        selectedValues.delete(item.value);
+    }
+    this.emitCalciteListChange();
+}
+function toggleSingleSelectItemTabbing(item, selectable) {
+    // using attribute intentionally
+    if (selectable) {
+        item.removeAttribute("tabindex");
+    }
+    else {
+        item.setAttribute("tabindex", "-1");
+    }
+}
+export async function setFocus(focusId) {
+    if (this.filterEnabled && focusId === "filter") {
+        await focusElement(this.filterEl);
+        return;
+    }
+    const { items, multiple, selectionFollowsFocus } = this;
+    if (items.length === 0) {
+        return;
+    }
+    if (multiple) {
+        return items[0].setFocus();
+    }
+    const focusTarget = items.find((item) => item.selected) || items[0];
+    if (selectionFollowsFocus) {
+        focusTarget.selected = true;
+    }
+    return focusTarget.setFocus();
+}
+export function setUpItems(tagName) {
+    this.items = Array.from(this.el.querySelectorAll(tagName));
+    let hasSelected = false;
+    const { items } = this;
+    items.forEach((item) => {
+        item.icon = this.getIconType();
+        if (!this.multiple) {
+            item.disableDeselect = true;
+            toggleSingleSelectItemTabbing(item, false);
+        }
+        if (item.selected) {
+            hasSelected = true;
+            toggleSingleSelectItemTabbing(item, true);
+            this.selectedValues.set(item.value, item);
+        }
+    });
+    const [first] = items;
+    if (!hasSelected && first) {
+        toggleSingleSelectItemTabbing(first, true);
+    }
+}
+export function setUpFilter() {
+    if (this.filterEnabled) {
+        this.dataForFilter = this.getItemData();
+    }
+}
+export function deselectRemovedItems() {
+    const selectedValues = this.selectedValues;
+    const itemValues = this.items.map(({ value }) => value);
+    selectedValues.forEach((selectedItem) => {
+        if (!itemValues.includes(selectedItem.value)) {
+            this.selectedValues.delete(selectedItem.value);
+        }
+    });
+}
+export function deselectSiblingItems(item) {
+    this.items.forEach((currentItem) => {
+        if (currentItem.value !== item.value) {
+            currentItem.toggleSelected(false);
+            if (this.selectedValues.has(currentItem.value)) {
+                this.selectedValues.delete(currentItem.value);
+            }
+        }
+    });
+}
+export function selectSiblings(item, deselect = false) {
+    if (!this.lastSelectedItem) {
+        return;
+    }
+    const { items } = this;
+    const start = items.findIndex((currentItem) => {
+        return currentItem.value === this.lastSelectedItem.value;
+    });
+    const end = items.findIndex((currentItem) => {
+        return currentItem.value === item.value;
+    });
+    items.slice(Math.min(start, end), Math.max(start, end)).forEach((currentItem) => {
+        currentItem.toggleSelected(!deselect);
+        if (!deselect) {
+            this.selectedValues.set(currentItem.value, currentItem);
+        }
+        else {
+            this.selectedValues.delete(currentItem.value);
+        }
+    });
+}
+let groups;
+export function handleFilter(event) {
+    const { filteredItems } = event.currentTarget;
+    const values = filteredItems.map((item) => item.value);
+    let hasSelectedMatch = false;
+    if (!groups) {
+        groups = new Set();
+    }
+    const matchedItems = this.items.filter((item) => {
+        const parent = item.parentElement;
+        const grouped = parent.matches("calcite-pick-list-group");
+        if (grouped) {
+            groups.add(parent);
+        }
+        const matches = values.includes(item.value);
+        item.hidden = !matches;
+        if (!hasSelectedMatch) {
+            hasSelectedMatch = matches && item.selected;
+        }
+        return matches;
+    });
+    groups.forEach((group) => {
+        const hasAtLeastOneMatch = matchedItems.some((item) => group.contains(item));
+        group.hidden = !hasAtLeastOneMatch;
+        if (!hasAtLeastOneMatch) {
+            return;
+        }
+        const parentItem = getSlotted(group, "parent-item");
+        if (parentItem) {
+            parentItem.hidden = false;
+            if (matchedItems.includes(parentItem)) {
+                Array.from(group.children).forEach((child) => (child.hidden = false));
+            }
+        }
+    });
+    groups.clear();
+    if (matchedItems.length > 0 && !hasSelectedMatch && !this.multiple) {
+        toggleSingleSelectItemTabbing(matchedItems[0], true);
+    }
+}
+export function getItemData() {
+    return this.items.map((item) => ({
+        label: item.label,
+        description: item.description,
+        metadata: item.metadata,
+        value: item.value
+    }));
+}

package/dist/collection/components/pick-list/shared-list-render.js

@@ -0,0 +1,25 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { h, Host } from "@stencil/core";
+import { CSS, SLOTS } from "./resources";
+export const List = (_a) => {
+    var { props: { disabled, loading, filterEnabled, dataForFilter, handleFilter, filterPlaceholder, setFilterEl } } = _a, rest = __rest(_a, ["props"]);
+    const defaultSlot = h("slot", null);
+    return (h(Host, Object.assign({ "aria-busy": loading.toString(), "aria-disabled": disabled.toString(), role: "menu" }, rest),
+        h("section", null,
+            h("header", { class: { [CSS.sticky]: true } },
+                filterEnabled ? (h("calcite-filter", { "aria-label": filterPlaceholder, disabled: loading || disabled, items: dataForFilter, onCalciteFilterChange: handleFilter, placeholder: filterPlaceholder, ref: setFilterEl })) : null,
+                h("slot", { name: SLOTS.menuActions })),
+            loading || disabled ? h("calcite-scrim", { loading: loading }) : null,
+            defaultSlot)));
+};
+export default List;

package/dist/collection/components/radio-group/interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/components/tab/interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/components/tabs/interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/components/tile-select/interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/components/tile-select-group/interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/components/tree/interfaces.js

@@ -0,0 +1,8 @@
+export var TreeSelectionMode;
+(function (TreeSelectionMode) {
+    TreeSelectionMode["Single"] = "single";
+    TreeSelectionMode["Multi"] = "multi";
+    TreeSelectionMode["Children"] = "children";
+    TreeSelectionMode["MultiChildren"] = "multi-children";
+    TreeSelectionMode["Ancestors"] = "ancestors";
+})(TreeSelectionMode || (TreeSelectionMode = {}));

package/dist/collection/components/tree-item/interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/components/value-list/resources.js

@@ -0,0 +1,11 @@
+export const CSS = {
+    container: "container",
+    handle: "handle"
+};
+export var ICON_TYPES;
+(function (ICON_TYPES) {
+    ICON_TYPES["grip"] = "grip";
+})(ICON_TYPES || (ICON_TYPES = {}));
+export const TEXT = {
+    filterResults: "Filter results"
+};