@ni/fast-foundation 0.0.2

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

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

package/dist/esm/select/select.js

@@ -0,0 +1,490 @@
+import { __decorate } from "tslib";
+import { attr, DOM, Observable, observable, volatile } from "@ni/fast-element";
+import { keyArrowDown, keyArrowUp, keyEnd, keyEnter, keyEscape, keyHome, keySpace, keyTab, uniqueId, } from "@ni/fast-web-utilities";
+import { DelegatesARIAListbox, Listbox } from "../listbox/listbox.js";
+import { StartEnd } from "../patterns/start-end.js";
+import { applyMixins } from "../utilities/apply-mixins.js";
+import { FormAssociatedSelect } from "./select.form-associated.js";
+import { SelectPosition } from "./select.options.js";
+/**
+ * A Select Custom HTML Element.
+ * Implements the {@link https://www.w3.org/TR/wai-aria-1.1/#select | ARIA select }.
+ *
+ * @slot start - Content which can be provided before the button content
+ * @slot end - Content which can be provided after the button content
+ * @slot button-container - The element representing the select button
+ * @slot selected-value - The selected value
+ * @slot indicator - The visual indicator for the expand/collapse state of the button
+ * @slot - The default slot for slotted options
+ * @csspart control - The element representing the select invoking element
+ * @csspart selected-value - The element wrapping the selected value
+ * @csspart indicator - The element wrapping the visual indicator
+ * @csspart listbox - The listbox element
+ * @fires input - Fires a custom 'input' event when the value updates
+ * @fires change - Fires a custom 'change' event when the value updates
+ *
+ * @public
+ */
+export class Select extends FormAssociatedSelect {
+    constructor() {
+        super(...arguments);
+        /**
+         * The open attribute.
+         *
+         * @public
+         * @remarks
+         * HTML Attribute: open
+         */
+        this.open = false;
+        /**
+         * Indicates the initial state of the position attribute.
+         *
+         * @internal
+         */
+        this.forcedPosition = false;
+        /**
+         * The unique id for the internal listbox element.
+         *
+         * @internal
+         */
+        this.listboxId = uniqueId("listbox-");
+        /**
+         * The max height for the listbox when opened.
+         *
+         * @internal
+         */
+        this.maxHeight = 0;
+    }
+    /**
+     * Sets focus and synchronizes ARIA attributes when the open property changes.
+     *
+     * @param prev - the previous open value
+     * @param next - the current open value
+     *
+     * @internal
+     */
+    openChanged(prev, next) {
+        if (!this.collapsible) {
+            return;
+        }
+        if (this.open) {
+            this.ariaControls = this.listboxId;
+            this.ariaExpanded = "true";
+            this.setPositioning();
+            this.focusAndScrollOptionIntoView();
+            this.indexWhenOpened = this.selectedIndex;
+            // focus is directed to the element when `open` is changed programmatically
+            DOM.queueUpdate(() => this.focus());
+            return;
+        }
+        this.ariaControls = "";
+        this.ariaExpanded = "false";
+    }
+    /**
+     * The component is collapsible when in single-selection mode with no size attribute.
+     *
+     * @internal
+     */
+    get collapsible() {
+        return !(this.multiple || typeof this.size === "number");
+    }
+    /**
+     * The value property.
+     *
+     * @public
+     */
+    get value() {
+        Observable.track(this, "value");
+        return this._value;
+    }
+    set value(next) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const prev = `${this._value}`;
+        if ((_a = this._options) === null || _a === void 0 ? void 0 : _a.length) {
+            const selectedIndex = this._options.findIndex(el => el.value === next);
+            const prevSelectedValue = (_c = (_b = this._options[this.selectedIndex]) === null || _b === void 0 ? void 0 : _b.value) !== null && _c !== void 0 ? _c : null;
+            const nextSelectedValue = (_e = (_d = this._options[selectedIndex]) === null || _d === void 0 ? void 0 : _d.value) !== null && _e !== void 0 ? _e : null;
+            if (selectedIndex === -1 || prevSelectedValue !== nextSelectedValue) {
+                next = "";
+                this.selectedIndex = selectedIndex;
+            }
+            next = (_g = (_f = this.firstSelectedOption) === null || _f === void 0 ? void 0 : _f.value) !== null && _g !== void 0 ? _g : next;
+        }
+        if (prev !== next) {
+            this._value = next;
+            super.valueChanged(prev, next);
+            Observable.notify(this, "value");
+            this.updateDisplayValue();
+        }
+    }
+    /**
+     * Sets the value and display value to match the first selected option.
+     *
+     * @param shouldEmit - if true, the input and change events will be emitted
+     *
+     * @internal
+     */
+    updateValue(shouldEmit) {
+        var _a, _b;
+        if (this.$fastController.isConnected) {
+            this.value = (_b = (_a = this.firstSelectedOption) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : "";
+        }
+        if (shouldEmit) {
+            this.$emit("input");
+            this.$emit("change", this, {
+                bubbles: true,
+                composed: undefined,
+            });
+        }
+    }
+    /**
+     * Updates the proxy value when the selected index changes.
+     *
+     * @param prev - the previous selected index
+     * @param next - the next selected index
+     *
+     * @internal
+     */
+    selectedIndexChanged(prev, next) {
+        super.selectedIndexChanged(prev, next);
+        this.updateValue();
+    }
+    positionChanged(prev, next) {
+        this.positionAttribute = next;
+        this.setPositioning();
+    }
+    /**
+     * Calculate and apply listbox positioning based on available viewport space.
+     *
+     * @public
+     */
+    setPositioning() {
+        const currentBox = this.getBoundingClientRect();
+        const viewportHeight = window.innerHeight;
+        const availableBottom = viewportHeight - currentBox.bottom;
+        this.position = this.forcedPosition
+            ? this.positionAttribute
+            : currentBox.top > availableBottom
+                ? SelectPosition.above
+                : SelectPosition.below;
+        this.positionAttribute = this.forcedPosition
+            ? this.positionAttribute
+            : this.position;
+        this.maxHeight =
+            this.position === SelectPosition.above ? ~~currentBox.top : ~~availableBottom;
+    }
+    /**
+     * The value displayed on the button.
+     *
+     * @public
+     */
+    get displayValue() {
+        var _a, _b;
+        Observable.track(this, "displayValue");
+        return (_b = (_a = this.firstSelectedOption) === null || _a === void 0 ? void 0 : _a.text) !== null && _b !== void 0 ? _b : "";
+    }
+    /**
+     * Synchronize the `aria-disabled` property when the `disabled` property changes.
+     *
+     * @param prev - The previous disabled value
+     * @param next - The next disabled value
+     *
+     * @internal
+     */
+    disabledChanged(prev, next) {
+        if (super.disabledChanged) {
+            super.disabledChanged(prev, next);
+        }
+        this.ariaDisabled = this.disabled ? "true" : "false";
+    }
+    /**
+     * Reset the element to its first selectable option when its parent form is reset.
+     *
+     * @internal
+     */
+    formResetCallback() {
+        this.setProxyOptions();
+        // Call the base class's implementation setDefaultSelectedOption instead of the select's
+        // override, in order to reset the selectedIndex without using the value property.
+        super.setDefaultSelectedOption();
+        if (this.selectedIndex === -1) {
+            this.selectedIndex = 0;
+        }
+    }
+    /**
+     * Handle opening and closing the listbox when the select is clicked.
+     *
+     * @param e - the mouse event
+     * @internal
+     */
+    clickHandler(e) {
+        // do nothing if the select is disabled
+        if (this.disabled) {
+            return;
+        }
+        if (this.open) {
+            const captured = e.target.closest(`option,[role=option]`);
+            if (captured && captured.disabled) {
+                return;
+            }
+        }
+        super.clickHandler(e);
+        this.open = this.collapsible && !this.open;
+        if (!this.open && this.indexWhenOpened !== this.selectedIndex) {
+            this.updateValue(true);
+        }
+        return true;
+    }
+    /**
+     * Handles focus state when the element or its children lose focus.
+     *
+     * @param e - The focus event
+     * @internal
+     */
+    focusoutHandler(e) {
+        var _a;
+        super.focusoutHandler(e);
+        if (!this.open) {
+            return true;
+        }
+        const focusTarget = e.relatedTarget;
+        if (this.isSameNode(focusTarget)) {
+            this.focus();
+            return;
+        }
+        if (!((_a = this.options) === null || _a === void 0 ? void 0 : _a.includes(focusTarget))) {
+            this.open = false;
+            if (this.indexWhenOpened !== this.selectedIndex) {
+                this.updateValue(true);
+            }
+        }
+    }
+    /**
+     * Updates the value when an option's value changes.
+     *
+     * @param source - the source object
+     * @param propertyName - the property to evaluate
+     *
+     * @internal
+     * @override
+     */
+    handleChange(source, propertyName) {
+        super.handleChange(source, propertyName);
+        if (propertyName === "value") {
+            this.updateValue();
+        }
+    }
+    /**
+     * Synchronize the form-associated proxy and updates the value property of the element.
+     *
+     * @param prev - the previous collection of slotted option elements
+     * @param next - the next collection of slotted option elements
+     *
+     * @internal
+     */
+    slottedOptionsChanged(prev, next) {
+        this.options.forEach(o => {
+            const notifier = Observable.getNotifier(o);
+            notifier.unsubscribe(this, "value");
+        });
+        super.slottedOptionsChanged(prev, next);
+        this.options.forEach(o => {
+            const notifier = Observable.getNotifier(o);
+            notifier.subscribe(this, "value");
+        });
+        this.setProxyOptions();
+        this.updateValue();
+    }
+    /**
+     * Prevents focus when size is set and a scrollbar is clicked.
+     *
+     * @param e - the mouse event object
+     *
+     * @override
+     * @internal
+     */
+    mousedownHandler(e) {
+        var _a;
+        if (e.offsetX >= 0 && e.offsetX <= ((_a = this.listbox) === null || _a === void 0 ? void 0 : _a.scrollWidth)) {
+            return super.mousedownHandler(e);
+        }
+        return this.collapsible;
+    }
+    /**
+     * Sets the multiple property on the proxy element.
+     *
+     * @param prev - the previous multiple value
+     * @param next - the current multiple value
+     */
+    multipleChanged(prev, next) {
+        super.multipleChanged(prev, next);
+        if (this.proxy) {
+            this.proxy.multiple = next;
+        }
+    }
+    /**
+     * Updates the selectedness of each option when the list of selected options changes.
+     *
+     * @param prev - the previous list of selected options
+     * @param next - the current list of selected options
+     *
+     * @override
+     * @internal
+     */
+    selectedOptionsChanged(prev, next) {
+        var _a;
+        super.selectedOptionsChanged(prev, next);
+        (_a = this.options) === null || _a === void 0 ? void 0 : _a.forEach((o, i) => {
+            var _a;
+            const proxyOption = (_a = this.proxy) === null || _a === void 0 ? void 0 : _a.options.item(i);
+            if (proxyOption) {
+                proxyOption.selected = o.selected;
+            }
+        });
+    }
+    /**
+     * Sets the selected index to match the first option with the selected attribute, or
+     * the first selectable option.
+     *
+     * @override
+     * @internal
+     */
+    setDefaultSelectedOption() {
+        var _a;
+        const options = (_a = this.options) !== null && _a !== void 0 ? _a : Array.from(this.children).filter(Listbox.slottedOptionFilter);
+        const selectedIndex = options === null || options === void 0 ? void 0 : options.findIndex(el => el.hasAttribute("selected") || el.selected || el.value === this.value);
+        if (selectedIndex !== -1) {
+            this.selectedIndex = selectedIndex;
+            return;
+        }
+        this.selectedIndex = 0;
+    }
+    /**
+     * Resets and fills the proxy to match the component's options.
+     *
+     * @internal
+     */
+    setProxyOptions() {
+        if (this.proxy instanceof HTMLSelectElement && this.options) {
+            this.proxy.options.length = 0;
+            this.options.forEach(option => {
+                const proxyOption = option.proxy ||
+                    (option instanceof HTMLOptionElement ? option.cloneNode() : null);
+                if (proxyOption) {
+                    this.proxy.options.add(proxyOption);
+                }
+            });
+        }
+    }
+    /**
+     * Handle keyboard interaction for the select.
+     *
+     * @param e - the keyboard event
+     * @internal
+     */
+    keydownHandler(e) {
+        super.keydownHandler(e);
+        const key = e.key || e.key.charCodeAt(0);
+        switch (key) {
+            case keySpace: {
+                e.preventDefault();
+                if (this.collapsible && this.typeAheadExpired) {
+                    this.open = !this.open;
+                }
+                break;
+            }
+            case keyHome:
+            case keyEnd: {
+                e.preventDefault();
+                break;
+            }
+            case keyEnter: {
+                e.preventDefault();
+                this.open = !this.open;
+                break;
+            }
+            case keyEscape: {
+                if (this.collapsible && this.open) {
+                    e.preventDefault();
+                    this.open = false;
+                }
+                break;
+            }
+            case keyTab: {
+                if (this.collapsible && this.open) {
+                    e.preventDefault();
+                    this.open = false;
+                }
+                return true;
+            }
+        }
+        if (!this.open && this.indexWhenOpened !== this.selectedIndex) {
+            this.updateValue(true);
+            this.indexWhenOpened = this.selectedIndex;
+        }
+        return !(key === keyArrowDown || key === keyArrowUp);
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        this.forcedPosition = !!this.positionAttribute;
+        this.addEventListener("contentchange", this.updateDisplayValue);
+    }
+    disconnectedCallback() {
+        this.removeEventListener("contentchange", this.updateDisplayValue);
+        super.disconnectedCallback();
+    }
+    /**
+     * Updates the proxy's size property when the size attribute changes.
+     *
+     * @param prev - the previous size
+     * @param next - the current size
+     *
+     * @override
+     * @internal
+     */
+    sizeChanged(prev, next) {
+        super.sizeChanged(prev, next);
+        if (this.proxy) {
+            this.proxy.size = next;
+        }
+    }
+    /**
+     *
+     * @internal
+     */
+    updateDisplayValue() {
+        if (this.collapsible) {
+            Observable.notify(this, "displayValue");
+        }
+    }
+}
+__decorate([
+    attr({ attribute: "open", mode: "boolean" })
+], Select.prototype, "open", void 0);
+__decorate([
+    volatile
+], Select.prototype, "collapsible", null);
+__decorate([
+    observable
+], Select.prototype, "control", void 0);
+__decorate([
+    attr({ attribute: "position" })
+], Select.prototype, "positionAttribute", void 0);
+__decorate([
+    observable
+], Select.prototype, "position", void 0);
+__decorate([
+    observable
+], Select.prototype, "maxHeight", void 0);
+/**
+ * Includes ARIA states and properties relating to the ARIA select role.
+ *
+ * @public
+ */
+export class DelegatesARIASelect {
+}
+__decorate([
+    observable
+], DelegatesARIASelect.prototype, "ariaControls", void 0);
+applyMixins(DelegatesARIASelect, DelegatesARIAListbox);
+applyMixins(Select, StartEnd, DelegatesARIASelect);

package/dist/esm/select/select.options.js

@@ -0,0 +1,8 @@
+/**
+ * Positioning directions for the listbox when a select is open.
+ * @public
+ */
+export const SelectPosition = {
+    above: "above",
+    below: "below",
+};

package/dist/esm/select/select.template.js

@@ -0,0 +1,72 @@
+import { html, ref, slotted, when } from "@ni/fast-element";
+import { Listbox } from "../listbox/listbox.js";
+import { endSlotTemplate, startSlotTemplate } from "../patterns/start-end.js";
+/**
+ * The template for the {@link @ni/fast-foundation#(Select:class)} component.
+ * @public
+ */
+export const selectTemplate = (context, definition) => html `
+    <template
+        class="${x => [
+    x.collapsible && "collapsible",
+    x.collapsible && x.open && "open",
+    x.disabled && "disabled",
+    x.collapsible && x.position,
+]
+    .filter(Boolean)
+    .join(" ")}"
+        aria-activedescendant="${x => x.ariaActiveDescendant}"
+        aria-controls="${x => x.ariaControls}"
+        aria-disabled="${x => x.ariaDisabled}"
+        aria-expanded="${x => x.ariaExpanded}"
+        aria-haspopup="${x => (x.collapsible ? "listbox" : null)}"
+        aria-multiselectable="${x => x.ariaMultiSelectable}"
+        ?open="${x => x.open}"
+        role="combobox"
+        tabindex="${x => (!x.disabled ? "0" : null)}"
+        @click="${(x, c) => x.clickHandler(c.event)}"
+        @focusin="${(x, c) => x.focusinHandler(c.event)}"
+        @focusout="${(x, c) => x.focusoutHandler(c.event)}"
+        @keydown="${(x, c) => x.keydownHandler(c.event)}"
+        @mousedown="${(x, c) => x.mousedownHandler(c.event)}"
+    >
+        ${when(x => x.collapsible, html `
+                <div
+                    class="control"
+                    part="control"
+                    ?disabled="${x => x.disabled}"
+                    ${ref("control")}
+                >
+                    ${startSlotTemplate(context, definition)}
+                    <slot name="button-container">
+                        <div class="selected-value" part="selected-value">
+                            <slot name="selected-value">${x => x.displayValue}</slot>
+                        </div>
+                        <div aria-hidden="true" class="indicator" part="indicator">
+                            <slot name="indicator">
+                                ${definition.indicator || ""}
+                            </slot>
+                        </div>
+                    </slot>
+                    ${endSlotTemplate(context, definition)}
+                </div>
+            `)}
+        <div
+            class="listbox"
+            id="${x => x.listboxId}"
+            part="listbox"
+            role="listbox"
+            ?disabled="${x => x.disabled}"
+            ?hidden="${x => (x.collapsible ? !x.open : false)}"
+            ${ref("listbox")}
+        >
+            <slot
+                ${slotted({
+    filter: Listbox.slottedOptionFilter,
+    flatten: true,
+    property: "slottedOptions",
+})}
+            ></slot>
+        </div>
+    </template>
+`;

package/dist/esm/skeleton/index.js

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

package/dist/esm/skeleton/skeleton.js

@@ -0,0 +1,35 @@
+import { __decorate } from "tslib";
+import { attr } from "@ni/fast-element";
+import { FoundationElement } from "../foundation-element/foundation-element.js";
+/**
+ * A Skeleton Custom HTML Element.
+ *
+ * @slot - The default slot
+ *
+ * @public
+ */
+export class Skeleton extends FoundationElement {
+    constructor() {
+        super(...arguments);
+        /**
+         * Indicates what the shape of the Skeleton should be.
+         *
+         * @public
+         * @remarks
+         * HTML Attribute: shape
+         */
+        this.shape = "rect";
+    }
+}
+__decorate([
+    attr
+], Skeleton.prototype, "fill", void 0);
+__decorate([
+    attr
+], Skeleton.prototype, "shape", void 0);
+__decorate([
+    attr
+], Skeleton.prototype, "pattern", void 0);
+__decorate([
+    attr({ mode: "boolean" })
+], Skeleton.prototype, "shimmer", void 0);

package/dist/esm/skeleton/skeleton.template.js

@@ -0,0 +1,20 @@
+import { html, when } from "@ni/fast-element";
+/**
+ * The template for the fast-skeleton component
+ * @public
+ */
+export const skeletonTemplate = (context, definition) => html `
+    <template
+        class="${x => (x.shape === "circle" ? "circle" : "rect")}"
+        pattern="${x => x.pattern}"
+        ?shimmer="${x => x.shimmer}"
+    >
+        ${when(x => x.shimmer === true, html `
+                <span class="shimmer"></span>
+            `)}
+        <object type="image/svg+xml" data="${x => x.pattern}" role="presentation">
+            <img class="pattern" src="${x => x.pattern}" />
+        </object>
+        <slot></slot>
+    </template>
+`;

package/dist/esm/slider/index.js

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

package/dist/esm/slider/slider-utilities.js

@@ -0,0 +1,11 @@
+import { Direction, limit } from "@ni/fast-web-utilities";
+/**
+ * Converts a pixel coordinate on the track to a percent of the track's range
+ */
+export function convertPixelToPercent(pixelPos, minPosition, maxPosition, direction) {
+    let pct = limit(0, 1, (pixelPos - minPosition) / (maxPosition - minPosition));
+    if (direction === Direction.rtl) {
+        pct = 1 - pct;
+    }
+    return pct;
+}

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

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