jekyll-v4-theme-primer 0.11.0 → 0.13.0

data/_sass/@primer/view-components/app/components/primer/dialog_helper.js

@@ -0,0 +1,117 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _DialogHelperElement_abortController;
+function dialogInvokerButtonHandler(event) {
+    const target = event.target;
+    const button = target?.closest('button');
+    if (!button || button.hasAttribute('disabled') || button.getAttribute('aria-disabled') === 'true')
+        return;
+    // If the user is clicking a valid dialog trigger
+    let dialogId = button?.getAttribute('data-show-dialog-id');
+    if (dialogId) {
+        const dialog = document.getElementById(dialogId);
+        if (dialog instanceof HTMLDialogElement) {
+            dialog.showModal();
+            // A buttons default behaviour in some browsers it to send a pointer event
+            // If the behaviour is allowed through the dialog will be shown but then
+            // quickly hidden- as if it were never shown. This prevents that.
+            event.preventDefault();
+            // In some older browsers, such as Chrome 122, when a top layer element (such as a dialog)
+            // opens from within a popover, the "hide all popovers" internal algorithm runs, hiding
+            // any popover that is currently open, regardless of whether or not another top layer element,
+            // such as a <dialog> is nested inside.
+            // See https://github.com/whatwg/html/issues/9998.
+            // This is fixed by https://github.com/whatwg/html/pull/10116, but while we still support browsers
+            // that present this bug, we must undo the work they did to hide ancestral popovers of the dialog:
+            let node = button;
+            let fixed = false;
+            while (node) {
+                node = node.parentElement?.closest('[popover]:not(:popover-open)');
+                if (node && node.popover === 'auto') {
+                    node.classList.add('dialog-inside-popover-fix');
+                    node.popover = 'manual';
+                    node.showPopover();
+                    fixed = true;
+                }
+            }
+            if (fixed) {
+                // We need to re-open the dialog as modal, and also ensure no close event listeners
+                // are trying to act on the close
+                /* eslint-disable-next-line no-restricted-syntax */
+                dialog.addEventListener('close', e => e.stopImmediatePropagation(), { once: true });
+                dialog.close();
+                dialog.showModal();
+                dialog.addEventListener('close', () => {
+                    for (const el of dialog.ownerDocument.querySelectorAll('.dialog-inside-popover-fix')) {
+                        if (el.contains(dialog)) {
+                            el.classList.remove('dialog-inside-popover-fix');
+                            el.popover = 'auto';
+                            el.showPopover();
+                        }
+                    }
+                }, { once: true });
+            }
+        }
+    }
+    dialogId = button.getAttribute('data-close-dialog-id') || button.getAttribute('data-submit-dialog-id');
+    if (dialogId) {
+        const dialog = document.getElementById(dialogId);
+        if (dialog instanceof HTMLDialogElement && dialog.open) {
+            dialog.close();
+        }
+    }
+}
+export class DialogHelperElement extends HTMLElement {
+    constructor() {
+        super(...arguments);
+        _DialogHelperElement_abortController.set(this, null);
+    }
+    get dialog() {
+        return this.querySelector('dialog');
+    }
+    connectedCallback() {
+        const { signal } = (__classPrivateFieldSet(this, _DialogHelperElement_abortController, new AbortController(), "f"));
+        document.addEventListener('click', dialogInvokerButtonHandler, true);
+        document.addEventListener('click', this, { signal });
+        this.ownerDocument.body.style.setProperty('--dialog-scrollgutter', `${window.innerWidth - this.ownerDocument.body.clientWidth}px`);
+        new MutationObserver(records => {
+            for (const record of records) {
+                if (record.target === this.dialog) {
+                    this.ownerDocument.body.classList.toggle('has-modal', this.dialog.hasAttribute('open'));
+                }
+            }
+        }).observe(this, { subtree: true, attributeFilter: ['open'] });
+    }
+    disconnectedCallback() {
+        __classPrivateFieldGet(this, _DialogHelperElement_abortController, "f")?.abort();
+    }
+    handleEvent(event) {
+        const target = event.target;
+        const dialog = this.dialog;
+        // The click target _must_ be the dialog element itself, and not elements underneath or inside.
+        if (target !== dialog || !dialog?.open)
+            return;
+        const rect = dialog.getBoundingClientRect();
+        const clickWasInsideDialog = rect.top <= event.clientY &&
+            event.clientY <= rect.top + rect.height &&
+            rect.left <= event.clientX &&
+            event.clientX <= rect.left + rect.width;
+        if (!clickWasInsideDialog) {
+            dialog.close();
+        }
+    }
+}
+_DialogHelperElement_abortController = new WeakMap();
+if (!window.customElements.get('dialog-helper')) {
+    window.DialogHelperElement = DialogHelperElement;
+    window.customElements.define('dialog-helper', DialogHelperElement);
+}

data/_sass/@primer/view-components/app/components/primer/focus_group.d.ts

@@ -0,0 +1,19 @@
+import '@oddbird/popover-polyfill';
+export default class FocusGroupElement extends HTMLElement {
+    #private;
+    get nowrap(): boolean;
+    set nowrap(value: boolean);
+    get direction(): 'horizontal' | 'vertical' | 'both';
+    set direction(value: 'horizontal' | 'vertical' | 'both');
+    get retain(): boolean;
+    set retain(value: boolean);
+    get mnemonics(): boolean;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    handleEvent(event: Event): void;
+}
+declare global {
+    interface Window {
+        FocusGroupElement: typeof FocusGroupElement;
+    }
+}

data/_sass/@primer/view-components/app/components/primer/focus_group.js

@@ -0,0 +1,163 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _FocusGroupElement_instances, _FocusGroupElement_retainSignal, _FocusGroupElement_abortController, _FocusGroupElement_items_get;
+import '@oddbird/popover-polyfill';
+const validSelectors = ['[role="menuitem"]', '[role="menuitemcheckbox"]', '[role="menuitemradio"]'];
+const menuItemSelector = validSelectors.map(selector => `:not([hidden]) > ${selector}`).join(', ');
+const getMnemonicFor = (item) => item.textContent?.trim()[0].toLowerCase();
+const printable = /^\S$/;
+class FocusGroupElement extends HTMLElement {
+    constructor() {
+        super(...arguments);
+        _FocusGroupElement_instances.add(this);
+        _FocusGroupElement_retainSignal.set(this, null);
+        _FocusGroupElement_abortController.set(this, null);
+    }
+    get nowrap() {
+        return this.hasAttribute('nowrap');
+    }
+    set nowrap(value) {
+        this.toggleAttribute('nowrap', value);
+    }
+    get direction() {
+        if (this.getAttribute('direction') === 'horizontal')
+            return 'horizontal';
+        return 'vertical';
+    }
+    set direction(value) {
+        this.setAttribute('direction', `${value}`);
+    }
+    get retain() {
+        return this.hasAttribute('retain');
+    }
+    set retain(value) {
+        this.toggleAttribute('retain', value);
+    }
+    get mnemonics() {
+        return this.hasAttribute('mnemonics');
+    }
+    connectedCallback() {
+        __classPrivateFieldSet(this, _FocusGroupElement_abortController, new AbortController(), "f");
+        const { signal } = __classPrivateFieldGet(this, _FocusGroupElement_abortController, "f");
+        this.addEventListener('keydown', this, { signal });
+        this.addEventListener('click', this, { signal });
+        this.addEventListener('mouseover', this, { signal });
+        this.addEventListener('focusin', this, { signal });
+    }
+    disconnectedCallback() {
+        __classPrivateFieldGet(this, _FocusGroupElement_abortController, "f")?.abort();
+    }
+    handleEvent(event) {
+        const { direction, nowrap } = this;
+        if (event.type === 'focusin') {
+            if (this.retain && event.target instanceof Element && event.target.matches(menuItemSelector)) {
+                __classPrivateFieldGet(this, _FocusGroupElement_retainSignal, "f")?.abort();
+                const { signal } = (__classPrivateFieldSet(this, _FocusGroupElement_retainSignal, new AbortController(), "f"));
+                for (const item of __classPrivateFieldGet(this, _FocusGroupElement_instances, "a", _FocusGroupElement_items_get)) {
+                    item.setAttribute('tabindex', item === event.target ? '0' : '-1');
+                    const popover = event.target.closest('[popover]');
+                    if (item === event.target && popover?.popover === 'auto' && popover.closest('focus-group') === this) {
+                        popover.addEventListener('toggle', (toggleEvent) => {
+                            if (!(toggleEvent.target instanceof Element))
+                                return;
+                            if (toggleEvent.newState === 'closed') {
+                                __classPrivateFieldGet(this, _FocusGroupElement_retainSignal, "f")?.abort();
+                                item.setAttribute('tabindex', '-1');
+                                if (popover.id) {
+                                    const invoker = this.querySelector(`[popovertarget="${popover.id}"]`);
+                                    if (invoker) {
+                                        invoker.setAttribute('tabindex', '0');
+                                    }
+                                    else {
+                                        __classPrivateFieldGet(this, _FocusGroupElement_instances, "a", _FocusGroupElement_items_get)[0]?.setAttribute('tabindex', '0');
+                                    }
+                                }
+                            }
+                        }, { signal });
+                    }
+                }
+            }
+        }
+        else if (event instanceof KeyboardEvent) {
+            const items = Array.from(__classPrivateFieldGet(this, _FocusGroupElement_instances, "a", _FocusGroupElement_items_get));
+            let index = items.indexOf(event.target);
+            const key = event.key;
+            if (key === 'Up' || key === 'ArrowUp') {
+                if (direction === 'vertical' || direction === 'both') {
+                    index -= index < 0 ? 0 : 1;
+                    event.preventDefault();
+                }
+            }
+            else if (key === 'Down' || key === 'ArrowDown') {
+                if (direction === 'vertical' || direction === 'both') {
+                    index += 1;
+                    event.preventDefault();
+                }
+            }
+            else if (event.key === 'Left' || event.key === 'ArrowLeft') {
+                if (direction === 'horizontal' || direction === 'both') {
+                    index -= 1;
+                    event.preventDefault();
+                }
+            }
+            else if (event.key === 'Right' || event.key === 'ArrowRight') {
+                if (direction === 'horizontal' || direction === 'both') {
+                    index += 1;
+                    event.preventDefault();
+                }
+            }
+            else if (event.key === 'Home' || event.key === 'PageUp') {
+                index = 0;
+                event.preventDefault();
+            }
+            else if (event.key === 'End' || event.key === 'PageDown') {
+                index = items.length - 1;
+                event.preventDefault();
+            }
+            else if (this.mnemonics && printable.test(key)) {
+                const mnemonic = key.toLowerCase();
+                const offset = index > 0 && getMnemonicFor(event.target) === mnemonic ? index : 0;
+                index = items.findIndex((item, i) => i > offset && getMnemonicFor(item) === mnemonic);
+                if (index < 0 && !nowrap) {
+                    index = items.findIndex(item => getMnemonicFor(item) === mnemonic);
+                }
+            }
+            else {
+                return;
+            }
+            if (nowrap && index < 0)
+                index = 0;
+            if (!nowrap && index >= items.length)
+                index = 0;
+            const focusEl = items.at(Math.min(index, items.length - 1));
+            {
+                let el = focusEl;
+                do {
+                    el = el.closest(`[popover]:not(:popover-open)`);
+                    if (el?.popover === 'auto' && !['ArrowRight', 'ArrowLeft'].includes(event.key)) {
+                        el.showPopover();
+                    }
+                    el = el?.parentElement || null;
+                } while (el);
+            }
+            focusEl?.focus();
+        }
+    }
+}
+_FocusGroupElement_retainSignal = new WeakMap(), _FocusGroupElement_abortController = new WeakMap(), _FocusGroupElement_instances = new WeakSet(), _FocusGroupElement_items_get = function _FocusGroupElement_items_get() {
+    return this.querySelectorAll(menuItemSelector);
+};
+export default FocusGroupElement;
+if (!customElements.get('focus-group')) {
+    window.FocusGroupElement = FocusGroupElement;
+    customElements.define('focus-group', FocusGroupElement);
+}

data/_sass/@primer/view-components/app/components/primer/primer.d.ts

@@ -1,16 +1,23 @@
+import '@github/include-fragment-element';
+import './alpha/action_bar_element';
 import './alpha/dropdown';
+import './anchored_position';
+import './dialog_helper';
+import './focus_group';
+import './scrollable_region';
 import './alpha/image_crop';
 import './alpha/modal_dialog';
-import './alpha/nav_list';
+import './beta/nav_list';
+import './beta/nav_list_group_element';
 import './alpha/segmented_control';
 import './alpha/toggle_switch';
 import './alpha/tool_tip';
 import './alpha/x_banner';
 import './beta/auto_complete/auto_complete';
 import './beta/clipboard_copy';
-import './local_time';
+import './beta/relative_time';
 import './alpha/tab_container';
-import './time_ago_component';
 import '../../../lib/primer/forms/primer_multi_input';
 import '../../../lib/primer/forms/primer_text_field';
 import '../../../lib/primer/forms/toggle_switch_input';
+import './alpha/action_menu/action_menu_element';

data/_sass/@primer/view-components/app/components/primer/primer.js

@@ -1,16 +1,23 @@
+import '@github/include-fragment-element';
+import './alpha/action_bar_element';
 import './alpha/dropdown';
+import './anchored_position';
+import './dialog_helper';
+import './focus_group';
+import './scrollable_region';
 import './alpha/image_crop';
 import './alpha/modal_dialog';
-import './alpha/nav_list';
+import './beta/nav_list';
+import './beta/nav_list_group_element';
 import './alpha/segmented_control';
 import './alpha/toggle_switch';
 import './alpha/tool_tip';
 import './alpha/x_banner';
 import './beta/auto_complete/auto_complete';
 import './beta/clipboard_copy';
-import './local_time';
+import './beta/relative_time';
 import './alpha/tab_container';
-import './time_ago_component';
 import '../../../lib/primer/forms/primer_multi_input';
 import '../../../lib/primer/forms/primer_text_field';
 import '../../../lib/primer/forms/toggle_switch_input';
+import './alpha/action_menu/action_menu_element';

data/_sass/@primer/view-components/app/components/primer/scrollable_region.d.ts

@@ -0,0 +1,13 @@
+export declare class ScrollableRegionElement extends HTMLElement {
+    hasOverflow: boolean;
+    labelledBy: string;
+    observer: ResizeObserver;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+}
+declare global {
+    interface Window {
+        ScrollableRegionElement: typeof ScrollableRegionElement;
+    }
+}

data/_sass/@primer/view-components/app/components/primer/scrollable_region.js

@@ -0,0 +1,52 @@
+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 { controller, attr } from '@github/catalyst';
+let ScrollableRegionElement = class ScrollableRegionElement extends HTMLElement {
+    constructor() {
+        super(...arguments);
+        this.hasOverflow = false;
+        this.labelledBy = '';
+    }
+    connectedCallback() {
+        this.style.overflow = 'auto';
+        this.observer = new ResizeObserver(entries => {
+            for (const entry of entries) {
+                this.hasOverflow =
+                    entry.target.scrollHeight > entry.target.clientHeight || entry.target.scrollWidth > entry.target.clientWidth;
+            }
+        });
+        this.observer.observe(this);
+    }
+    disconnectedCallback() {
+        this.observer.disconnect();
+    }
+    attributeChangedCallback(name) {
+        if (name === 'data-has-overflow') {
+            if (this.hasOverflow) {
+                this.setAttribute('aria-labelledby', this.labelledBy);
+                this.setAttribute('role', 'region');
+                this.setAttribute('tabindex', '0');
+            }
+            else {
+                this.removeAttribute('aria-labelledby');
+                this.removeAttribute('role');
+                this.removeAttribute('tabindex');
+            }
+        }
+    }
+};
+__decorate([
+    attr
+], ScrollableRegionElement.prototype, "hasOverflow", void 0);
+__decorate([
+    attr
+], ScrollableRegionElement.prototype, "labelledBy", void 0);
+ScrollableRegionElement = __decorate([
+    controller
+], ScrollableRegionElement);
+export { ScrollableRegionElement };
+window.ScrollableRegionElement = ScrollableRegionElement;

data/_sass/@primer/view-components/app/components/primer/truncate.css.json

@@ -1 +1,13 @@
-{"name":"truncate","selectors":[".css-truncate .css-truncate-overflow",".css-truncate .css-truncate-target",".css-truncate.css-truncate-overflow",".css-truncate.css-truncate-target",".css-truncate.expandable.css-truncate-target:hover",".css-truncate.expandable.zeroclipboard-is-hover .css-truncate-target",".css-truncate.expandable.zeroclipboard-is-hover.css-truncate-target",".css-truncate.expandable:hover .css-truncate-target"]}
+{
+  "name": "truncate",
+  "selectors": [
+    ".css-truncate .css-truncate-overflow",
+    ".css-truncate .css-truncate-target",
+    ".css-truncate.css-truncate-overflow",
+    ".css-truncate.css-truncate-target",
+    ".css-truncate.expandable.css-truncate-target:hover",
+    ".css-truncate.expandable.zeroclipboard-is-hover .css-truncate-target",
+    ".css-truncate.expandable.zeroclipboard-is-hover.css-truncate-target",
+    ".css-truncate.expandable:hover .css-truncate-target"
+  ]
+}

data/_sass/@primer/view-components/lib/primer/forms/primer_multi_input.js

@@ -8,7 +8,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { controller, targets } from '@github/catalyst';
 let PrimerMultiInputElement = class PrimerMultiInputElement extends HTMLElement {
     activateField(name) {
-        var _a, _b;
         const fieldWithName = this.findField(name);
         if (!fieldWithName)
             return;
@@ -17,11 +16,11 @@ let PrimerMultiInputElement = class PrimerMultiInputElement extends HTMLElement
                 continue;
             field.setAttribute('disabled', 'disabled');
             field.setAttribute('hidden', 'hidden');
-            (_a = field.parentElement) === null || _a === void 0 ? void 0 : _a.setAttribute('hidden', 'hidden');
+            field.parentElement?.setAttribute('hidden', 'hidden');
         }
         fieldWithName.removeAttribute('disabled');
         fieldWithName.removeAttribute('hidden');
-        (_b = fieldWithName.parentElement) === null || _b === void 0 ? void 0 : _b.removeAttribute('hidden');
+        fieldWithName.parentElement?.removeAttribute('hidden');
     }
     findField(name) {
         for (const field of this.fields) {

data/_sass/@primer/view-components/lib/primer/forms/primer_text_field.js

@@ -18,33 +18,70 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
 var _PrimerTextFieldElement_abortController;
 import '@github/auto-check-element';
 import { controller, target } from '@github/catalyst';
-let PrimerTextFieldElement = class PrimerTextFieldElement extends HTMLElement {
+// eslint-disable-next-line custom-elements/expose-class-on-global
+let PrimerTextFieldElement = 
+// eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+class PrimerTextFieldElement extends HTMLElement {
     constructor() {
         super(...arguments);
         _PrimerTextFieldElement_abortController.set(this, void 0);
     }
     connectedCallback() {
-        var _a;
-        (_a = __classPrivateFieldGet(this, _PrimerTextFieldElement_abortController, "f")) === null || _a === void 0 ? void 0 : _a.abort();
+        __classPrivateFieldGet(this, _PrimerTextFieldElement_abortController, "f")?.abort();
         const { signal } = (__classPrivateFieldSet(this, _PrimerTextFieldElement_abortController, new AbortController(), "f"));
-        this.inputElement.addEventListener('auto-check-success', () => { this.clearError(); }, { signal });
-        this.inputElement.addEventListener('auto-check-error', (event) => {
-            event.detail.response.text().then((error_message) => { this.setError(error_message); });
+        this.inputElement.addEventListener('auto-check-success', async (event) => {
+            const message = await event.detail.response.text();
+            if (message && message.length > 0) {
+                this.setSuccess(message);
+            }
+            else {
+                this.clearError();
+            }
+        }, { signal });
+        this.inputElement.addEventListener('auto-check-error', async (event) => {
+            const errorMessage = await event.detail.response.text();
+            this.setError(errorMessage);
         }, { signal });
     }
     disconnectedCallback() {
-        var _a;
-        (_a = __classPrivateFieldGet(this, _PrimerTextFieldElement_abortController, "f")) === null || _a === void 0 ? void 0 : _a.abort();
+        __classPrivateFieldGet(this, _PrimerTextFieldElement_abortController, "f")?.abort();
+    }
+    clearContents() {
+        this.inputElement.value = '';
+        this.inputElement.focus();
     }
     clearError() {
         this.inputElement.removeAttribute('invalid');
         this.validationElement.hidden = true;
-        this.validationMessageElement.innerText = '';
+        this.validationMessageElement.replaceChildren();
+    }
+    setValidationMessage(message) {
+        const template = document.createElement('template');
+        // eslint-disable-next-line github/no-inner-html
+        template.innerHTML = message;
+        const fragment = document.importNode(template.content, true);
+        this.validationMessageElement.replaceChildren(fragment);
+    }
+    toggleValidationStyling(isError) {
+        if (isError) {
+            this.validationElement.classList.remove('FormControl-inlineValidation--success');
+        }
+        else {
+            this.validationElement.classList.add('FormControl-inlineValidation--success');
+        }
+        this.validationSuccessIcon.hidden = isError;
+        this.validationErrorIcon.hidden = !isError;
+        this.inputElement.setAttribute('invalid', isError ? 'true' : 'false');
+    }
+    setSuccess(message) {
+        this.toggleValidationStyling(false);
+        this.setValidationMessage(message);
+        this.validationElement.hidden = false;
     }
     setError(message) {
-        this.validationMessageElement.innerText = message;
+        this.toggleValidationStyling(true);
+        this.setValidationMessage(message);
         this.validationElement.hidden = false;
-        this.inputElement.setAttribute('invalid', 'true');
     }
 };
 _PrimerTextFieldElement_abortController = new WeakMap();
@@ -57,6 +94,13 @@ __decorate([
 __decorate([
     target
 ], PrimerTextFieldElement.prototype, "validationMessageElement", void 0);
+__decorate([
+    target
+], PrimerTextFieldElement.prototype, "validationSuccessIcon", void 0);
+__decorate([
+    target
+], PrimerTextFieldElement.prototype, "validationErrorIcon", void 0);
 PrimerTextFieldElement = __decorate([
     controller
+    // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
 ], PrimerTextFieldElement);

data/_sass/@primer/view-components/lib/primer/forms/toggle_switch_input.js

@@ -1,3 +1,4 @@
+/* eslint-disable custom-elements/expose-class-on-global */
 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);
@@ -8,11 +9,15 @@ import { controller, target } from '@github/catalyst';
 let ToggleSwitchInputElement = class ToggleSwitchInputElement extends HTMLElement {
     connectedCallback() {
         this.addEventListener('toggleSwitchError', (event) => {
-            this.validationMessageElement.innerText = event.detail;
+            this.validationMessageElement.textContent = event.detail;
             this.validationElement.removeAttribute('hidden');
         });
         this.addEventListener('toggleSwitchSuccess', () => {
-            this.validationMessageElement.innerText = '';
+            this.validationMessageElement.textContent = '';
+            this.validationElement.setAttribute('hidden', 'hidden');
+        });
+        this.addEventListener('toggleSwitchLoading', () => {
+            this.validationMessageElement.textContent = '';
             this.validationElement.setAttribute('hidden', 'hidden');
         });
     }