@ni/fast-foundation 0.0.2

package/dist/esm/radio-group/radio-group.js

@@ -0,0 +1,390 @@
+import { __decorate } from "tslib";
+import { attr, observable } from "@ni/fast-element";
+import { ArrowKeys, Direction, keyArrowDown, keyArrowLeft, keyArrowRight, keyArrowUp, keyEnter, Orientation, } from "@ni/fast-web-utilities";
+import { getDirection } from "../utilities/direction.js";
+import { FoundationElement } from "../foundation-element/foundation-element.js";
+/**
+ * An Radio Group Custom HTML Element.
+ * Implements the {@link https://www.w3.org/TR/wai-aria-1.1/#radiogroup | ARIA radiogroup }.
+ *
+ * @slot label - The slot for the label
+ * @slot - The default slot for radio buttons
+ * @csspart positioning-region - The positioning region for laying out the radios
+ * @fires change - Fires a custom 'change' event when the value changes
+ *
+ * @public
+ */
+export class RadioGroup extends FoundationElement {
+    constructor() {
+        super(...arguments);
+        /**
+         * The orientation of the group
+         *
+         * @public
+         * @remarks
+         * HTML Attribute: orientation
+         */
+        this.orientation = Orientation.horizontal;
+        this.radioChangeHandler = (e) => {
+            const changedRadio = e.target;
+            if (changedRadio.checked) {
+                this.slottedRadioButtons.forEach((radio) => {
+                    if (radio !== changedRadio) {
+                        radio.checked = false;
+                        if (!this.isInsideFoundationToolbar) {
+                            radio.setAttribute("tabindex", "-1");
+                        }
+                    }
+                });
+                this.selectedRadio = changedRadio;
+                this.value = changedRadio.value;
+                changedRadio.setAttribute("tabindex", "0");
+                this.focusedRadio = changedRadio;
+            }
+            e.stopPropagation();
+        };
+        this.moveToRadioByIndex = (group, index) => {
+            const radio = group[index];
+            if (!this.isInsideToolbar) {
+                radio.setAttribute("tabindex", "0");
+                if (radio.readOnly) {
+                    this.slottedRadioButtons.forEach((nextRadio) => {
+                        if (nextRadio !== radio) {
+                            nextRadio.setAttribute("tabindex", "-1");
+                        }
+                    });
+                }
+                else {
+                    radio.checked = true;
+                    this.selectedRadio = radio;
+                }
+            }
+            this.focusedRadio = radio;
+            radio.focus();
+        };
+        this.moveRightOffGroup = () => {
+            var _a;
+            (_a = this.nextElementSibling) === null || _a === void 0 ? void 0 : _a.focus();
+        };
+        this.moveLeftOffGroup = () => {
+            var _a;
+            (_a = this.previousElementSibling) === null || _a === void 0 ? void 0 : _a.focus();
+        };
+        /**
+         * @internal
+         */
+        this.focusOutHandler = (e) => {
+            const group = this.slottedRadioButtons;
+            const radio = e.target;
+            const index = radio !== null ? group.indexOf(radio) : 0;
+            const focusedIndex = this.focusedRadio
+                ? group.indexOf(this.focusedRadio)
+                : -1;
+            if ((focusedIndex === 0 && index === focusedIndex) ||
+                (focusedIndex === group.length - 1 && focusedIndex === index)) {
+                if (!this.selectedRadio) {
+                    this.focusedRadio = group[0];
+                    this.focusedRadio.setAttribute("tabindex", "0");
+                    group.forEach((nextRadio) => {
+                        if (nextRadio !== this.focusedRadio) {
+                            nextRadio.setAttribute("tabindex", "-1");
+                        }
+                    });
+                }
+                else {
+                    this.focusedRadio = this.selectedRadio;
+                    if (!this.isInsideFoundationToolbar) {
+                        this.selectedRadio.setAttribute("tabindex", "0");
+                        group.forEach((nextRadio) => {
+                            if (nextRadio !== this.selectedRadio) {
+                                nextRadio.setAttribute("tabindex", "-1");
+                            }
+                        });
+                    }
+                }
+            }
+            return true;
+        };
+        /**
+         * @internal
+         */
+        this.clickHandler = (e) => {
+            const radio = e.target;
+            if (radio) {
+                const group = this.slottedRadioButtons;
+                if (radio.checked || group.indexOf(radio) === 0) {
+                    radio.setAttribute("tabindex", "0");
+                    this.selectedRadio = radio;
+                }
+                else {
+                    radio.setAttribute("tabindex", "-1");
+                    this.selectedRadio = null;
+                }
+                this.focusedRadio = radio;
+            }
+            e.preventDefault();
+        };
+        this.shouldMoveOffGroupToTheRight = (index, group, key) => {
+            return index === group.length && this.isInsideToolbar && key === keyArrowRight;
+        };
+        this.shouldMoveOffGroupToTheLeft = (group, key) => {
+            const index = this.focusedRadio ? group.indexOf(this.focusedRadio) - 1 : 0;
+            return index < 0 && this.isInsideToolbar && key === keyArrowLeft;
+        };
+        this.checkFocusedRadio = () => {
+            if (this.focusedRadio !== null &&
+                !this.focusedRadio.readOnly &&
+                !this.focusedRadio.checked) {
+                this.focusedRadio.checked = true;
+                this.focusedRadio.setAttribute("tabindex", "0");
+                this.focusedRadio.focus();
+                this.selectedRadio = this.focusedRadio;
+            }
+        };
+        this.moveRight = (e) => {
+            const group = this.slottedRadioButtons;
+            let index = 0;
+            index = this.focusedRadio ? group.indexOf(this.focusedRadio) + 1 : 1;
+            if (this.shouldMoveOffGroupToTheRight(index, group, e.key)) {
+                this.moveRightOffGroup();
+                return;
+            }
+            else if (index === group.length) {
+                index = 0;
+            }
+            /* looping to get to next radio that is not disabled */
+            /* matching native radio/radiogroup which does not select an item if there is only 1 in the group */
+            while (index < group.length && group.length > 1) {
+                if (!group[index].disabled) {
+                    this.moveToRadioByIndex(group, index);
+                    break;
+                }
+                else if (this.focusedRadio && index === group.indexOf(this.focusedRadio)) {
+                    break;
+                }
+                else if (index + 1 >= group.length) {
+                    if (this.isInsideToolbar) {
+                        break;
+                    }
+                    else {
+                        index = 0;
+                    }
+                }
+                else {
+                    index += 1;
+                }
+            }
+        };
+        this.moveLeft = (e) => {
+            const group = this.slottedRadioButtons;
+            let index = 0;
+            index = this.focusedRadio ? group.indexOf(this.focusedRadio) - 1 : 0;
+            index = index < 0 ? group.length - 1 : index;
+            if (this.shouldMoveOffGroupToTheLeft(group, e.key)) {
+                this.moveLeftOffGroup();
+                return;
+            }
+            /* looping to get to next radio that is not disabled */
+            while (index >= 0 && group.length > 1) {
+                if (!group[index].disabled) {
+                    this.moveToRadioByIndex(group, index);
+                    break;
+                }
+                else if (this.focusedRadio && index === group.indexOf(this.focusedRadio)) {
+                    break;
+                }
+                else if (index - 1 < 0) {
+                    index = group.length - 1;
+                }
+                else {
+                    index -= 1;
+                }
+            }
+        };
+        /**
+         * keyboard handling per https://w3c.github.io/aria-practices/#for-radio-groups-not-contained-in-a-toolbar
+         * navigation is different when there is an ancestor with role='toolbar'
+         *
+         * @internal
+         */
+        this.keydownHandler = (e) => {
+            const key = e.key;
+            if (key in ArrowKeys && this.isInsideFoundationToolbar) {
+                return true;
+            }
+            switch (key) {
+                case keyEnter: {
+                    this.checkFocusedRadio();
+                    break;
+                }
+                case keyArrowRight:
+                case keyArrowDown: {
+                    if (this.direction === Direction.ltr) {
+                        this.moveRight(e);
+                    }
+                    else {
+                        this.moveLeft(e);
+                    }
+                    break;
+                }
+                case keyArrowLeft:
+                case keyArrowUp: {
+                    if (this.direction === Direction.ltr) {
+                        this.moveLeft(e);
+                    }
+                    else {
+                        this.moveRight(e);
+                    }
+                    break;
+                }
+                default: {
+                    return true;
+                }
+            }
+        };
+    }
+    readOnlyChanged() {
+        if (this.slottedRadioButtons !== undefined) {
+            this.slottedRadioButtons.forEach((radio) => {
+                if (this.readOnly) {
+                    radio.readOnly = true;
+                }
+                else {
+                    radio.readOnly = false;
+                }
+            });
+        }
+    }
+    disabledChanged() {
+        if (this.slottedRadioButtons !== undefined) {
+            this.slottedRadioButtons.forEach((radio) => {
+                if (this.disabled) {
+                    radio.disabled = true;
+                }
+                else {
+                    radio.disabled = false;
+                }
+            });
+        }
+    }
+    nameChanged() {
+        if (this.slottedRadioButtons) {
+            this.slottedRadioButtons.forEach((radio) => {
+                radio.setAttribute("name", this.name);
+            });
+        }
+    }
+    valueChanged() {
+        if (this.slottedRadioButtons) {
+            this.slottedRadioButtons.forEach((radio) => {
+                if (radio.value === this.value) {
+                    radio.checked = true;
+                    this.selectedRadio = radio;
+                }
+            });
+        }
+        this.$emit("change");
+    }
+    slottedRadioButtonsChanged(oldValue, newValue) {
+        if (this.slottedRadioButtons && this.slottedRadioButtons.length > 0) {
+            this.setupRadioButtons();
+        }
+    }
+    get parentToolbar() {
+        return this.closest('[role="toolbar"]');
+    }
+    get isInsideToolbar() {
+        var _a;
+        return ((_a = this.parentToolbar) !== null && _a !== void 0 ? _a : false);
+    }
+    get isInsideFoundationToolbar() {
+        var _a;
+        return !!((_a = this.parentToolbar) === null || _a === void 0 ? void 0 : _a["$fastController"]);
+    }
+    /**
+     * @internal
+     */
+    connectedCallback() {
+        super.connectedCallback();
+        this.direction = getDirection(this);
+        this.setupRadioButtons();
+    }
+    disconnectedCallback() {
+        this.slottedRadioButtons.forEach((radio) => {
+            radio.removeEventListener("change", this.radioChangeHandler);
+        });
+    }
+    setupRadioButtons() {
+        const checkedRadios = this.slottedRadioButtons.filter((radio) => {
+            return radio.hasAttribute("checked");
+        });
+        const numberOfCheckedRadios = checkedRadios ? checkedRadios.length : 0;
+        if (numberOfCheckedRadios > 1) {
+            const lastCheckedRadio = checkedRadios[numberOfCheckedRadios - 1];
+            lastCheckedRadio.checked = true;
+        }
+        let foundMatchingVal = false;
+        this.slottedRadioButtons.forEach((radio) => {
+            if (this.name !== undefined) {
+                radio.setAttribute("name", this.name);
+            }
+            if (this.disabled) {
+                radio.disabled = true;
+            }
+            if (this.readOnly) {
+                radio.readOnly = true;
+            }
+            if (this.value && this.value === radio.value) {
+                this.selectedRadio = radio;
+                this.focusedRadio = radio;
+                radio.checked = true;
+                radio.setAttribute("tabindex", "0");
+                foundMatchingVal = true;
+            }
+            else {
+                if (!this.isInsideFoundationToolbar) {
+                    radio.setAttribute("tabindex", "-1");
+                }
+                radio.checked = false;
+            }
+            radio.addEventListener("change", this.radioChangeHandler);
+        });
+        if (this.value === undefined && this.slottedRadioButtons.length > 0) {
+            const checkedRadios = this.slottedRadioButtons.filter((radio) => {
+                return radio.hasAttribute("checked");
+            });
+            const numberOfCheckedRadios = checkedRadios !== null ? checkedRadios.length : 0;
+            if (numberOfCheckedRadios > 0 && !foundMatchingVal) {
+                const lastCheckedRadio = checkedRadios[numberOfCheckedRadios - 1];
+                lastCheckedRadio.checked = true;
+                this.focusedRadio = lastCheckedRadio;
+                lastCheckedRadio.setAttribute("tabindex", "0");
+            }
+            else {
+                this.slottedRadioButtons[0].setAttribute("tabindex", "0");
+                this.focusedRadio = this.slottedRadioButtons[0];
+            }
+        }
+    }
+}
+__decorate([
+    attr({ attribute: "readonly", mode: "boolean" })
+], RadioGroup.prototype, "readOnly", void 0);
+__decorate([
+    attr({ attribute: "disabled", mode: "boolean" })
+], RadioGroup.prototype, "disabled", void 0);
+__decorate([
+    attr
+], RadioGroup.prototype, "name", void 0);
+__decorate([
+    attr
+], RadioGroup.prototype, "value", void 0);
+__decorate([
+    attr
+], RadioGroup.prototype, "orientation", void 0);
+__decorate([
+    observable
+], RadioGroup.prototype, "childItems", void 0);
+__decorate([
+    observable
+], RadioGroup.prototype, "slottedRadioButtons", void 0);

package/dist/esm/radio-group/radio-group.template.js

@@ -0,0 +1,29 @@
+import { elements, html, slotted } from "@ni/fast-element";
+import { Orientation } from "@ni/fast-web-utilities";
+/**
+ * The template for the {@link @ni/fast-foundation#RadioGroup} component.
+ * @public
+ */
+export const radioGroupTemplate = (context, definition) => html `
+    <template
+        role="radiogroup"
+        aria-disabled="${x => x.disabled}"
+        aria-readonly="${x => x.readOnly}"
+        @click="${(x, c) => x.clickHandler(c.event)}"
+        @keydown="${(x, c) => x.keydownHandler(c.event)}"
+        @focusout="${(x, c) => x.focusOutHandler(c.event)}"
+    >
+        <slot name="label"></slot>
+        <div
+            class="positioning-region ${x => x.orientation === Orientation.horizontal ? "horizontal" : "vertical"}"
+            part="positioning-region"
+        >
+            <slot
+                ${slotted({
+    property: "slottedRadioButtons",
+    filter: elements("[role=radio]"),
+})}
+            ></slot>
+        </div>
+    </template>
+`;

package/dist/esm/search/index.js

@@ -0,0 +1,2 @@
+export * from "./search.template.js";
+export * from "./search.js";

package/dist/esm/search/search.form-associated.js

@@ -0,0 +1,15 @@
+import { FormAssociated } from "../form-associated/form-associated.js";
+import { FoundationElement } from "../foundation-element/foundation-element.js";
+class _Search extends FoundationElement {
+}
+/**
+ * A form-associated base class for the {@link @ni/fast-foundation#(Search:class)} component.
+ *
+ * @internal
+ */
+export class FormAssociatedSearch extends FormAssociated(_Search) {
+    constructor() {
+        super(...arguments);
+        this.proxy = document.createElement("input");
+    }
+}

package/dist/esm/search/search.js

@@ -0,0 +1,157 @@
+import { __decorate } from "tslib";
+import { attr, DOM, nullableNumberConverter, observable } from "@ni/fast-element";
+import { ARIAGlobalStatesAndProperties, StartEnd, } from "../patterns/index.js";
+import { applyMixins } from "../utilities/apply-mixins.js";
+import { FormAssociatedSearch } from "./search.form-associated.js";
+/**
+ * A Search Custom HTML Element.
+ * Based largely on the {@link https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/search | <input type="search" /> element }.
+ *
+ * @slot start - Content which can be provided before the search input
+ * @slot end - Content which can be provided after the search clear button
+ * @slot - The default slot for the label
+ * @slot close-button - The clear button
+ * @slot close-glyph - The clear glyph
+ * @csspart label - The label
+ * @csspart root - The element wrapping the control, including start and end slots
+ * @csspart control - The element representing the input
+ * @csspart clear-button - The button to clear the input
+ *
+ * @public
+ */
+export class Search extends FormAssociatedSearch {
+    readOnlyChanged() {
+        if (this.proxy instanceof HTMLInputElement) {
+            this.proxy.readOnly = this.readOnly;
+            this.validate();
+        }
+    }
+    autofocusChanged() {
+        if (this.proxy instanceof HTMLInputElement) {
+            this.proxy.autofocus = this.autofocus;
+            this.validate();
+        }
+    }
+    placeholderChanged() {
+        if (this.proxy instanceof HTMLInputElement) {
+            this.proxy.placeholder = this.placeholder;
+        }
+    }
+    listChanged() {
+        if (this.proxy instanceof HTMLInputElement) {
+            this.proxy.setAttribute("list", this.list);
+            this.validate();
+        }
+    }
+    maxlengthChanged() {
+        if (this.proxy instanceof HTMLInputElement) {
+            this.proxy.maxLength = this.maxlength;
+            this.validate();
+        }
+    }
+    minlengthChanged() {
+        if (this.proxy instanceof HTMLInputElement) {
+            this.proxy.minLength = this.minlength;
+            this.validate();
+        }
+    }
+    patternChanged() {
+        if (this.proxy instanceof HTMLInputElement) {
+            this.proxy.pattern = this.pattern;
+            this.validate();
+        }
+    }
+    sizeChanged() {
+        if (this.proxy instanceof HTMLInputElement) {
+            this.proxy.size = this.size;
+        }
+    }
+    spellcheckChanged() {
+        if (this.proxy instanceof HTMLInputElement) {
+            this.proxy.spellcheck = this.spellcheck;
+        }
+    }
+    /**
+     * @internal
+     */
+    connectedCallback() {
+        super.connectedCallback();
+        this.validate();
+        if (this.autofocus) {
+            DOM.queueUpdate(() => {
+                this.focus();
+            });
+        }
+    }
+    /** {@inheritDoc (FormAssociated:interface).validate} */
+    validate() {
+        super.validate(this.control);
+    }
+    /**
+     * Handles the internal control's `input` event
+     * @internal
+     */
+    handleTextInput() {
+        this.value = this.control.value;
+    }
+    /**
+     * Handles the control's clear value event
+     * @public
+     */
+    handleClearInput() {
+        this.value = "";
+        this.control.focus();
+        this.handleChange();
+    }
+    /**
+     * Change event handler for inner control.
+     * @remarks
+     * "Change" events are not `composable` so they will not
+     * permeate the shadow DOM boundary. This fn effectively proxies
+     * the change event, emitting a `change` event whenever the internal
+     * control emits a `change` event
+     * @internal
+     */
+    handleChange() {
+        this.$emit("change");
+    }
+}
+__decorate([
+    attr({ attribute: "readonly", mode: "boolean" })
+], Search.prototype, "readOnly", void 0);
+__decorate([
+    attr({ mode: "boolean" })
+], Search.prototype, "autofocus", void 0);
+__decorate([
+    attr
+], Search.prototype, "placeholder", void 0);
+__decorate([
+    attr
+], Search.prototype, "list", void 0);
+__decorate([
+    attr({ converter: nullableNumberConverter })
+], Search.prototype, "maxlength", void 0);
+__decorate([
+    attr({ converter: nullableNumberConverter })
+], Search.prototype, "minlength", void 0);
+__decorate([
+    attr
+], Search.prototype, "pattern", void 0);
+__decorate([
+    attr({ converter: nullableNumberConverter })
+], Search.prototype, "size", void 0);
+__decorate([
+    attr({ mode: "boolean" })
+], Search.prototype, "spellcheck", void 0);
+__decorate([
+    observable
+], Search.prototype, "defaultSlottedNodes", void 0);
+/**
+ * Includes ARIA states and properties relating to the ARIA textbox role
+ *
+ * @public
+ */
+export class DelegatesARIASearch {
+}
+applyMixins(DelegatesARIASearch, ARIAGlobalStatesAndProperties);
+applyMixins(Search, StartEnd, DelegatesARIASearch);

package/dist/esm/search/search.template.js

@@ -0,0 +1,93 @@
+import { html, ref, slotted } from "@ni/fast-element";
+import { endSlotTemplate, startSlotTemplate } from "../patterns/start-end.js";
+import { whitespaceFilter } from "../utilities/whitespace-filter.js";
+/**
+ * The template for the {@link @ni/fast-foundation#(Search:class)} component.
+ * @public
+ */
+export const searchTemplate = (context, definition) => html `
+    <template
+        class="
+            ${x => (x.readOnly ? "readonly" : "")}
+        "
+    >
+        <label
+            part="label"
+            for="control"
+            class="${x => x.defaultSlottedNodes && x.defaultSlottedNodes.length
+    ? "label"
+    : "label label__hidden"}"
+        >
+            <slot
+                ${slotted({ property: "defaultSlottedNodes", filter: whitespaceFilter })}
+            ></slot>
+        </label>
+        <div class="root" part="root" ${ref("root")}>
+            ${startSlotTemplate(context, definition)}
+            <div class="input-wrapper" part="input-wrapper">
+                <input
+                    class="control"
+                    part="control"
+                    id="control"
+                    @input="${x => x.handleTextInput()}"
+                    @change="${x => x.handleChange()}"
+                    ?autofocus="${x => x.autofocus}"
+                    ?disabled="${x => x.disabled}"
+                    list="${x => x.list}"
+                    maxlength="${x => x.maxlength}"
+                    minlength="${x => x.minlength}"
+                    pattern="${x => x.pattern}"
+                    placeholder="${x => x.placeholder}"
+                    ?readonly="${x => x.readOnly}"
+                    ?required="${x => x.required}"
+                    size="${x => x.size}"
+                    ?spellcheck="${x => x.spellcheck}"
+                    :value="${x => x.value}"
+                    type="search"
+                    aria-atomic="${x => x.ariaAtomic}"
+                    aria-busy="${x => x.ariaBusy}"
+                    aria-controls="${x => x.ariaControls}"
+                    aria-current="${x => x.ariaCurrent}"
+                    aria-describedby="${x => x.ariaDescribedby}"
+                    aria-details="${x => x.ariaDetails}"
+                    aria-disabled="${x => x.ariaDisabled}"
+                    aria-errormessage="${x => x.ariaErrormessage}"
+                    aria-flowto="${x => x.ariaFlowto}"
+                    aria-haspopup="${x => x.ariaHaspopup}"
+                    aria-hidden="${x => x.ariaHidden}"
+                    aria-invalid="${x => x.ariaInvalid}"
+                    aria-keyshortcuts="${x => x.ariaKeyshortcuts}"
+                    aria-label="${x => x.ariaLabel}"
+                    aria-labelledby="${x => x.ariaLabelledby}"
+                    aria-live="${x => x.ariaLive}"
+                    aria-owns="${x => x.ariaOwns}"
+                    aria-relevant="${x => x.ariaRelevant}"
+                    aria-roledescription="${x => x.ariaRoledescription}"
+                    ${ref("control")}
+                />
+                <slot name="close-button">
+                    <button
+                        class="clear-button ${x => x.value ? "" : "clear-button__hidden"}"
+                        part="clear-button"
+                        tabindex="-1"
+                        @click=${x => x.handleClearInput()}
+                    >
+                        <slot name="close-glyph">
+                            <svg
+                                width="9"
+                                height="9"
+                                viewBox="0 0 9 9"
+                                xmlns="http://www.w3.org/2000/svg"
+                            >
+                                <path
+                                    d="M0.146447 0.146447C0.338683 -0.0478972 0.645911 -0.0270359 0.853553 0.146447L4.5 3.793L8.14645 0.146447C8.34171 -0.0488155 8.65829 -0.0488155 8.85355 0.146447C9.04882 0.341709 9.04882 0.658291 8.85355 0.853553L5.207 4.5L8.85355 8.14645C9.05934 8.35223 9.03129 8.67582 8.85355 8.85355C8.67582 9.03129 8.35409 9.02703 8.14645 8.85355L4.5 5.207L0.853553 8.85355C0.658291 9.04882 0.341709 9.04882 0.146447 8.85355C-0.0488155 8.65829 -0.0488155 8.34171 0.146447 8.14645L3.793 4.5L0.146447 0.853553C-0.0268697 0.680237 -0.0457894 0.34079 0.146447 0.146447Z"
+                                />
+                            </svg>
+                        </slot>
+                    </button>
+                </slot>
+            </div>
+            ${endSlotTemplate(context, definition)}
+        </div>
+    </template>
+`;

package/dist/esm/select/index.js

@@ -0,0 +1,3 @@
+export * from "./select.js";
+export * from "./select.options.js";
+export * from "./select.template.js";