@lmfaole/basics 0.3.0 → 0.4.0

package/components/basic-table/index.js

@@ -12,6 +12,22 @@ const GENERATED_ROW_HEADER_ATTRIBUTE = "data-basic-table-generated-row-header";
 const GENERATED_DESCRIPTION_ATTRIBUTE = "data-basic-table-generated-description";
 const MANAGED_HEADERS_ATTRIBUTE = "data-basic-table-managed-headers";
 const MANAGED_LABEL_ATTRIBUTE = "data-basic-table-managed-label";
+const TABLE_OBSERVER_OPTIONS = {
+    childList: true,
+    subtree: true,
+    characterData: true,
+    attributes: true,
+    attributeFilter: [
+        "aria-describedby",
+        "aria-label",
+        "aria-labelledby",
+        "colspan",
+        "headers",
+        "id",
+        "rowspan",
+        "scope",
+    ],
+};
 
 let nextTableInstanceId = 1;
 
@@ -198,6 +214,21 @@ function replaceCellTag(cell, tagName, generatedAttributeName) {
     return replacement;
 }
 
+function demoteManagedHeaderCell(cell, generatedAttributeName) {
+    const replacement = document.createElement("td");
+
+    for (const attribute of Array.from(cell.attributes)) {
+        if (attribute.name === generatedAttributeName || attribute.name === "scope") {
+            continue;
+        }
+
+        replacement.setAttribute(attribute.name, attribute.value);
+    }
+
+    replacement.replaceChildren(...Array.from(cell.childNodes));
+    cell.parentElement?.replaceChild(replacement, cell);
+}
+
 function promoteFirstRowCellsToHeaders(table) {
     const firstRow = table.rows[0];
 
@@ -214,38 +245,41 @@ function promoteFirstRowCellsToHeaders(table) {
     }
 }
 
-function promoteBodyCellsToRowHeaders(table, rowHeaderColumnIndex) {
-    for (const section of Array.from(table.tBodies)) {
-        for (const row of Array.from(section.rows)) {
-            const targetCell = findCellAtColumnIndex(row, rowHeaderColumnIndex);
-
-            if (!(targetCell instanceof HTMLTableCellElementBase) || targetCell.tagName === "TH") {
-                continue;
-            }
-
-            replaceCellTag(targetCell, "th", GENERATED_ROW_HEADER_ATTRIBUTE);
-        }
-    }
-}
-
 function demoteManagedHeaders(table, generatedAttributeName) {
     for (const cell of Array.from(table.querySelectorAll(`th[${generatedAttributeName}]`))) {
         if (!(cell instanceof HTMLTableCellElementBase)) {
             continue;
         }
 
-        const replacement = document.createElement("td");
+        demoteManagedHeaderCell(cell, generatedAttributeName);
+    }
+}
 
-        for (const attribute of Array.from(cell.attributes)) {
-            if (attribute.name === generatedAttributeName || attribute.name === "scope") {
+function syncBodyRowHeaders(table, rowHeaderColumnIndex, rowHeadersEnabled) {
+    for (const section of Array.from(table.tBodies)) {
+        for (const row of Array.from(section.rows)) {
+            const targetCell = rowHeadersEnabled
+                ? findCellAtColumnIndex(row, rowHeaderColumnIndex)
+                : null;
+
+            for (const cell of Array.from(row.cells)) {
+                if (
+                    !(cell instanceof HTMLTableCellElementBase)
+                    || !cell.hasAttribute(GENERATED_ROW_HEADER_ATTRIBUTE)
+                    || cell === targetCell
+                ) {
+                    continue;
+                }
+
+                demoteManagedHeaderCell(cell, GENERATED_ROW_HEADER_ATTRIBUTE);
+            }
+
+            if (!(targetCell instanceof HTMLTableCellElementBase) || targetCell.tagName === "TH") {
                 continue;
             }
 
-            replacement.setAttribute(attribute.name, attribute.value);
+            replaceCellTag(targetCell, "th", GENERATED_ROW_HEADER_ATTRIBUTE);
         }
-
-        replacement.replaceChildren(...Array.from(cell.childNodes));
-        cell.parentElement?.replaceChild(replacement, cell);
     }
 }
 
@@ -256,6 +290,12 @@ function createGeneratedCaption(table) {
     return caption;
 }
 
+function syncTextContent(node, text) {
+    if (node.textContent !== text) {
+        node.textContent = text;
+    }
+}
+
 function syncTableCaption(table, captionText) {
     const existingCaption = table.caption;
     const generatedCaption = existingCaption?.hasAttribute(GENERATED_CAPTION_ATTRIBUTE)
@@ -272,18 +312,12 @@ function syncTableCaption(table, captionText) {
     }
 
     const caption = generatedCaption ?? createGeneratedCaption(table);
-    caption.textContent = captionText;
+    syncTextContent(caption, captionText);
 }
 
 function syncFallbackAccessibleName(table, label) {
     const hasCaption = Boolean(table.caption);
-    let hasManagedLabel = table.hasAttribute(MANAGED_LABEL_ATTRIBUTE);
-
-    if (hasManagedLabel && table.getAttribute("aria-label") !== label) {
-        table.removeAttribute(MANAGED_LABEL_ATTRIBUTE);
-        hasManagedLabel = false;
-    }
-
+    const hasManagedLabel = table.hasAttribute(MANAGED_LABEL_ATTRIBUTE);
     const hasOwnAriaLabel = table.hasAttribute("aria-label") && !hasManagedLabel;
     const hasOwnLabelledBy = table.hasAttribute("aria-labelledby");
 
@@ -296,8 +330,13 @@ function syncFallbackAccessibleName(table, label) {
         return;
     }
 
-    table.setAttribute("aria-label", label);
-    table.setAttribute(MANAGED_LABEL_ATTRIBUTE, "");
+    if (table.getAttribute("aria-label") !== label) {
+        table.setAttribute("aria-label", label);
+    }
+
+    if (!hasManagedLabel) {
+        table.setAttribute(MANAGED_LABEL_ATTRIBUTE, "");
+    }
 }
 
 function getGeneratedDescription(root) {
@@ -321,7 +360,11 @@ function syncTableDescription(root, table, descriptionText, baseId) {
             );
 
             if (tokens.length > 0) {
-                table.setAttribute("aria-describedby", tokens.join(" "));
+                const nextValue = tokens.join(" ");
+
+                if (table.getAttribute("aria-describedby") !== nextValue) {
+                    table.setAttribute("aria-describedby", nextValue);
+                }
             } else {
                 table.removeAttribute("aria-describedby");
             }
@@ -343,13 +386,17 @@ function syncTableDescription(root, table, descriptionText, baseId) {
         description.id = `${baseId}-description`;
     }
 
-    description.textContent = descriptionText;
+    syncTextContent(description, descriptionText);
 
     const tokens = getAriaReferenceTokens(table.getAttribute("aria-describedby")).filter(
         (token) => token !== description.id,
     );
     tokens.push(description.id);
-    table.setAttribute("aria-describedby", tokens.join(" "));
+    const nextValue = tokens.join(" ");
+
+    if (table.getAttribute("aria-describedby") !== nextValue) {
+        table.setAttribute("aria-describedby", nextValue);
+    }
 }
 
 export class TableElement extends HTMLElementBase {
@@ -364,6 +411,7 @@ export class TableElement extends HTMLElementBase {
 
     #instanceId = `${TABLE_TAG_NAME}-${nextTableInstanceId++}`;
     #observer = null;
+    #observing = false;
     #scheduledFrame = 0;
 
     connectedCallback() {
@@ -372,7 +420,7 @@ export class TableElement extends HTMLElementBase {
     }
 
     disconnectedCallback() {
-        this.#observer?.disconnect();
+        this.#stopObserving();
         this.#observer = null;
 
         if (this.#scheduledFrame !== 0 && typeof window !== "undefined") {
@@ -386,119 +434,126 @@ export class TableElement extends HTMLElementBase {
     }
 
     refresh() {
-        const table = collectOwnedTables(this)[0] ?? null;
+        this.#stopObserving();
 
-        if (!(table instanceof HTMLTableElementBase)) {
-            return;
-        }
+        try {
+            const table = collectOwnedTables(this)[0] ?? null;
 
-        const label = normalizeTableLabel(this.getAttribute("data-label"));
-        const caption = normalizeTableCaption(this.getAttribute("data-caption"));
-        const description = normalizeTableDescription(this.getAttribute("data-description"));
-        const columnHeadersEnabled = normalizeTableColumnHeaders(
-            this.getAttribute("data-column-headers") ?? this.hasAttribute("data-column-headers"),
-        );
-        const rowHeaderColumnIndex = normalizeTableRowHeaderColumn(
-            this.getAttribute("data-row-header-column"),
-        ) - 1;
-        const rowHeadersEnabled = normalizeTableRowHeaders(
-            this.getAttribute("data-row-headers") ?? this.hasAttribute("data-row-header-column"),
-        );
-        const baseId = this.id || this.#instanceId;
-
-        syncTableCaption(table, caption);
-        syncFallbackAccessibleName(table, label);
-        syncTableDescription(this, table, description, baseId);
-
-        if (columnHeadersEnabled) {
-            promoteFirstRowCellsToHeaders(table);
-        } else {
-            demoteManagedHeaders(table, GENERATED_COLUMN_HEADER_ATTRIBUTE);
-        }
+            if (!(table instanceof HTMLTableElementBase)) {
+                return;
+            }
 
-        if (rowHeadersEnabled) {
-            demoteManagedHeaders(table, GENERATED_ROW_HEADER_ATTRIBUTE);
-            promoteBodyCellsToRowHeaders(table, rowHeaderColumnIndex);
-        } else {
-            demoteManagedHeaders(table, GENERATED_ROW_HEADER_ATTRIBUTE);
-        }
+            const label = normalizeTableLabel(this.getAttribute("data-label"));
+            const caption = normalizeTableCaption(this.getAttribute("data-caption"));
+            const description = normalizeTableDescription(this.getAttribute("data-description"));
+            const columnHeadersEnabled = normalizeTableColumnHeaders(
+                this.getAttribute("data-column-headers") ?? this.hasAttribute("data-column-headers"),
+            );
+            const rowHeaderColumnIndex = normalizeTableRowHeaderColumn(
+                this.getAttribute("data-row-header-column"),
+            ) - 1;
+            const rowHeadersEnabled = normalizeTableRowHeaders(
+                this.getAttribute("data-row-headers") ?? this.hasAttribute("data-row-header-column"),
+            );
+            const baseId = this.id || this.#instanceId;
 
-        const placements = buildTablePlacements(table);
-        const headerPlacements = [];
-        let nextHeaderIndex = 1;
+            syncTableCaption(table, caption);
+            syncFallbackAccessibleName(table, label);
+            syncTableDescription(this, table, description, baseId);
 
-        for (const placement of placements) {
-            if (placement.cell.tagName !== "TH") {
-                continue;
+            if (columnHeadersEnabled) {
+                promoteFirstRowCellsToHeaders(table);
+            } else {
+                demoteManagedHeaders(table, GENERATED_COLUMN_HEADER_ATTRIBUTE);
             }
 
-            const scope = inferHeaderScope(placement.cell, placement, {
-                columnHeadersEnabled,
-                rowHeadersEnabled,
-                rowHeaderColumnIndex,
-            });
+            syncBodyRowHeaders(table, rowHeaderColumnIndex, rowHeadersEnabled);
 
-            if (scope) {
-                placement.cell.setAttribute("scope", scope);
-            }
+            const placements = buildTablePlacements(table);
+            const headerPlacements = [];
+            let nextHeaderIndex = 1;
 
-            headerPlacements.push({
-                ...placement,
-                scope,
-                id: ensureHeaderId(placement.cell, this.id || this.#instanceId, nextHeaderIndex),
-            });
-            nextHeaderIndex += 1;
-        }
+            for (const placement of placements) {
+                if (placement.cell.tagName !== "TH") {
+                    continue;
+                }
 
-        headerPlacements.sort(sortPlacementsInDocumentOrder);
+                const scope = inferHeaderScope(placement.cell, placement, {
+                    columnHeadersEnabled,
+                    rowHeadersEnabled,
+                    rowHeaderColumnIndex,
+                });
 
-        for (const placement of placements) {
-            if (placement.cell.tagName !== "TD") {
-                continue;
+                if (scope) {
+                    if (placement.cell.getAttribute("scope") !== scope) {
+                        placement.cell.setAttribute("scope", scope);
+                    }
+                }
+
+                headerPlacements.push({
+                    ...placement,
+                    scope,
+                    id: ensureHeaderId(placement.cell, this.id || this.#instanceId, nextHeaderIndex),
+                });
+                nextHeaderIndex += 1;
             }
 
-            const associatedHeaders = headerPlacements.filter((header) => {
-                switch (header.scope) {
-                    case "col":
-                    case "colgroup":
-                        return (
-                            header.rowIndex < placement.rowIndex
-                            && header.columnIndex < placement.columnIndex + placement.colSpan
-                            && header.columnIndex + header.colSpan > placement.columnIndex
-                        );
-                    case "row":
-                    case "rowgroup":
-                        return (
-                            header.columnIndex < placement.columnIndex
-                            && header.rowIndex < placement.rowIndex + placement.rowSpan
-                            && header.rowIndex + header.rowSpan > placement.rowIndex
-                        );
-                    default:
-                        return false;
+            headerPlacements.sort(sortPlacementsInDocumentOrder);
+
+            for (const placement of placements) {
+                if (placement.cell.tagName !== "TD") {
+                    continue;
                 }
-            });
 
-            if (associatedHeaders.length === 0) {
-                if (placement.cell.hasAttribute(MANAGED_HEADERS_ATTRIBUTE)) {
-                    placement.cell.removeAttribute("headers");
-                    placement.cell.removeAttribute(MANAGED_HEADERS_ATTRIBUTE);
+                const associatedHeaders = headerPlacements.filter((header) => {
+                    switch (header.scope) {
+                        case "col":
+                        case "colgroup":
+                            return (
+                                header.rowIndex < placement.rowIndex
+                                && header.columnIndex < placement.columnIndex + placement.colSpan
+                                && header.columnIndex + header.colSpan > placement.columnIndex
+                            );
+                        case "row":
+                        case "rowgroup":
+                            return (
+                                header.columnIndex < placement.columnIndex
+                                && header.rowIndex < placement.rowIndex + placement.rowSpan
+                                && header.rowIndex + header.rowSpan > placement.rowIndex
+                            );
+                        default:
+                            return false;
+                    }
+                });
+
+                if (associatedHeaders.length === 0) {
+                    if (placement.cell.hasAttribute(MANAGED_HEADERS_ATTRIBUTE)) {
+                        placement.cell.removeAttribute("headers");
+                        placement.cell.removeAttribute(MANAGED_HEADERS_ATTRIBUTE);
+                    }
+
+                    continue;
                 }
 
-                continue;
-            }
+                if (
+                    placement.cell.hasAttribute("headers")
+                    && !placement.cell.hasAttribute(MANAGED_HEADERS_ATTRIBUTE)
+                ) {
+                    continue;
+                }
 
-            if (
-                placement.cell.hasAttribute("headers")
-                && !placement.cell.hasAttribute(MANAGED_HEADERS_ATTRIBUTE)
-            ) {
-                continue;
-            }
+                const nextHeaders = associatedHeaders.map((header) => header.id).join(" ");
 
-            placement.cell.setAttribute(
-                "headers",
-                associatedHeaders.map((header) => header.id).join(" "),
-            );
-            placement.cell.setAttribute(MANAGED_HEADERS_ATTRIBUTE, "");
+                if (placement.cell.getAttribute("headers") !== nextHeaders) {
+                    placement.cell.setAttribute("headers", nextHeaders);
+                }
+
+                if (!placement.cell.hasAttribute(MANAGED_HEADERS_ATTRIBUTE)) {
+                    placement.cell.setAttribute(MANAGED_HEADERS_ATTRIBUTE, "");
+                }
+            }
+        } finally {
+            this.#startObserving();
         }
     }
 
@@ -522,22 +577,25 @@ export class TableElement extends HTMLElementBase {
             this.#scheduleRefresh();
         });
 
-        this.#observer.observe(this, {
-            childList: true,
-            subtree: true,
-            characterData: true,
-            attributes: true,
-            attributeFilter: [
-                "aria-describedby",
-                "aria-label",
-                "aria-labelledby",
-                "colspan",
-                "headers",
-                "id",
-                "rowspan",
-                "scope",
-            ],
-        });
+        this.#startObserving();
+    }
+
+    #startObserving() {
+        if (!this.#observer || this.#observing) {
+            return;
+        }
+
+        this.#observer.observe(this, TABLE_OBSERVER_OPTIONS);
+        this.#observing = true;
+    }
+
+    #stopObserving() {
+        if (!this.#observer || !this.#observing) {
+            return;
+        }
+
+        this.#observer.disconnect();
+        this.#observing = false;
     }
 }
 

package/components/basic-toast/index.d.ts

@@ -0,0 +1,65 @@
+export const TOAST_TAG_NAME: "basic-toast";
+
+/**
+ * Normalizes unsupported or empty labels back to the default `"Toast"`.
+ */
+export function normalizeToastLabel(
+    value?: string | null,
+): string;
+
+/**
+ * Normalizes unsupported live-region values back to `"polite"`.
+ */
+export function normalizeToastLive(
+    value?: string | null,
+): "assertive" | "polite";
+
+/**
+ * Maps a toast live setting to the matching ARIA role.
+ */
+export function getToastRoleForLive(
+    value?: string | null,
+): "alert" | "status";
+
+/**
+ * Normalizes the optional `data-duration` attribute into milliseconds.
+ * A value of `0` disables auto-dismiss.
+ */
+export function normalizeToastDuration(
+    value?: string | null,
+): number;
+
+/**
+ * Normalizes the optional `data-open` attribute into a boolean flag.
+ */
+export function normalizeToastOpen(
+    value?: string | null,
+): boolean;
+
+/**
+ * Custom element that upgrades trigger-and-panel markup into a toast
+ * notification flow with optional auto-dismiss.
+ *
+ * Attributes:
+ * - `data-label`: fallback accessible name when the toast has no title
+ * - `data-live`: chooses between `status` and `alert` semantics
+ * - `data-duration`: auto-dismiss timeout in milliseconds, `0` disables it
+ * - `data-open`: optional initial open state
+ *
+ * Behavior:
+ * - uses the Popover API in manual mode when available so the toast panel can
+ *   render in the top layer
+ */
+export class ToastElement extends HTMLElement {
+    static observedAttributes: string[];
+    show(opener?: HTMLElement | null): boolean;
+    hide(): boolean;
+    toggle(opener?: HTMLElement | null): boolean;
+}
+
+/**
+ * Registers the `basic-toast` custom element if it is not already defined.
+ */
+export function defineToast(
+    registry?: CustomElementRegistry,
+): typeof ToastElement;