@tai42/studio-sdk 0.2.0

package/dist/components/scroll-region.js

@@ -0,0 +1,574 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * `ScrollRegion` — a horizontally scrollable container that becomes a keyboard
+ * target ONLY while it actually overflows.
+ *
+ * A pane that scrolls must be reachable without a pointer (WCAG 2.1.1), which
+ * needs `tabIndex`, `role="region"` and a name. Applying those unconditionally
+ * would litter every screen with phantom landmarks and dead tab stops for tables
+ * that happen to fit, so the attributes are driven by a live measurement:
+ * `scrollWidth > clientWidth`, re-taken whenever the container or its content
+ * resizes and whenever the content is replaced.
+ *
+ * `useOverflowRegion` is the same measurement for a component that IS its own
+ * scrolling box (a `<pre>`, a JSON pane) and therefore cannot be wrapped in a
+ * `<div>` without gaining a second scroller. `useProseScrollRegions` applies the
+ * rules to the surfaces React never renders — the tables and code blocks inside
+ * `dangerouslySetInnerHTML` (rendered README/markdown), which cannot be wrapped
+ * in a component and are therefore instrumented imperatively.
+ *
+ * Both hooks hand back a CALLBACK REF for the element they measure, rather than
+ * reading one the caller holds: a ref object tells a hook nothing about WHEN it
+ * is filled, so a hook that read one would never instrument an element that
+ * mounts later than the hook (a README that arrives with the second render) and
+ * would never notice one being swapped for another.
+ */
+import { useCallback, useState } from 'react';
+/**
+ * The names for a prose surface that has no heading above it.
+ *
+ * They say what the surface IS and nothing about which document it came from,
+ * because this hook cannot know: it instruments whatever markup the caller
+ * injected. A default that named one document put that document's name on every
+ * caller's regions, and a region a reader hears the wrong name for is worse than
+ * a plain one. A caller that CAN say which document it is showing passes its own
+ * `labels`; a surface with a heading above it takes that heading instead, which
+ * is the usual case.
+ */
+const DEFAULT_PROSE_LABELS = { table: 'Table', pre: 'Code block' };
+const HEADING_SELECTOR = 'h1, h2, h3, h4, h5, h6';
+/**
+ * Headings AND the surfaces they name, in one selector: a single query returns
+ * both interleaved in document order, which is what lets one walk name every
+ * surface (see `labelledProseSurfaces`).
+ */
+const PROSE_SURFACE_SELECTOR = `${HEADING_SELECTOR}, table, pre`;
+const SCROLL_REGION_CLASS = 'tai-scroll-region';
+/**
+ * The most surfaces one rendered document is given regions for.
+ *
+ * The prose is publisher-authored and unbounded in length, and every region is
+ * an entry in the landmark list a screen-reader user navigates the page by: a
+ * README with more surfaces than this turns that list into the very thing the
+ * regions exist to spare a reader. Past the cap a table still gets its scrolling
+ * wrapper — the wrapper is what keeps it inside the column — but no name and no
+ * tab stop, so the landmark list stays a list a person can read.
+ */
+const MAX_PROSE_REGIONS = 200;
+function overflows(element) {
+    return element.scrollWidth > element.clientWidth;
+}
+/**
+ * Whether the element should carry the region attributes right now.
+ *
+ * A region that stops overflowing keeps its tab stop for as long as it holds
+ * focus: taking `tabindex` off the focused element drops the reader onto the
+ * document body, and a window resize is not their doing. Only an element that
+ * already has the stop can be the active element, so this can hold a stop open
+ * but never invent one.
+ */
+function needsRegion(element) {
+    return overflows(element) || element.ownerDocument.activeElement === element;
+}
+/**
+ * Attaches `element` to a consumer ref of either form, and returns the detach
+ * for it. A callback ref that answers with its own cleanup gets that cleanup
+ * called rather than a second call with `null` — the contract React itself
+ * follows for a ref it owns.
+ */
+function attachRef(ref, element) {
+    if (ref === undefined || ref === null)
+        return () => undefined;
+    if (typeof ref !== 'function') {
+        ref.current = element;
+        return () => {
+            ref.current = null;
+        };
+    }
+    const cleanup = ref(element);
+    if (typeof cleanup === 'function')
+        return cleanup;
+    return () => {
+        ref(null);
+    };
+}
+/**
+ * The handlers waiting on each observed element. A SET, not a single handler:
+ * one element can be both a box and another box's child — a `<pre>` inside a
+ * `ScrollRegion` is exactly that — and both owners must still hear its resize.
+ */
+const resizeHandlers = new WeakMap();
+let sharedResize;
+function sharedResizeObserver() {
+    sharedResize ??= new ResizeObserver((entries) => {
+        // A box and its children are observed separately, so one frame can deliver
+        // several entries owned by the same handler; measuring once is enough.
+        const fired = new Set();
+        for (const entry of entries) {
+            for (const handler of resizeHandlers.get(entry.target) ?? [])
+                fired.add(handler);
+        }
+        for (const handler of fired)
+            handler();
+    });
+    return sharedResize;
+}
+/**
+ * Registers `handler` for `target`'s resizes, observing the element only the
+ * first time anyone asks for it: re-observing an element already under a
+ * `ResizeObserver` re-arms its initial notification, which spends a forced
+ * layout on a measurement nobody asked for.
+ */
+function holdResizeTarget(target, handler) {
+    const handlers = resizeHandlers.get(target);
+    if (handlers !== undefined) {
+        handlers.add(handler);
+        return;
+    }
+    // Registered before the element is observed, so the initial notification the
+    // observation arms reaches the handler that asked for it.
+    resizeHandlers.set(target, new Set([handler]));
+    sharedResizeObserver().observe(target);
+}
+/** Stops observing `target` for `handler`, and entirely once nobody wants it. */
+function releaseResizeTarget(target, handler) {
+    const handlers = resizeHandlers.get(target);
+    if (handlers === undefined)
+        return;
+    handlers.delete(handler);
+    if (handlers.size > 0)
+        return;
+    resizeHandlers.delete(target);
+    sharedResizeObserver().unobserve(target);
+}
+/** What a box wants to hear about: its content replaced, appended or edited. */
+const CONTENT_OBSERVER_INIT = {
+    childList: true,
+    subtree: true,
+    characterData: true,
+};
+/**
+ * The handlers waiting on each observed box, and the boxes the shared observer
+ * currently holds. Keyed by `Node` because a `characterData` record names the
+ * TEXT node that changed, and the walk to the box that owns it goes through
+ * whatever nodes lie between.
+ */
+const contentHandlers = new WeakMap();
+const contentTargets = new Set();
+let sharedContent;
+/** Registrations the shared observer still holds for released boxes. */
+let staleContentTargets = 0;
+function deliverContentRecords(records) {
+    const fired = new Set();
+    for (const record of records) {
+        // A `childList` record names the changed parent and a `characterData` record
+        // the text node itself, either of them at any depth under a box. Every box
+        // on the ancestor chain therefore owns the change, exactly as a separate
+        // observer on each of them would have seen it — a `<pre>` inside a
+        // `ScrollRegion` measures both.
+        for (let node = record.target; node !== null; node = node.parentNode) {
+            for (const handler of contentHandlers.get(node) ?? [])
+                fired.add(handler);
+        }
+    }
+    for (const handler of fired)
+        handler();
+}
+function sharedContentObserver() {
+    sharedContent ??= new MutationObserver(deliverContentRecords);
+    return sharedContent;
+}
+function holdContentTarget(target, handler) {
+    let handlers = contentHandlers.get(target);
+    if (handlers === undefined) {
+        handlers = new Set();
+        contentHandlers.set(target, handlers);
+        contentTargets.add(target);
+        sharedContentObserver().observe(target, CONTENT_OBSERVER_INIT);
+    }
+    handlers.add(handler);
+}
+/**
+ * Stops watching `target`'s content for `handler`.
+ *
+ * `MutationObserver` has no `unobserve`: the only way to drop one registration
+ * is to disconnect the observer and re-observe everything else, which would cost
+ * one registration per surviving box every time a box unmounts. A released box
+ * is therefore dropped from the handler map at once — its records find no
+ * handler and are ignored — and the observer is rebuilt only once the dead
+ * registrations outnumber the live ones, which keeps the total registration work
+ * proportional to the number of mounts. Records already queued survive the
+ * rebuild: they are taken off the observer and delivered by hand.
+ */
+function releaseContentTarget(target, handler) {
+    const handlers = contentHandlers.get(target);
+    if (handlers === undefined)
+        return;
+    handlers.delete(handler);
+    if (handlers.size > 0)
+        return;
+    contentHandlers.delete(target);
+    contentTargets.delete(target);
+    staleContentTargets += 1;
+    if (staleContentTargets <= contentTargets.size)
+        return;
+    const observer = sharedContentObserver();
+    const queued = observer.takeRecords();
+    observer.disconnect();
+    staleContentTargets = 0;
+    for (const live of contentTargets)
+        observer.observe(live, CONTENT_OBSERVER_INIT);
+    if (queued.length > 0)
+        deliverContentRecords(queued);
+}
+/**
+ * The conditional region attributes for a scrolling box, alongside the ref that
+ * names it. The ref must go on the scrolling box ITSELF — a `<pre>`, a JSON
+ * pane, or the `div` `ScrollRegion` renders. Use the hook when wrapping the
+ * content in a `ScrollRegion` would give the surface a second scroller.
+ *
+ * The box is measured as it is attached, whenever it or any child resizes, and
+ * whenever its content changes — replaced, appended, or edited in place. A
+ * replaced child is a NEW element, so the registration is re-pointed at the
+ * current children before each measurement, adding and dropping only the ones
+ * that actually changed; both sides of that are registrations on the shared
+ * observers, not observers of this mount's own. The only DOM change a
+ * measurement can cause is the region ATTRIBUTES this hook returns, and
+ * attributes are deliberately left unobserved — that, not an absence of
+ * mutation, is what stops the pair from re-triggering each other.
+ *
+ * @param ref - a consumer ref that wants the same element, or `undefined`.
+ * @param label - its accessible name, applied only while it actually scrolls.
+ */
+export function useOverflowRegion(ref, label) {
+    const [scrollable, setScrollable] = useState(false);
+    // Attached and released with the element, so a box that mounts later than the
+    // hook, or is swapped for another, is instrumented exactly once either way.
+    const measuredRef = useCallback((box) => {
+        const detachConsumer = attachRef(ref, box);
+        const measure = () => {
+            setScrollable(needsRegion(box));
+        };
+        // The box gives resize; its children give the overflowing width. The
+        // shared observer is released target by target rather than disconnected,
+        // because every other scrolling box on the page is registered on the same
+        // one — and only the targets that actually came or went are touched, so an
+        // edit in place re-registers nothing and costs one measurement.
+        let observed = [];
+        const observeAll = () => {
+            const current = [box, ...box.children];
+            const kept = new Set(current);
+            for (const target of observed) {
+                if (!kept.has(target))
+                    releaseResizeTarget(target, measure);
+            }
+            for (const target of current)
+                holdResizeTarget(target, measure);
+            observed = current;
+            measure();
+        };
+        // The whole subtree, text included: content is as often EDITED IN PLACE —
+        // a longer code string, a different JSON body — as it is replaced, and
+        // React reuses the element when it does, so watching the direct child list
+        // alone would freeze the measurement at whatever the first content needed.
+        // ATTRIBUTES are deliberately absent: the region attributes are what a
+        // measurement writes, and observing them would make each pass trigger the
+        // next.
+        holdContentTarget(box, observeAll);
+        observeAll();
+        // A stop held open only because the box had focus outlives its reason the
+        // moment the reader leaves, so re-measure then and let it go.
+        const releaseHeldStop = () => {
+            measure();
+        };
+        box.addEventListener('blur', releaseHeldStop);
+        return () => {
+            for (const target of observed)
+                releaseResizeTarget(target, measure);
+            observed = [];
+            releaseContentTarget(box, observeAll);
+            box.removeEventListener('blur', releaseHeldStop);
+            detachConsumer();
+        };
+    }, [ref]);
+    if (!scrollable)
+        return { ref: measuredRef };
+    return { ref: measuredRef, tabIndex: 0, role: 'region', 'aria-label': label };
+}
+export function ScrollRegion({ label, children, className, style, 'data-testid': testId, ref, }) {
+    const region = useOverflowRegion(ref, label);
+    return (_jsx("div", { className: className === undefined ? SCROLL_REGION_CLASS : `${SCROLL_REGION_CLASS} ${className}`, style: style, "data-testid": testId, ...region, children: children }));
+}
+/**
+ * The wrapper a prose table sits inside, creating it on first pass. Idempotent:
+ * a table already inside a `.tai-scroll-region` keeps the wrapper it has.
+ */
+function ensureScrollWrapper(table) {
+    const parent = table.parentElement;
+    if (parent?.classList.contains(SCROLL_REGION_CLASS) === true)
+        return parent;
+    const wrapper = table.ownerDocument.createElement('div');
+    wrapper.className = SCROLL_REGION_CLASS;
+    table.replaceWith(wrapper);
+    wrapper.append(table);
+    return wrapper;
+}
+/**
+ * The text of the last heading in `headings` that does not ENCLOSE `surface`.
+ *
+ * A heading wrapping the surface does precede it in document order, but it is
+ * not a section the surface sits UNDER, so it is stepped over in favour of the
+ * heading before it — which is the answer an outward walk from the surface
+ * reaches. In well-formed prose no heading contains a table or a code block, so
+ * this returns the last heading on the first look.
+ */
+function namingHeadingText(headings, surface) {
+    for (let index = headings.length - 1; index >= 0; index -= 1) {
+        const heading = headings[index];
+        if (heading !== undefined && !heading.element.contains(surface))
+            return heading.text;
+    }
+    return undefined;
+}
+/**
+ * Every scrollable prose surface under `root` — each `<table>` and each `<pre>`
+ * — paired with the text of the nearest heading PRECEDING it, or `undefined`
+ * when no heading does.
+ *
+ * One query returns the headings and the surfaces interleaved in document order,
+ * so a single walk over that list names all of them: the heading a surface
+ * belongs to is the last one seen before reaching it. Naming each surface by
+ * searching backwards from it instead would re-read the same prose once per
+ * surface, at a cost that grows with the product of the two.
+ *
+ * Blank headings never enter the list, so a decorative empty heading names
+ * nothing and the section above it is used instead. A heading INSIDE a surface
+ * (a `<pre>` or a table cell holding one) comes AFTER that surface in document
+ * order and so can never name it, though it does name later surfaces — exactly
+ * as being the last heading before them implies.
+ *
+ * Read in full before the pass wraps anything, and safely so: a name depends
+ * only on what PRECEDES its surface, and `ensureScrollWrapper` puts the wrapper
+ * in the table's own place, moving nothing else and leaving every heading where
+ * it was — so a name stays true whether its table is wrapped yet or not.
+ */
+function labelledProseSurfaces(root) {
+    const headings = [];
+    const surfaces = [];
+    for (const node of root.querySelectorAll(PROSE_SURFACE_SELECTOR)) {
+        if (node.matches(HEADING_SELECTOR)) {
+            // textContent is nullable under strict DOM typings; the local eslint
+            // profile assumes non-null, so the necessary guard trips its rule.
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            const text = (node.textContent ?? '').trim();
+            if (text !== '')
+                headings.push({ element: node, text });
+            continue;
+        }
+        surfaces.push({ element: node, heading: namingHeadingText(headings, node) });
+    }
+    return surfaces;
+}
+/**
+ * The same surfaces, each given a name no other one in the list carries.
+ *
+ * A name is only as useful as it is distinguishing, and one heading names every
+ * surface under it: two wide tables in one section, or two code blocks under no
+ * heading at all, would otherwise be two landmarks a reader hears identically
+ * and cannot choose between. A name more than one surface claims is therefore
+ * numbered, in document order, and a name only one surface claims is left alone.
+ */
+function uniquelyNamed(boxes) {
+    const claims = new Map();
+    for (const { name } of boxes)
+        claims.set(name, (claims.get(name) ?? 0) + 1);
+    const taken = new Map();
+    return boxes.map(({ surface, name }) => {
+        if (claims.get(name) === 1)
+            return { surface, label: name };
+        const ordinal = (taken.get(name) ?? 0) + 1;
+        taken.set(name, ordinal);
+        return { surface, label: `${name} (${String(ordinal)})` };
+    });
+}
+/** Strips the region attributes from a surface that is not a region now. */
+function clearScrollRegionAttributes(wrapper) {
+    wrapper.removeAttribute('tabindex');
+    wrapper.removeAttribute('role');
+    wrapper.removeAttribute('aria-label');
+}
+/** Applies the same conditional attribute set `ScrollRegion` renders. */
+function applyScrollRegionAttributes(wrapper, label, scrolling) {
+    if (!scrolling) {
+        clearScrollRegionAttributes(wrapper);
+        return;
+    }
+    wrapper.setAttribute('tabindex', '0');
+    wrapper.setAttribute('role', 'region');
+    wrapper.setAttribute('aria-label', label);
+}
+/**
+ * Re-applies the region attributes to `tracked`, reading ALL of them before
+ * writing any.
+ *
+ * `needsRegion` reads `scrollWidth`, which forces layout if anything has been
+ * written since the last one — so measuring and writing surface by surface makes
+ * the browser re-lay-out the prose once per surface, every time. Two phases cost
+ * one layout for the whole batch however many surfaces it holds.
+ */
+function refreshRegions(tracked) {
+    const scrolling = tracked.map((entry) => needsRegion(entry.surface));
+    for (const [index, entry] of tracked.entries()) {
+        applyScrollRegionAttributes(entry.surface, entry.label, scrolling[index] === true);
+    }
+}
+/**
+ * Instruments the scrollable surfaces under the element the returned ref is
+ * attached to — every `<table>` and every `<pre>` — as scroll regions. React
+ * cannot wrap markup it did not create, so this walks the DOM instead. A table
+ * is moved into a `div.tai-scroll-region` (once — the pass is idempotent)
+ * because the table itself is not the scrolling box; a `<pre>` already IS its
+ * own scrolling box, so it is instrumented in place. Either way the scrolling
+ * element carries the same conditional `tabindex`/`role`/`aria-label` as
+ * `ScrollRegion`.
+ *
+ * The name is the nearest heading preceding the surface — read for all of them
+ * in one document-order pass — so a reader landing on the region hears which
+ * section it belongs to; `labels` covers a surface with no heading above it, and
+ * a name shared by several surfaces is numbered so no two regions answer to the
+ * same one.
+ *
+ * The pass runs from the ref callback rather than an effect, which puts it in
+ * the commit phase, BEFORE the browser paints: `.tai-prose table` is
+ * `width: 100%` with no overflow of its own — the scroller exists only on the
+ * wrapper this builds — so a pass that ran after paint would show one frame at
+ * 320/360 px with the table overflowing the document, then jolt sideways. A
+ * passive-effect probe measured exactly that: at first paint wrappers=0 and the
+ * table's parent was `.tai-prose`.
+ *
+ * Injected HTML is replaced wholesale when its source changes, so the pass is
+ * re-run from a `MutationObserver` on the subtree rather than on attachment
+ * alone.
+ *
+ * @param labels - the names for surfaces with no preceding heading.
+ * @returns the ref for the element whose subtree holds the injected markup.
+ */
+export function useProseScrollRegions(labels) {
+    const tableLabel = labels?.table ?? DEFAULT_PROSE_LABELS.table;
+    const preLabel = labels?.pre ?? DEFAULT_PROSE_LABELS.pre;
+    return useCallback((root) => {
+        // Every observed element, mapped to the surface whose width it reports and
+        // that surface's current name. This is what lets a resize re-measure just
+        // the surfaces that moved: an observer callback carries the elements that
+        // resized, and each of them answers here with the region it belongs to.
+        const surfaceOf = new WeakMap();
+        // What the observer holds and what wears region attributes right now. A
+        // re-instrumentation replaces the surfaces wholesale, and the elements it
+        // drops are detached ones: kept observed they would be registrations on
+        // dead nodes, kept named they would be landmarks nobody can reach.
+        let observed = new Set();
+        let instrumented = new Set();
+        // The box gives resize; its children give the overflowing width. A table
+        // that grows wider inside a parent-constrained wrapper resizes nothing
+        // else, so watching the wrapper alone would freeze the mount-time
+        // measurement. Membership of `observed` doubles as the re-observation
+        // guard: re-observing an element already under a ResizeObserver re-arms
+        // its initial notification, which would make each pass trigger the next
+        // one forever.
+        const track = (entry, next) => {
+            for (const target of [entry.surface, ...entry.surface.children]) {
+                // Rewritten even when already observed: a re-run may have found a new
+                // heading above the surface, and the name has to follow it.
+                surfaceOf.set(target, entry);
+                next.add(target);
+                if (!observed.has(target))
+                    resizeObserver.observe(target);
+            }
+        };
+        // A pass over the whole subtree. It reads the observers declared below it,
+        // which is safe because nothing calls it until both exist.
+        const instrument = () => {
+            // Wrapping mutates the subtree; pause the observer so this pass cannot
+            // re-trigger itself, and drop the records it generated before resuming.
+            mutationObserver.disconnect();
+            // Every name comes from one document-order read of the prose, taken
+            // before the first wrapper goes in. The list is a static snapshot and
+            // the surfaces in it stay the same elements: wrapping moves a table one
+            // level down, into a `div` standing exactly where the table stood, so
+            // neither the remaining entries nor the names already computed for them
+            // change. Every table is wrapped, cap or no cap — the wrapper is what
+            // keeps a `width: 100%` table inside the column.
+            const boxes = labelledProseSurfaces(root).map(({ element, heading }) => {
+                const table = element instanceof HTMLTableElement;
+                return {
+                    surface: table ? ensureScrollWrapper(element) : element,
+                    name: heading ?? (table ? tableLabel : preLabel),
+                };
+            });
+            const tracked = uniquelyNamed(boxes.slice(0, MAX_PROSE_REGIONS));
+            const next = new Set();
+            for (const entry of tracked)
+                track(entry, next);
+            for (const target of observed) {
+                if (!next.has(target))
+                    resizeObserver.unobserve(target);
+            }
+            observed = next;
+            const dropped = instrumented;
+            instrumented = new Set(tracked.map((entry) => entry.surface));
+            // Wrapping is done for every surface before the first measurement, so
+            // the whole pass costs one layout rather than one per surface.
+            refreshRegions(tracked);
+            for (const surface of dropped) {
+                if (!instrumented.has(surface) && root.contains(surface)) {
+                    clearScrollRegionAttributes(surface);
+                }
+            }
+            mutationObserver.takeRecords();
+            mutationObserver.observe(root, { childList: true, subtree: true });
+        };
+        // Only the surfaces that actually resized are re-measured. Re-running the
+        // whole instrumentation pass from here re-queried the entire prose subtree
+        // on every resize frame, and a document with many surfaces spends that
+        // cost once per frame for the whole time a pane is being dragged.
+        const resizeObserver = new ResizeObserver((entries) => {
+            // A surface and its children are observed separately, so one frame can
+            // deliver several entries naming the same region; measuring it once is
+            // enough.
+            const affected = new Map();
+            for (const entry of entries) {
+                const tracked = surfaceOf.get(entry.target);
+                if (tracked !== undefined)
+                    affected.set(tracked.surface, tracked);
+            }
+            refreshRegions([...affected.values()]);
+        });
+        const mutationObserver = new MutationObserver(instrument);
+        // A stop held open only because the region had focus outlives its reason
+        // the moment the reader leaves. `focusout` bubbles, so one listener on the
+        // root covers every instrumented surface under it, however often they are
+        // replaced; the attribute pair is exactly what this hook writes, so it is
+        // also what identifies a region among the prose's other focusable content.
+        const releaseHeldStop = (event) => {
+            const left = event.target;
+            if (!(left instanceof HTMLElement))
+                return;
+            if (left.getAttribute('role') !== 'region' || !left.hasAttribute('tabindex'))
+                return;
+            // The stop being released belongs to exactly one region, so re-measure
+            // that one rather than re-walking the prose. A region this hook did not
+            // instrument is not ours to release.
+            const tracked = surfaceOf.get(left);
+            if (tracked !== undefined)
+                refreshRegions([tracked]);
+        };
+        root.addEventListener('focusout', releaseHeldStop);
+        instrument();
+        return () => {
+            resizeObserver.disconnect();
+            mutationObserver.disconnect();
+            root.removeEventListener('focusout', releaseHeldStop);
+        };
+    }, [tableLabel, preLabel]);
+}
+//# sourceMappingURL=scroll-region.js.map

package/dist/components/scroll-region.js.map

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

package/dist/components/select.d.ts

@@ -0,0 +1,53 @@
+export interface SelectOption {
+    readonly value: string;
+    readonly label: string;
+    readonly disabled?: boolean;
+}
+/** A labelled cluster of options (e.g. tools grouped by tag). */
+export interface SelectGroup {
+    readonly label: string;
+    readonly options: readonly SelectOption[];
+}
+/** Everything the two listbox shapes have in common. */
+interface SelectSharedProps {
+    readonly value?: string;
+    readonly defaultValue?: string;
+    readonly onValueChange?: (value: string) => void;
+    readonly placeholder?: string;
+    readonly disabled?: boolean;
+    readonly name?: string;
+    /**
+     * Accessible name for the trigger when it is not wired to an enclosing
+     * `Field`. A `Field` wins where both are given — it names the trigger from
+     * visible text, and `aria-label` would override that native label and leave
+     * the visible text out of the accessible name (WCAG 2.5.3).
+     */
+    readonly 'aria-label'?: string;
+}
+/** The FLAT listbox: one ungrouped run of options. */
+export interface SelectProps extends SelectSharedProps {
+    readonly options: readonly SelectOption[];
+}
+/** The GROUPED listbox: labelled clusters, each carrying its own options. */
+export interface SelectGroupsProps extends SelectSharedProps {
+    readonly groups: readonly SelectGroup[];
+}
+/**
+ * What `Select` ACCEPTS: exactly one of the two shapes, never both. Only one
+ * list can be rendered, so accepting `options` alongside `groups` means
+ * discarding every entry of the other without a word.
+ *
+ * The exclusion lives HERE and not on the two interfaces because both are
+ * published plugin API and must stay extendable: `groups?: undefined` written
+ * onto `SelectProps` makes `interface MyPicker extends SelectProps { groups:
+ * readonly SelectGroup[] }` a TS2430, and a union cannot be `extends`-ed at all
+ * (TS2312).
+ */
+type SelectArgs = (SelectProps & {
+    readonly groups?: undefined;
+}) | (SelectGroupsProps & {
+    readonly options?: undefined;
+});
+export declare function Select(props: SelectArgs): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=select.d.ts.map

package/dist/components/select.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select.d.ts","sourceRoot":"","sources":["../../src/components/select.tsx"],"names":[],"mappings":"AAiBA,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,iEAAiE;AACjE,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,SAAS,YAAY,EAAE,CAAC;CAC3C;AAED,wDAAwD;AACxD,UAAU,iBAAiB;IACzB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACjD,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,sDAAsD;AACtD,MAAM,WAAW,WAAY,SAAQ,iBAAiB;IACpD,QAAQ,CAAC,OAAO,EAAE,SAAS,YAAY,EAAE,CAAC;CAC3C;AAED,6EAA6E;AAC7E,MAAM,WAAW,iBAAkB,SAAQ,iBAAiB;IAC1D,QAAQ,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,CAAC;CACzC;AAED;;;;;;;;;;GAUG;AACH,KAAK,UAAU,GACX,CAAC,WAAW,GAAG;IAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAA;CAAE,CAAC,GAC/C,CAAC,iBAAiB,GAAG;IAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,CAAA;CAAE,CAAC,CAAC;AAiB3D,wBAAgB,MAAM,CAAC,KAAK,EAAE,UAAU,+BA8DvC"}